board/compulab/common/eeprom.c

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