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

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

#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 = dectoul(str, NULL);
        }

        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

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

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_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