[people/ms/u-boot.git] / board / compulab / common / eeprom.c

/*
 * (C) Copyright 2011 CompuLab, Ltd. <www.compulab.co.il>
 *
 * Authors: Nikita Kiryanov <nikita@compulab.co.il>
 *	    Igor Grinberg <grinberg@compulab.co.il>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <i2c.h>
#include <eeprom_layout.h>
#include <eeprom_field.h>
#include <asm/setup.h>
#include <linux/kernel.h>
#include "eeprom.h"

#ifndef CONFIG_SYS_I2C_EEPROM_ADDR
# define CONFIG_SYS_I2C_EEPROM_ADDR	0x50
# define CONFIG_SYS_I2C_EEPROM_ADDR_LEN	1
#endif

#ifndef CONFIG_SYS_I2C_EEPROM_BUS
#define CONFIG_SYS_I2C_EEPROM_BUS	0
#endif

#define EEPROM_LAYOUT_VER_OFFSET	44
#define BOARD_SERIAL_OFFSET		20
#define BOARD_SERIAL_OFFSET_LEGACY	8
#define BOARD_REV_OFFSET		0
#define BOARD_REV_OFFSET_LEGACY		6
#define BOARD_REV_SIZE			2
#define PRODUCT_NAME_OFFSET		128
#define PRODUCT_NAME_SIZE		16
#define MAC_ADDR_OFFSET			4
#define MAC_ADDR_OFFSET_LEGACY		0

#define LAYOUT_INVALID	0
#define LAYOUT_LEGACY	0xff

static int cl_eeprom_bus;
static int cl_eeprom_layout; /* Implicitly LAYOUT_INVALID */

static int cl_eeprom_read(uint offset, uchar *buf, int len)
{
	int res;
	unsigned int current_i2c_bus = i2c_get_bus_num();

	res = i2c_set_bus_num(cl_eeprom_bus);
	if (res < 0)
		return res;

	res = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, offset,
			CONFIG_SYS_I2C_EEPROM_ADDR_LEN, buf, len);

	i2c_set_bus_num(current_i2c_bus);

	return res;
}

static int cl_eeprom_setup(uint eeprom_bus)
{
	int res;

	/*
	 * We know the setup was already done when the layout is set to a valid
	 * value and we're using the same bus as before.
	 */
	if (cl_eeprom_layout != LAYOUT_INVALID && eeprom_bus == cl_eeprom_bus)
		return 0;

	cl_eeprom_bus = eeprom_bus;
	res = cl_eeprom_read(EEPROM_LAYOUT_VER_OFFSET,
			     (uchar *)&cl_eeprom_layout, 1);
	if (res) {
		cl_eeprom_layout = LAYOUT_INVALID;
		return res;
	}

	if (cl_eeprom_layout == 0 || cl_eeprom_layout >= 0x20)
		cl_eeprom_layout = LAYOUT_LEGACY;

	return 0;
}

void get_board_serial(struct tag_serialnr *serialnr)
{
	u32 serial[2];
	uint offset;

	memset(serialnr, 0, sizeof(*serialnr));

	if (cl_eeprom_setup(CONFIG_SYS_I2C_EEPROM_BUS))
		return;

	offset = (cl_eeprom_layout != LAYOUT_LEGACY) ?
		BOARD_SERIAL_OFFSET : BOARD_SERIAL_OFFSET_LEGACY;

	if (cl_eeprom_read(offset, (uchar *)serial, 8))
		return;

	if (serial[0] != 0xffffffff && serial[1] != 0xffffffff) {
		serialnr->low = serial[0];
		serialnr->high = serial[1];
	}
}

/*
 * Routine: cl_eeprom_read_mac_addr
 * Description: read mac address and store it in buf.
 */
int cl_eeprom_read_mac_addr(uchar *buf, uint eeprom_bus)
{
	uint offset;
	int err;

	err = cl_eeprom_setup(eeprom_bus);
	if (err)
		return err;

	offset = (cl_eeprom_layout != LAYOUT_LEGACY) ?
			MAC_ADDR_OFFSET : MAC_ADDR_OFFSET_LEGACY;

	return cl_eeprom_read(offset, buf, 6);
}

static u32 board_rev;

/*
 * Routine: cl_eeprom_get_board_rev
 * Description: read system revision from eeprom
 */
u32 cl_eeprom_get_board_rev(uint eeprom_bus)
{
	char str[5]; /* Legacy representation can contain at most 4 digits */
	uint offset = BOARD_REV_OFFSET_LEGACY;

	if (board_rev)
		return board_rev;

	if (cl_eeprom_setup(eeprom_bus))
		return 0;

	if (cl_eeprom_layout != LAYOUT_LEGACY)
		offset = BOARD_REV_OFFSET;

	if (cl_eeprom_read(offset, (uchar *)&board_rev, BOARD_REV_SIZE))
		return 0;

	/*
	 * Convert legacy syntactic representation to semantic
	 * representation. i.e. for rev 1.00: 0x100 --> 0x64
	 */
	if (cl_eeprom_layout == LAYOUT_LEGACY) {
		sprintf(str, "%x", board_rev);
		board_rev = simple_strtoul(str, NULL, 10);
	}

	return board_rev;
};

