board/xilinx/common/fru_ops.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * (C) Copyright 2019 - 2020 Xilinx, Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <cpu_func.h>
   8 #include <env.h>
   9 #include <fdtdec.h>
  10 #include <log.h>
  11 #include <malloc.h>
  12 #include <asm/io.h>
  13 #include <asm/arch/hardware.h>
  14
  15 #include "fru.h"
  16
  17 struct fru_table fru_data __section(.data);
  18
  19 static u16 fru_cal_area_len(u8 len)
  20 {
  21         return len * FRU_COMMON_HDR_LEN_MULTIPLIER;
  22 }
  23
  24 static u8 fru_version(u8 ver)
  25 {
  26         return ver & FRU_COMMON_HDR_VER_MASK;
  27 }
  28
  29 static int fru_check_language(u8 code)
  30 {
  31         if (code != FRU_LANG_CODE_ENGLISH && code != FRU_LANG_CODE_ENGLISH_1) {
  32                 printf("FRU_ERROR: Only English Language is supported\n");
  33                 return -EINVAL;
  34         }
  35
  36         return 0;
  37 }
  38
  39 u8 fru_checksum(u8 *addr, u8 len)
  40 {
  41         u8 checksum = 0;
  42
  43         while (len--) {
  44                 checksum += *addr;
  45                 addr++;
  46         }
  47
  48         return checksum;
  49 }
  50
  51 static int fru_check_type_len(u8 type_len, u8 language, u8 *type)
  52 {
  53         int len;
  54
  55         if (type_len == FRU_TYPELEN_EOF)
  56                 return -EINVAL;
  57
  58         *type = (type_len & FRU_TYPELEN_CODE_MASK) >> FRU_TYPELEN_TYPE_SHIFT;
  59
  60         len = type_len & FRU_TYPELEN_LEN_MASK;
  61
  62         return len;
  63 }
  64
  65 /* Return len */
  66 static u8 fru_gen_type_len(u8 *addr, char *name)
  67 {
  68         int len = strlen(name);
  69         struct fru_board_info_member *member;
  70
  71         member = (struct fru_board_info_member *)addr;
  72         member->type_len = FRU_TYPELEN_TYPE_ASCII8 << FRU_TYPELEN_TYPE_SHIFT;
  73         member->type_len |= len;
  74
  75         debug("%lx/%lx: Add %s to 0x%lx (len 0x%x)\n", (ulong)addr,
  76               (ulong)&member->type_len,  name, (ulong)&member->name, len);
  77         memcpy(&member->name, name, len);
  78
  79         /* Add +1 for type_len parameter */
  80         return 1 + len;
  81 }
  82
  83 int fru_generate(unsigned long addr, char *manufacturer, char *board_name,
  84                  char *serial_no, char *part_no, char *revision)
  85 {
  86         struct fru_common_hdr *header = (struct fru_common_hdr *)addr;
  87         struct fru_board_info_header *board_info;
  88         u8 *member;
  89         u8 len, pad, modulo;
  90
  91         header->version = 1; /* Only version 1.0 is supported now */
  92         header->off_internal = 0; /* not present */
  93         header->off_chassis = 0; /* not present */
  94         header->off_board = (sizeof(*header)) / 8; /* Starting offset 8 */
  95         header->off_product = 0; /* not present */
  96         header->off_multirec = 0; /* not present */
  97         header->pad = 0;
  98         /*
  99          * This unsigned byte can be used to calculate a zero checksum
 100          * for the data area following the header. I.e. the modulo 256 sum of
 101          * the record data bytes plus the checksum byte equals zero.
 102          */
 103         header->crc = 0; /* Clear before calculation */
 104         header->crc = 0 - fru_checksum((u8 *)header, sizeof(*header));
 105
 106         /* board info is just right after header */
 107         board_info = (void *)((u8 *)header + sizeof(*header));
 108
 109         debug("header %lx, board_info %lx\n", (ulong)header, (ulong)board_info);
 110
 111         board_info->ver = 1; /* 1.0 spec */
 112         board_info->lang_code = 0; /* English */
 113         board_info->time[0] = 0; /* unspecified */
 114         board_info->time[1] = 0; /* unspecified */
 115         board_info->time[2] = 0; /* unspecified */
 116
 117         /* Member fields are just after board_info header */
 118         member = (u8 *)board_info + sizeof(*board_info);
 119
 120         len = fru_gen_type_len(member, manufacturer); /* Board Manufacturer */
 121         member += len;
 122         len = fru_gen_type_len(member, board_name); /* Board Product name */
 123         member += len;
 124         len = fru_gen_type_len(member, serial_no); /* Board Serial number */
 125         member += len;
 126         len = fru_gen_type_len(member, part_no); /* Board part number */
 127         member += len;
 128         len = fru_gen_type_len(member, "U-Boot generator"); /* File ID */
 129         member += len;
 130         len = fru_gen_type_len(member, revision); /* Revision */
 131         member += len;
 132
 133         *member++ = 0xc1; /* Indication of no more fields */
 134
 135         len = member - (u8 *)board_info; /* Find current length */
 136         len += 1; /* Add checksum there too for calculation */
 137
 138         modulo = len % 8;
 139
 140         if (modulo) {
 141                 /* Do not fill last item which is checksum */
 142                 for (pad = 0; pad < 8 - modulo; pad++)
 143                         *member++ = 0;
 144
 145                 /* Increase structure size */
 146                 len += 8 - modulo;
 147         }
 148
 149         board_info->len = len / 8; /* Size in multiples of 8 bytes */
 150
 151         *member = 0; /* Clear before calculation */
 152         *member = 0 - fru_checksum((u8 *)board_info, len);
 153
 154         debug("checksum %x(addr %x)\n", *member, len);
 155
 156         env_set_hex("fru_addr", addr);
 157         env_set_hex("filesize", (unsigned long)member - addr + 1);
 158
 159         return 0;
 160 }
 161
 162 static int fru_parse_board(unsigned long addr)
 163 {
 164         u8 i, type;
 165         int len;
 166         u8 *data, *term, *limit;
 167
 168         memcpy(&fru_data.brd.ver, (void *)addr, 6);
 169         addr += 6;
 170         data = (u8 *)&fru_data.brd.manufacturer_type_len;
 171
 172         /* Record max structure limit not to write data over allocated space */
 173         limit = data + sizeof(struct fru_board_data);
 174
 175         for (i = 0; ; i++, data += FRU_BOARD_MAX_LEN) {
 176                 len = fru_check_type_len(*(u8 *)addr, fru_data.brd.lang_code,
 177                                          &type);
 178                 /*
 179                  * Stop cature if it end of fields
 180                  */
 181                 if (len == -EINVAL)
 182                         break;
 183
 184                 /* Stop when amount of chars is more then fields to record */
 185                 if (data + len > limit)
 186                         break;
 187                 /* This record type/len field */
 188                 *data++ = *(u8 *)addr;
 189
 190                 /* Add offset to match data */
 191                 addr += 1;
 192
 193                 /* If len is 0 it means empty field that's why skip writing */
 194                 if (!len)
 195                         continue;
 196
 197                 /* Record data field */
 198                 memcpy(data, (u8 *)addr, len);
 199                 term = data + (u8)len;
 200                 *term = 0;
 201                 addr += len;
 202         }
 203
 204         if (i < FRU_BOARD_AREA_TOTAL_FIELDS) {
 205                 printf("Board area require minimum %d fields\n",
 206                        FRU_BOARD_AREA_TOTAL_FIELDS);
 207                 return -EINVAL;
 208         }
 209
 210         return 0;
 211 }
 212
 213 int fru_capture(unsigned long addr)
 214 {
 215         struct fru_common_hdr *hdr;
 216         u8 checksum = 0;
 217
 218         checksum = fru_checksum((u8 *)addr, sizeof(struct fru_common_hdr));
 219         if (checksum) {
 220                 printf("%s Common header CRC error\n", __func__);
 221                 return -EINVAL;
 222         }
 223
 224         hdr = (struct fru_common_hdr *)addr;
 225
 226         memcpy((void *)&fru_data, (void *)hdr,
 227                sizeof(struct fru_common_hdr));
 228
 229         fru_data.captured = true;
 230
 231         if (hdr->off_board) {
 232                 addr += fru_cal_area_len(hdr->off_board);
 233                 fru_parse_board(addr);
 234         }
 235
 236         env_set_hex("fru_addr", addr);
 237
 238         return 0;
 239 }
 240
 241 static int fru_display_board(struct fru_board_data *brd, int verbose)
 242 {
 243         u32 time = 0;
 244         u8 type;
 245         int len;
 246         u8 *data;
 247         static const char * const typecode[] = {
 248                 "Binary/Unspecified",
 249                 "BCD plus",
 250                 "6-bit ASCII",
 251                 "8-bit ASCII",
 252                 "2-byte UNICODE"
 253         };
 254         static const char * const boardinfo[] = {
 255                 "Manufacturer Name",
 256                 "Product Name",
 257                 "Serial No",
 258                 "Part Number",
 259                 "File ID",
 260                 /* Xilinx spec */
 261                 "Revision Number",
 262         };
 263
 264         if (verbose) {
 265                 printf("*****BOARD INFO*****\n");
 266                 printf("Version:%d\n", fru_version(brd->ver));
 267                 printf("Board Area Length:%d\n", fru_cal_area_len(brd->len));
 268         }
 269
 270         if (fru_check_language(brd->lang_code))
 271                 return -EINVAL;
 272
 273         time = brd->time[2] << 16 | brd->time[1] << 8 |
 274                brd->time[0];
 275
 276         if (verbose)
 277                 printf("Time in Minutes from 0:00hrs 1/1/96: %d\n", time);
 278
 279         data = (u8 *)&brd->manufacturer_type_len;
 280
 281         for (u8 i = 0; i < (sizeof(boardinfo) / sizeof(*boardinfo)); i++) {
 282                 len = fru_check_type_len(*data++, brd->lang_code,
 283                                          &type);
 284                 if (len == -EINVAL) {
 285                         printf("**** EOF for Board Area ****\n");
 286                         break;
 287                 }
 288
 289                 if (type <= FRU_TYPELEN_TYPE_ASCII8 &&
 290                     (brd->lang_code == FRU_LANG_CODE_ENGLISH ||
 291                      brd->lang_code == FRU_LANG_CODE_ENGLISH_1))
 292                         debug("Type code: %s\n", typecode[type]);
 293                 else
 294                         debug("Type code: %s\n", typecode[type + 1]);
 295
 296                 if (!len) {
 297                         debug("%s not found\n", boardinfo[i]);
 298                         continue;
 299                 }
 300
 301                 switch (type) {
 302                 case FRU_TYPELEN_TYPE_BINARY:
 303                         debug("Length: %d\n", len);
 304                         printf(" %s: 0x%x\n", boardinfo[i], *data);
 305                         break;
 306                 case FRU_TYPELEN_TYPE_ASCII8:
 307                         debug("Length: %d\n", len);
 308                         printf(" %s: %s\n", boardinfo[i], data);
 309                         break;
 310                 default:
 311                         debug("Unsupported type %x\n", type);
 312                 }
 313
 314                 data += FRU_BOARD_MAX_LEN;
 315         }
 316
 317         return 0;
 318 }
 319
 320 static void fru_display_common_hdr(struct fru_common_hdr *hdr, int verbose)
 321 {
 322         if (!verbose)
 323                 return;
 324
 325         printf("*****COMMON HEADER*****\n");
 326         printf("Version:%d\n", fru_version(hdr->version));
 327         if (hdr->off_internal)
 328                 printf("Internal Use Area Offset:%d\n",
 329                        fru_cal_area_len(hdr->off_internal));
 330         else
 331                 printf("*** No Internal Area ***\n");
 332
 333         if (hdr->off_chassis)
 334                 printf("Chassis Info Area Offset:%d\n",
 335                        fru_cal_area_len(hdr->off_chassis));
 336         else
 337                 printf("*** No Chassis Info Area ***\n");
 338
 339         if (hdr->off_board)
 340                 printf("Board Area Offset:%d\n",
 341                        fru_cal_area_len(hdr->off_board));
 342         else
 343                 printf("*** No Board Area ***\n");
 344
 345         if (hdr->off_product)
 346                 printf("Product Info Area Offset:%d\n",
 347                        fru_cal_area_len(hdr->off_product));
 348         else
 349                 printf("*** No Product Info Area ***\n");
 350
 351         if (hdr->off_multirec)
 352                 printf("MultiRecord Area Offset:%d\n",
 353                        fru_cal_area_len(hdr->off_multirec));
 354         else
 355                 printf("*** No MultiRecord Area ***\n");
 356 }
 357
 358 int fru_display(int verbose)
 359 {
 360         if (!fru_data.captured) {
 361                 printf("FRU data not available please run fru parse\n");
 362                 return -EINVAL;
 363         }
 364
 365         fru_display_common_hdr(&fru_data.hdr, verbose);
 366
 367         return fru_display_board(&fru_data.brd, verbose);
 368 }