eeprom.c 10.1 KB
Newer Older
1 2 3 4 5 6 7
#include "types.h"
#include "i2c.h"
#include "eeprom.h"
#include "board.h"
#include "syscon.h"

/*
8 9
 * 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
10 11 12
 * 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
 * ----------------------------------------------
 * | cal_ph_trans (4B) | SFP 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
 *
 * Fields description:
26
 * cal_ph_trans       - t2/t4 phase transition value (got from measure_t24p() ), contains
27
 *                      _valid_ bit (MSB) and 31 bits of cal_phase_transition value
28
 * count              - how many SFPs are described in the list (binary)
29
 * SFP(n) part number - SFP PN as read from SFP's EEPROM (e.g. AXGE-1254-0531)
30
 *                      (16 ascii chars)
31
 * checksum           - low order 8 bits of the sum of all bytes for the SFP(PN,alpha,dTx,dRx)
32 33 34
 *
 */

35 36 37 38 39 40 41 42 43 44 45 46 47
/*
 * 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'.....      |
 * |                                              |
 * |                                              |
 * ------------------------------------------------
 */

48 49 50 51
uint8_t has_eeprom = 0;

uint8_t eeprom_present(uint8_t i2cif, uint8_t i2c_addr)
{
52
	has_eeprom = 1;
53 54
	if (!mi2c_devprobe(i2cif, i2c_addr))
		if (!mi2c_devprobe(i2cif, i2c_addr))
55 56 57 58
			has_eeprom = 0;

	return 0;
}
59

60 61
int eeprom_read(uint8_t i2cif, uint8_t i2c_addr, uint32_t offset, uint8_t * buf,
		size_t size)
62 63 64 65
{
	int i;
	unsigned char c;

66
	if (!has_eeprom)
67 68
		return -1;

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
	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;
87 88
}

89 90
int eeprom_write(uint8_t i2cif, uint8_t i2c_addr, uint32_t offset,
		 uint8_t * buf, size_t size)
91 92 93
{
	int i, busy;

94
	if (!has_eeprom)
95 96
		return -1;

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

100 101 102 103
		if (mi2c_put_byte(i2cif, i2c_addr << 1) < 0) {
			mi2c_stop(i2cif);
			return -1;
		}
104 105 106 107 108 109
		mi2c_put_byte(i2cif, (offset >> 8) & 0xff);
		mi2c_put_byte(i2cif, offset & 0xff);
		mi2c_put_byte(i2cif, *buf++);
		offset++;
		mi2c_stop(i2cif);

110 111
		do {		/* wait until the chip becomes ready */
			mi2c_start(i2cif);
112 113
			busy = mi2c_put_byte(i2cif, i2c_addr << 1);
			mi2c_stop(i2cif);
114
		} while (busy);
115 116

	}
117
	return size;
118
}
119

120 121
int32_t eeprom_sfpdb_erase(uint8_t i2cif, uint8_t i2c_addr)
{
122
	uint8_t sfpcount = 0;
123

124 125 126 127 128 129
	//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;
130 131
}

132 133
int32_t eeprom_get_sfp(uint8_t i2cif, uint8_t i2c_addr, struct s_sfpinfo * sfp,
		       uint8_t add, uint8_t pos)
134
{
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 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
	static uint8_t sfpcount = 0;
	uint8_t i, chksum = 0;
	uint8_t *ptr;

	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) {
		if (eeprom_read(i2cif, i2c_addr,
				EE_BASE_SFP + sizeof(sfpcount)
				+ pos * sizeof(struct s_sfpinfo),
				(uint8_t*)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)
			EE_RET_CORRPT;
	} else {
		/*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),
			     (uint8_t *) sfp, sizeof(struct s_sfpinfo));
		sfpcount++;
		eeprom_write(i2cif, i2c_addr, EE_BASE_SFP, &sfpcount,
			     sizeof(sfpcount));
	}

	return sfpcount;
185 186
}

187
int8_t eeprom_match_sfp(uint8_t i2cif, uint8_t i2c_addr, struct s_sfpinfo * sfp)
188
{
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
	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;
212
}
213

214 215
int8_t eeprom_phtrans(uint8_t i2cif, uint8_t i2c_addr, uint32_t * val,
		      uint8_t write)
216
{
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
	if (write) {
		*val |= (1 << 31);
		if (eeprom_write(i2cif, i2c_addr, EE_BASE_CAL, (uint8_t *) val,
		     sizeof(val)) != sizeof(val))
			return EE_RET_I2CERR;
		else
			return 1;
	} else {
		if (eeprom_read(i2cif, i2c_addr, EE_BASE_CAL, (uint8_t *) val,
		     sizeof(val)) != sizeof(val))
			return EE_RET_I2CERR;

		if (!(*val & (1 << 31)))
			return 0;

		*val &= 0x7fffffff;	//return ph_trans value without validity bit
		return 1;
	}
235 236
}

237 238
int8_t eeprom_init_erase(uint8_t i2cif, uint8_t i2c_addr)
{
239
	uint16_t used = 0;
240

241 242 243 244 245
	if (eeprom_write(i2cif, i2c_addr, EE_BASE_INIT, (uint8_t *) & used,
	     sizeof(used)) != sizeof(used))
		return EE_RET_I2CERR;
	else
		return used;
246 247 248 249
}

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

253 254
	if (eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, (uint8_t *) & used,
	     sizeof(used)) != sizeof(used))
255 256
		return EE_RET_I2CERR;

257 258 259 260 261 262 263
	if (used == 0xffff)
		used = 0;
	for (i = 0; i < used; ++i)
		eeprom_write(i2cif, i2c_addr, EE_BASE_INIT + sizeof(used) + i,
			     (uint8_t *) & pattern, 1);
	used = 0xffff;
	eeprom_write(i2cif, i2c_addr, EE_BASE_INIT, (uint8_t *) & used, 2);
264

265
	return used;
266 267
}

268
/*
269 270 271 272
 * 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[])
{
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 303 304 305 306 307 308 309 310 311
	uint8_t i = 1;
	char separator = ' ';
	uint16_t used, readback;

	if (eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, (uint8_t *) & 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, (uint8_t *) 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, (uint8_t *) & used,
	     sizeof(used)) != sizeof(used))
		return EE_RET_I2CERR;

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

	return 0;
312 313 314 315
}

int32_t eeprom_init_show(uint8_t i2cif, uint8_t i2c_addr)
{
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	uint16_t used, i;
	char byte;

	if (eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, (uint8_t *) & 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;
336 337
}

338 339
int8_t eeprom_init_readcmd(uint8_t i2cif, uint8_t i2c_addr, char *buf,
			   uint8_t bufsize, uint8_t next)
340
{
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
	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,
				(uint8_t *) & 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;
365
}