/*
 * Routine: cl_eeprom_get_board_rev
 * Description: read system revision from eeprom
 *
 * @buf: buffer to store the product name
 * @eeprom_bus: i2c bus num of the eeprom
 *
 * @return: 0 on success, < 0 on failure
 */
int cl_eeprom_get_product_name(uchar *buf, uint eeprom_bus)
{
	int err;

	if (buf == NULL)
		return -EINVAL;

	err = cl_eeprom_setup(eeprom_bus);
	if (err)
		return err;

	err = cl_eeprom_read(PRODUCT_NAME_OFFSET, buf, PRODUCT_NAME_SIZE);
	if (!err) /* Protect ourselves from invalid data (unterminated str) */
		buf[PRODUCT_NAME_SIZE - 1] = '\0';

	return err;
}

#ifdef CONFIG_CMD_EEPROM_LAYOUT
/**
 * eeprom_field_print_bin_ver() - print a "version field" which contains binary
 *				  data
 *
 * Treat the field data as simple binary data, and print it formatted as a
 * version number (2 digits after decimal point).
 * The field size must be exactly 2 bytes.
 *
 * Sample output:
 *      Field Name      123.45
 *
 * @field:	an initialized field to print
 */
void eeprom_field_print_bin_ver(const struct eeprom_field *field)
{
	if ((field->buf[0] == 0xff) && (field->buf[1] == 0xff)) {
		field->buf[0] = 0;
		field->buf[1] = 0;
	}

	printf(PRINT_FIELD_SEGMENT, field->name);
	int major = (field->buf[1] << 8 | field->buf[0]) / 100;
	int minor = (field->buf[1] << 8 | field->buf[0]) - major * 100;
	printf("%d.%02d\n", major, minor);
}

/**
 * eeprom_field_update_bin_ver() - update a "version field" which contains
 *				   binary data
 *
 * This function takes a version string in the form of x.y (x and y are both
 * decimal values, y is limited to two digits), translates it to the binary
 * form, then writes it to the field. The field size must be exactly 2 bytes.
 *
 * This function strictly enforces the data syntax, and will not update the
 * field if there's any deviation from it. It also protects from overflow.
 *
 * @field:	an initialized field
 * @value:	a version string
 *
 * Returns 0 on success, -1 on failure.
 */
int eeprom_field_update_bin_ver(struct eeprom_field *field, char *value)
{
	char *endptr;
	char *tok = strtok(value, ".");
	if (tok == NULL)
		return -1;

	int num = simple_strtol(tok, &endptr, 0);
	if (*endptr != '\0')
		return -1;

	tok = strtok(NULL, "");
	if (tok == NULL)
		return -1;

	int remainder = simple_strtol(tok, &endptr, 0);
	if (*endptr != '\0')
		return -1;

	num = num * 100 + remainder;
	if (num >> 16)
		return -1;

	field->buf[0] = (unsigned char)num;
	field->buf[1] = num >> 8;

	return 0;
}

char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

/**
 * eeprom_field_print_date() - print a field which contains date data
 *
 * Treat the field data as simple binary data, and print it formatted as a date.
 * Sample output:
 *      Field Name      07/Feb/2014
 *      Field Name      56/BAD/9999
 *
 * @field:	an initialized field to print
 */
void eeprom_field_print_date(const struct eeprom_field *field)
{
	printf(PRINT_FIELD_SEGMENT, field->name);
	printf("%02d/", field->buf[0]);
	if (field->buf[1] >= 1 && field->buf[1] <= 12)
		printf("%s", months[field->buf[1] - 1]);
	else
		printf("BAD");

	printf("/%d\n", field->buf[3] << 8 | field->buf[2]);
}

static int validate_date(unsigned char day, unsigned char month,
			unsigned int year)
{
	int days_in_february;

	switch (month) {
	case 0:
	case 2:
	case 4:
	case 6:
	case 7:
	case 9:
	case 11:
		if (day > 31)
			return -1;
		break;
	case 3:
	case 5:
	case 8:
	case 10:
		if (day > 30)
			return -1;
		break;
	case 1:
		days_in_february = 28;
		if (year % 4 == 0) {
			if (year % 100 != 0)
				days_in_february = 29;
			else if (year % 400 == 0)
				days_in_february = 29;
		}

		if (day > days_in_february)
			return -1;

		break;
	default:
		return -1;
	}

	return 0;
}

/**
 * eeprom_field_update_date() - update a date field which contains binary data
 *
 * This function takes a date string in the form of x/Mon/y (x and y are both
 * decimal values), translates it to the binary representation, then writes it
 * to the field.
 *
 * This function strictly enforces the data syntax, and will not update the
 * field if there's any deviation from it. It also protects from overflow in the
 * year value, and checks the validity of the date.
 *
 * @field:	an initialized field
 * @value:	a date string
 *
 * Returns 0 on success, -1 on failure.
 */
int eeprom_field_update_date(struct eeprom_field *field, char *value)
{
	char *endptr;
	char *tok1 = strtok(value, "/");
	char *tok2 = strtok(NULL, "/");
	char *tok3 = strtok(NULL, "/");

	if (tok1 == NULL || tok2 == NULL || tok3 == NULL) {
		printf("%s: syntax error\n", field->name);
		return -1;
	}

	unsigned char day = (unsigned char)simple_strtol(tok1, &endptr, 0);
	if (*endptr != '\0' || day == 0) {
		printf("%s: invalid day\n", field->name);
		return -1;
	}

	unsigned char month;
	for (month = 1; month <= 12; month++)
		if (!strcmp(tok2, months[month - 1]))
			break;

	unsigned int year = simple_strtol(tok3, &endptr, 0);
	if (*endptr != '\0') {
		printf("%s: invalid year\n", field->name);
		return -1;
	}

	if (validate_date(day, month - 1, year)) {
		printf("%s: invalid date\n", field->name);
		return -1;
	}

	if (year >> 16) {
		printf("%s: year overflow\n", field->name);
		return -1;
	}

	field->buf[0] = day;
	field->buf[1] = month;
	field->buf[2] = (unsigned char)year;
	field->buf[3] = (unsigned char)(year >> 8);

	return 0;
}

#define	LAYOUT_VERSION_LEGACY 1
#define	LAYOUT_VERSION_VER1 2
#define	LAYOUT_VERSION_VER2 3
#define	LAYOUT_VERSION_VER3 4

extern struct eeprom_field layout_unknown[1];

#define DEFINE_PRINT_UPDATE(x) eeprom_field_print_##x, eeprom_field_update_##x

#ifdef CONFIG_CM_T3X
struct eeprom_field layout_legacy[5] = {
	{ "MAC address",          6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Board Revision",       2, NULL, DEFINE_PRINT_UPDATE(bin) },
	{ "Serial Number",        8, NULL, DEFINE_PRINT_UPDATE(bin) },
	{ "Board Configuration", 64, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ RESERVED_FIELDS,      176, NULL, eeprom_field_print_reserved,
					   eeprom_field_update_ascii },
};
#else
#define layout_legacy layout_unknown
#endif

#if defined(CONFIG_CM_T3X) || defined(CONFIG_CM_T3517)
struct eeprom_field layout_v1[12] = {
	{ "Major Revision",      2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "Minor Revision",      2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "1st MAC Address",     6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "2nd MAC Address",     6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Production Date",     4, NULL, DEFINE_PRINT_UPDATE(date) },
	{ "Serial Number",      12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
	{ RESERVED_FIELDS,      96, NULL, DEFINE_PRINT_UPDATE(reserved) },
	{ "Product Name",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #1", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #2", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #3", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ RESERVED_FIELDS,      64, NULL, eeprom_field_print_reserved,
					  eeprom_field_update_ascii },
};
#else
#define layout_v1 layout_unknown
#endif

struct eeprom_field layout_v2[15] = {
	{ "Major Revision",            2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "Minor Revision",            2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "1st MAC Address",           6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "2nd MAC Address",           6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Production Date",           4, NULL, DEFINE_PRINT_UPDATE(date) },
	{ "Serial Number",            12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
	{ "3rd MAC Address (WIFI)",    6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "4th MAC Address (Bluetooth)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Layout Version",            1, NULL, DEFINE_PRINT_UPDATE(bin) },
	{ RESERVED_FIELDS,            83, NULL, DEFINE_PRINT_UPDATE(reserved) },
	{ "Product Name",             16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #1",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #2",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #3",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ RESERVED_FIELDS,            64, NULL, eeprom_field_print_reserved,
						eeprom_field_update_ascii },
};

struct eeprom_field layout_v3[16] = {
	{ "Major Revision",            2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "Minor Revision",            2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
	{ "1st MAC Address",           6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "2nd MAC Address",           6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Production Date",           4, NULL, DEFINE_PRINT_UPDATE(date) },
	{ "Serial Number",            12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
	{ "3rd MAC Address (WIFI)",    6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "4th MAC Address (Bluetooth)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
	{ "Layout Version",            1, NULL, DEFINE_PRINT_UPDATE(bin) },
	{ "CompuLab EEPROM ID",        3, NULL, DEFINE_PRINT_UPDATE(bin) },
	{ RESERVED_FIELDS,            80, NULL, DEFINE_PRINT_UPDATE(reserved) },
	{ "Product Name",             16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #1",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #2",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ "Product Options #3",       16, NULL, DEFINE_PRINT_UPDATE(ascii) },
	{ RESERVED_FIELDS,            64, NULL, eeprom_field_print_reserved,
						eeprom_field_update_ascii },
};

void eeprom_layout_assign(struct eeprom_layout *layout, int layout_version)
{
	switch (layout->layout_version) {
	case LAYOUT_VERSION_LEGACY:
		layout->fields = layout_legacy;
		layout->num_of_fields = ARRAY_SIZE(layout_legacy);
		break;
	case LAYOUT_VERSION_VER1:
		layout->fields = layout_v1;
		layout->num_of_fields = ARRAY_SIZE(layout_v1);
		break;
	case LAYOUT_VERSION_VER2:
		layout->fields = layout_v2;
		layout->num_of_fields = ARRAY_SIZE(layout_v2);
		break;
	case LAYOUT_VERSION_VER3:
		layout->fields = layout_v3;
		layout->num_of_fields = ARRAY_SIZE(layout_v3);
		break;
	default:
		__eeprom_layout_assign(layout, layout_version);
	}
}

int eeprom_parse_layout_version(char *str)
{
	if (!strcmp(str, "legacy"))
		return LAYOUT_VERSION_LEGACY;
	else if (!strcmp(str, "v1"))
		return LAYOUT_VERSION_VER1;
	else if (!strcmp(str, "v2"))
		return LAYOUT_VERSION_VER2;
	else if (!strcmp(str, "v3"))
		return LAYOUT_VERSION_VER3;
	else
		return LAYOUT_VERSION_UNRECOGNIZED;
}

int eeprom_layout_detect(unsigned char *data)
{
	switch (data[EEPROM_LAYOUT_VER_OFFSET]) {
	case 0xff:
	case 0:
		return LAYOUT_VERSION_VER1;
	case 2:
		return LAYOUT_VERSION_VER2;
	case 3:
		return LAYOUT_VERSION_VER3;
	}

	if (data[EEPROM_LAYOUT_VER_OFFSET] >= 0x20)
		return LAYOUT_VERSION_LEGACY;

	return LAYOUT_VERSION_UNRECOGNIZED;
}
#endif
Commit	Line	Data
82309250 NK	1	/*
	2	* (C) Copyright 2011 CompuLab, Ltd. <www.compulab.co.il>
	3	*
	4	* Authors: Nikita Kiryanov <nikita@compulab.co.il>
	5	* Igor Grinberg <grinberg@compulab.co.il>
	6	*
1a459660	7	* SPDX-License-Identifier: GPL-2.0+
82309250 NK	8	*/
	9
	10	#include <common.h>
	11	#include <i2c.h>
8af5734b NK	12	#include <eeprom_layout.h>
8af5734b NK	13	#include <eeprom_field.h>
5d982856	14	#include <asm/setup.h>
8af5734b	15	#include <linux/kernel.h>
53af877f	16	#include "eeprom.h"
82309250	17
d3f041c0 IG	18	#ifndef CONFIG_SYS_I2C_EEPROM_ADDR
	19	# define CONFIG_SYS_I2C_EEPROM_ADDR 0x50
	20	# define CONFIG_SYS_I2C_EEPROM_ADDR_LEN 1
	21	#endif
	22
7d2f669b NK	23	#ifndef CONFIG_SYS_I2C_EEPROM_BUS
	24	#define CONFIG_SYS_I2C_EEPROM_BUS 0
	25	#endif
	26
82309250 NK	27	#define EEPROM_LAYOUT_VER_OFFSET 44
	28	#define BOARD_SERIAL_OFFSET 20
	29	#define BOARD_SERIAL_OFFSET_LEGACY 8
7d3c97d7 NK	30	#define BOARD_REV_OFFSET 0
7d3c97d7 NK	31	#define BOARD_REV_OFFSET_LEGACY 6
6f3b300c	32	#define BOARD_REV_SIZE 2
53af877f NK	33	#define PRODUCT_NAME_OFFSET 128
53af877f NK	34	#define PRODUCT_NAME_SIZE 16
e4e2bf5e NK	35	#define MAC_ADDR_OFFSET 4
e4e2bf5e NK	36	#define MAC_ADDR_OFFSET_LEGACY 0
82309250 NK	37
	38	#define LAYOUT_INVALID 0
	39	#define LAYOUT_LEGACY 0xff
	40
e7a2447b	41	static int cl_eeprom_bus;
689be5f8	42	static int cl_eeprom_layout; /* Implicitly LAYOUT_INVALID */
82309250	43
689be5f8	44	static int cl_eeprom_read(uint offset, uchar *buf, int len)
82309250	45	{
52658fda NK	46	int res;
	47	unsigned int current_i2c_bus = i2c_get_bus_num();
	48
e7a2447b	49	res = i2c_set_bus_num(cl_eeprom_bus);
52658fda NK	50	if (res < 0)
	51	return res;
	52
	53	res = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, offset,
82309250	54	CONFIG_SYS_I2C_EEPROM_ADDR_LEN, buf, len);
52658fda NK	55
	56	i2c_set_bus_num(current_i2c_bus);
	57
	58	return res;
82309250 NK	59	}
82309250 NK	60
e7a2447b	61	static int cl_eeprom_setup(uint eeprom_bus)
82309250 NK	62	{
	63	int res;
	64
e7a2447b NK	65	/*
	66	* We know the setup was already done when the layout is set to a valid
	67	* value and we're using the same bus as before.
	68	*/
	69	if (cl_eeprom_layout != LAYOUT_INVALID && eeprom_bus == cl_eeprom_bus)
82309250 NK	70	return 0;
82309250 NK	71
e7a2447b	72	cl_eeprom_bus = eeprom_bus;
689be5f8 IG	73	res = cl_eeprom_read(EEPROM_LAYOUT_VER_OFFSET,
689be5f8 IG	74	(uchar *)&cl_eeprom_layout, 1);
82309250	75	if (res) {
689be5f8	76	cl_eeprom_layout = LAYOUT_INVALID;
82309250 NK	77	return res;
	78	}
	79
689be5f8 IG	80	if (cl_eeprom_layout == 0 \|\| cl_eeprom_layout >= 0x20)
689be5f8 IG	81	cl_eeprom_layout = LAYOUT_LEGACY;
82309250 NK	82
	83	return 0;
	84	}
	85
	86	void get_board_serial(struct tag_serialnr *serialnr)
	87	{
	88	u32 serial[2];
	89	uint offset;
	90
	91	memset(serialnr, 0, sizeof(*serialnr));
689be5f8	92
e7a2447b	93	if (cl_eeprom_setup(CONFIG_SYS_I2C_EEPROM_BUS))
82309250 NK	94	return;
82309250 NK	95
689be5f8 IG	96	offset = (cl_eeprom_layout != LAYOUT_LEGACY) ?
	97	BOARD_SERIAL_OFFSET : BOARD_SERIAL_OFFSET_LEGACY;
	98
	99	if (cl_eeprom_read(offset, (uchar *)serial, 8))
82309250 NK	100	return;
	101
	102	if (serial[0] != 0xffffffff && serial[1] != 0xffffffff) {
	103	serialnr->low = serial[0];
	104	serialnr->high = serial[1];
	105	}
	106	}
7d3c97d7	107
e4e2bf5e	108	/*
689be5f8	109	* Routine: cl_eeprom_read_mac_addr
e4e2bf5e NK	110	* Description: read mac address and store it in buf.
e4e2bf5e NK	111	*/
e7a2447b	112	int cl_eeprom_read_mac_addr(uchar *buf, uint eeprom_bus)
e4e2bf5e NK	113	{
e4e2bf5e NK	114	uint offset;
e93e809f	115	int err;
e4e2bf5e	116
e93e809f NK	117	err = cl_eeprom_setup(eeprom_bus);
	118	if (err)
	119	return err;
e4e2bf5e	120
689be5f8	121	offset = (cl_eeprom_layout != LAYOUT_LEGACY) ?
e4e2bf5e	122	MAC_ADDR_OFFSET : MAC_ADDR_OFFSET_LEGACY;
689be5f8 IG	123
689be5f8 IG	124	return cl_eeprom_read(offset, buf, 6);
e4e2bf5e NK	125	}
e4e2bf5e NK	126
a937fd16 IG	127	static u32 board_rev;
a937fd16 IG	128
7d3c97d7	129	/*
689be5f8	130	* Routine: cl_eeprom_get_board_rev
8c318eb3	131	* Description: read system revision from eeprom
7d3c97d7	132	*/
72898ac7	133	u32 cl_eeprom_get_board_rev(uint eeprom_bus)
7d3c97d7	134	{
2ef6302f	135	char str[5]; /* Legacy representation can contain at most 4 digits */
7d3c97d7	136	uint offset = BOARD_REV_OFFSET_LEGACY;
7d3c97d7	137
a937fd16 IG	138	if (board_rev)
	139	return board_rev;
	140
72898ac7	141	if (cl_eeprom_setup(eeprom_bus))
7d3c97d7 NK	142	return 0;
7d3c97d7 NK	143
689be5f8	144	if (cl_eeprom_layout != LAYOUT_LEGACY)
7d3c97d7	145	offset = BOARD_REV_OFFSET;
7d3c97d7	146
a937fd16	147	if (cl_eeprom_read(offset, (uchar *)&board_rev, BOARD_REV_SIZE))
7d3c97d7 NK	148	return 0;
7d3c97d7 NK	149
2ef6302f NK	150	/*
	151	* Convert legacy syntactic representation to semantic
	152	* representation. i.e. for rev 1.00: 0x100 --> 0x64
	153	*/
689be5f8	154	if (cl_eeprom_layout == LAYOUT_LEGACY) {
a937fd16 IG	155	sprintf(str, "%x", board_rev);
a937fd16 IG	156	board_rev = simple_strtoul(str, NULL, 10);
2ef6302f NK	157	}
2ef6302f NK	158
a937fd16	159	return board_rev;
7d3c97d7	160	};
53af877f NK	161
	162	/*
	163	* Routine: cl_eeprom_get_board_rev
	164	* Description: read system revision from eeprom
	165	*
	166	* @buf: buffer to store the product name
	167	* @eeprom_bus: i2c bus num of the eeprom
	168	*
	169	* @return: 0 on success, < 0 on failure
	170	*/
	171	int cl_eeprom_get_product_name(uchar *buf, uint eeprom_bus)
	172	{
	173	int err;
	174
	175	if (buf == NULL)
	176	return -EINVAL;
	177
	178	err = cl_eeprom_setup(eeprom_bus);
	179	if (err)
	180	return err;
	181
	182	err = cl_eeprom_read(PRODUCT_NAME_OFFSET, buf, PRODUCT_NAME_SIZE);
	183	if (!err) /* Protect ourselves from invalid data (unterminated str) */
	184	buf[PRODUCT_NAME_SIZE - 1] = '\0';
	185
	186	return err;
	187	}
8af5734b NK	188
	189	#ifdef CONFIG_CMD_EEPROM_LAYOUT
	190	/**
	191	* eeprom_field_print_bin_ver() - print a "version field" which contains binary
	192	* data
	193	*
	194	* Treat the field data as simple binary data, and print it formatted as a
	195	* version number (2 digits after decimal point).
	196	* The field size must be exactly 2 bytes.
	197	*
	198	* Sample output:
	199	* Field Name 123.45
	200	*
	201	* @field: an initialized field to print
	202	*/
	203	void eeprom_field_print_bin_ver(const struct eeprom_field *field)
	204	{
	205	if ((field->buf[0] == 0xff) && (field->buf[1] == 0xff)) {
	206	field->buf[0] = 0;
	207	field->buf[1] = 0;
	208	}
	209
	210	printf(PRINT_FIELD_SEGMENT, field->name);
	211	int major = (field->buf[1] << 8 \| field->buf[0]) / 100;
	212	int minor = (field->buf[1] << 8 \| field->buf[0]) - major * 100;
	213	printf("%d.%02d\n", major, minor);
	214	}
	215
	216	/**
	217	* eeprom_field_update_bin_ver() - update a "version field" which contains
	218	* binary data
	219	*
	220	* This function takes a version string in the form of x.y (x and y are both
	221	* decimal values, y is limited to two digits), translates it to the binary
	222	* form, then writes it to the field. The field size must be exactly 2 bytes.
	223	*
	224	* This function strictly enforces the data syntax, and will not update the
	225	* field if there's any deviation from it. It also protects from overflow.
	226	*
	227	* @field: an initialized field
	228	* @value: a version string
	229	*
	230	* Returns 0 on success, -1 on failure.
	231	*/
	232	int eeprom_field_update_bin_ver(struct eeprom_field field, char value)
	233	{
	234	char *endptr;
	235	char *tok = strtok(value, ".");
	236	if (tok == NULL)
	237	return -1;
	238
	239	int num = simple_strtol(tok, &endptr, 0);
	240	if (*endptr != '\0')
	241	return -1;
	242
	243	tok = strtok(NULL, "");
	244	if (tok == NULL)
	245	return -1;
	246
	247	int remainder = simple_strtol(tok, &endptr, 0);
	248	if (*endptr != '\0')
	249	return -1;
	250
	251	num = num * 100 + remainder;
252	if (num >> 16)
253	return -1;
254
255	field->buf[0] = (unsigned char)num;
256	field->buf[1] = num >> 8;
257
258	return 0;
259	}
260
261	char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
262	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
263
264	/**
265	* eeprom_field_print_date() - print a field which contains date data
266	*
267	* Treat the field data as simple binary data, and print it formatted as a date.
268	* Sample output:
269	* Field Name 07/Feb/2014
270	* Field Name 56/BAD/9999
271	*
272	* @field: an initialized field to print
273	*/
274	void eeprom_field_print_date(const struct eeprom_field *field)
275	{
276	printf(PRINT_FIELD_SEGMENT, field->name);
277	printf("%02d/", field->buf[0]);
278	if (field->buf[1] >= 1 && field->buf[1] <= 12)
279	printf("%s", months[field->buf[1] - 1]);
280	else
281	printf("BAD");
282
283	printf("/%d\n", field->buf[3] << 8 \| field->buf[2]);
284	}
285
286	static int validate_date(unsigned char day, unsigned char month,
287	unsigned int year)
288	{
289	int days_in_february;
290
291	switch (month) {
292	case 0:
293	case 2:
294	case 4:
295	case 6:
296	case 7:
297	case 9:
298	case 11:
299	if (day > 31)
300	return -1;
301	break;
302	case 3:
303	case 5:
304	case 8:
305	case 10:
306	if (day > 30)
307	return -1;
308	break;
309	case 1:
310	days_in_february = 28;
311	if (year % 4 == 0) {
312	if (year % 100 != 0)
313	days_in_february = 29;
314	else if (year % 400 == 0)
315	days_in_february = 29;
316	}
317
318	if (day > days_in_february)
319	return -1;
320
321	break;
322	default:
323	return -1;
324	}
325
326	return 0;
327	}
328
329	/**
330	* eeprom_field_update_date() - update a date field which contains binary data
331	*
332	* This function takes a date string in the form of x/Mon/y (x and y are both
333	* decimal values), translates it to the binary representation, then writes it
334	* to the field.
335	*
336	* This function strictly enforces the data syntax, and will not update the
337	* field if there's any deviation from it. It also protects from overflow in the
338	* year value, and checks the validity of the date.
339	*
340	* @field: an initialized field
341	* @value: a date string
342	*
343	* Returns 0 on success, -1 on failure.
344	*/
345	int eeprom_field_update_date(struct eeprom_field field, char value)
346	{
347	char *endptr;
348	char *tok1 = strtok(value, "/");
349	char *tok2 = strtok(NULL, "/");
350	char *tok3 = strtok(NULL, "/");
351
352	if (tok1 == NULL \|\| tok2 == NULL \|\| tok3 == NULL) {
353	printf("%s: syntax error\n", field->name);
354	return -1;
355	}
356
357	unsigned char day = (unsigned char)simple_strtol(tok1, &endptr, 0);
358	if (*endptr != '\0' \|\| day == 0) {
359	printf("%s: invalid day\n", field->name);
360	return -1;
361	}
362
363	unsigned char month;
364	for (month = 1; month <= 12; month++)
365	if (!strcmp(tok2, months[month - 1]))
366	break;
367
368	unsigned int year = simple_strtol(tok3, &endptr, 0);
369	if (*endptr != '\0') {
370	printf("%s: invalid year\n", field->name);
371	return -1;
372	}
373
374	if (validate_date(day, month - 1, year)) {
375	printf("%s: invalid date\n", field->name);
376	return -1;
377	}
378
379	if (year >> 16) {
380	printf("%s: year overflow\n", field->name);
381	return -1;
382	}
383
384	field->buf[0] = day;
385	field->buf[1] = month;
386	field->buf[2] = (unsigned char)year;
387	field->buf[3] = (unsigned char)(year >> 8);
388
389	return 0;
390	}
391
392	#define LAYOUT_VERSION_LEGACY 1
393	#define LAYOUT_VERSION_VER1 2
394	#define LAYOUT_VERSION_VER2 3
395	#define LAYOUT_VERSION_VER3 4
396
397	extern struct eeprom_field layout_unknown[1];
398
399	#define DEFINE_PRINT_UPDATE(x) eeprom_field_print_##x, eeprom_field_update_##x
400
401	#ifdef CONFIG_CM_T3X
402	struct eeprom_field layout_legacy[5] = {
403	{ "MAC address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
404	{ "Board Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin) },
405	{ "Serial Number", 8, NULL, DEFINE_PRINT_UPDATE(bin) },
406	{ "Board Configuration", 64, NULL, DEFINE_PRINT_UPDATE(ascii) },
407	{ RESERVED_FIELDS, 176, NULL, eeprom_field_print_reserved,
408	eeprom_field_update_ascii },
409	};
410	#else
411	#define layout_legacy layout_unknown
412	#endif
413
414	#if defined(CONFIG_CM_T3X) \|\| defined(CONFIG_CM_T3517)
415	struct eeprom_field layout_v1[12] = {
416	{ "Major Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
417	{ "Minor Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
418	{ "1st MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
419	{ "2nd MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
420	{ "Production Date", 4, NULL, DEFINE_PRINT_UPDATE(date) },
421	{ "Serial Number", 12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
422	{ RESERVED_FIELDS, 96, NULL, DEFINE_PRINT_UPDATE(reserved) },
423	{ "Product Name", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
424	{ "Product Options #1", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
425	{ "Product Options #2", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
426	{ "Product Options #3", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
427	{ RESERVED_FIELDS, 64, NULL, eeprom_field_print_reserved,
428	eeprom_field_update_ascii },
429	};
430	#else
431	#define layout_v1 layout_unknown
432	#endif
433
434	struct eeprom_field layout_v2[15] = {
435	{ "Major Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
436	{ "Minor Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
437	{ "1st MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
438	{ "2nd MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
439	{ "Production Date", 4, NULL, DEFINE_PRINT_UPDATE(date) },
440	{ "Serial Number", 12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
441	{ "3rd MAC Address (WIFI)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
442	{ "4th MAC Address (Bluetooth)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
443	{ "Layout Version", 1, NULL, DEFINE_PRINT_UPDATE(bin) },
444	{ RESERVED_FIELDS, 83, NULL, DEFINE_PRINT_UPDATE(reserved) },
445	{ "Product Name", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
446	{ "Product Options #1", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
447	{ "Product Options #2", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
448	{ "Product Options #3", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
449	{ RESERVED_FIELDS, 64, NULL, eeprom_field_print_reserved,
450	eeprom_field_update_ascii },
451	};
452
453	struct eeprom_field layout_v3[16] = {
454	{ "Major Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
455	{ "Minor Revision", 2, NULL, DEFINE_PRINT_UPDATE(bin_ver) },
456	{ "1st MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
457	{ "2nd MAC Address", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
458	{ "Production Date", 4, NULL, DEFINE_PRINT_UPDATE(date) },
459	{ "Serial Number", 12, NULL, DEFINE_PRINT_UPDATE(bin_rev) },
460	{ "3rd MAC Address (WIFI)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
461	{ "4th MAC Address (Bluetooth)", 6, NULL, DEFINE_PRINT_UPDATE(mac) },
462	{ "Layout Version", 1, NULL, DEFINE_PRINT_UPDATE(bin) },
463	{ "CompuLab EEPROM ID", 3, NULL, DEFINE_PRINT_UPDATE(bin) },
464	{ RESERVED_FIELDS, 80, NULL, DEFINE_PRINT_UPDATE(reserved) },
465	{ "Product Name", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
466	{ "Product Options #1", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
467	{ "Product Options #2", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
468	{ "Product Options #3", 16, NULL, DEFINE_PRINT_UPDATE(ascii) },
469	{ RESERVED_FIELDS, 64, NULL, eeprom_field_print_reserved,
470	eeprom_field_update_ascii },
471	};
472
473	void eeprom_layout_assign(struct eeprom_layout *layout, int layout_version)
474	{
475	switch (layout->layout_version) {
476	case LAYOUT_VERSION_LEGACY:
477	layout->fields = layout_legacy;
478	layout->num_of_fields = ARRAY_SIZE(layout_legacy);
479	break;
480	case LAYOUT_VERSION_VER1:
481	layout->fields = layout_v1;
482	layout->num_of_fields = ARRAY_SIZE(layout_v1);
483	break;
484	case LAYOUT_VERSION_VER2:
485	layout->fields = layout_v2;
486	layout->num_of_fields = ARRAY_SIZE(layout_v2);
487	break;
488	case LAYOUT_VERSION_VER3:
489	layout->fields = layout_v3;
490	layout->num_of_fields = ARRAY_SIZE(layout_v3);
491	break;
492	default:
493	__eeprom_layout_assign(layout, layout_version);
494	}
495	}
496
497	int eeprom_parse_layout_version(char *str)
498	{
499	if (!strcmp(str, "legacy"))
500	return LAYOUT_VERSION_LEGACY;
501	else if (!strcmp(str, "v1"))
502	return LAYOUT_VERSION_VER1;
503	else if (!strcmp(str, "v2"))
504	return LAYOUT_VERSION_VER2;
505	else if (!strcmp(str, "v3"))
506	return LAYOUT_VERSION_VER3;
507	else
508	return LAYOUT_VERSION_UNRECOGNIZED;
509	}
510
511	int eeprom_layout_detect(unsigned char *data)
512	{
513	switch (data[EEPROM_LAYOUT_VER_OFFSET]) {
514	case 0xff:
515	case 0:
516	return LAYOUT_VERSION_VER1;
517	case 2:
518	return LAYOUT_VERSION_VER2;
519	case 3:
520	return LAYOUT_VERSION_VER3;
521	}
522
523	if (data[EEPROM_LAYOUT_VER_OFFSET] >= 0x20)
524	return LAYOUT_VERSION_LEGACY;
525
526	return LAYOUT_VERSION_UNRECOGNIZED;
527	}
528	#endif