drivers/net/sfc/base/ef10_nvram.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2012-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9
  10 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
  11
  12 #if EFSYS_OPT_VPD || EFSYS_OPT_NVRAM
  13
  14 #include "ef10_tlv_layout.h"
  15
  16 /* Cursor for TLV partition format */
  17 typedef struct tlv_cursor_s {
  18         uint32_t        *block;                 /* Base of data block */
  19         uint32_t        *current;               /* Cursor position */
  20         uint32_t        *end;                   /* End tag position */
  21         uint32_t        *limit;                 /* Last dword of data block */
  22 } tlv_cursor_t;
  23
  24 typedef struct nvram_partition_s {
  25         uint16_t type;
  26         uint8_t chip_select;
  27         uint8_t flags;
  28         /*
  29          * The full length of the NVRAM partition.
  30          * This is different from tlv_partition_header.total_length,
  31          *  which can be smaller.
  32          */
  33         uint32_t length;
  34         uint32_t erase_size;
  35         uint32_t *data;
  36         tlv_cursor_t tlv_cursor;
  37 } nvram_partition_t;
  38
  39
  40 static  __checkReturn           efx_rc_t
  41 tlv_validate_state(
  42         __inout                 tlv_cursor_t *cursor);
  43
  44
  45 static                          void
  46 tlv_init_block(
  47         __out   uint32_t        *block)
  48 {
  49         *block = __CPU_TO_LE_32(TLV_TAG_END);
  50 }
  51
  52 static                          uint32_t
  53 tlv_tag(
  54         __in    tlv_cursor_t    *cursor)
  55 {
  56         uint32_t dword, tag;
  57
  58         dword = cursor->current[0];
  59         tag = __LE_TO_CPU_32(dword);
  60
  61         return (tag);
  62 }
  63
  64 static                          size_t
  65 tlv_length(
  66         __in    tlv_cursor_t    *cursor)
  67 {
  68         uint32_t dword, length;
  69
  70         if (tlv_tag(cursor) == TLV_TAG_END)
  71                 return (0);
  72
  73         dword = cursor->current[1];
  74         length = __LE_TO_CPU_32(dword);
  75
  76         return ((size_t)length);
  77 }
  78
  79 static                          uint8_t *
  80 tlv_value(
  81         __in    tlv_cursor_t    *cursor)
  82 {
  83         if (tlv_tag(cursor) == TLV_TAG_END)
  84                 return (NULL);
  85
  86         return ((uint8_t *)(&cursor->current[2]));
  87 }
  88
  89 static                          uint8_t *
  90 tlv_item(
  91         __in    tlv_cursor_t    *cursor)
  92 {
  93         if (tlv_tag(cursor) == TLV_TAG_END)
  94                 return (NULL);
  95
  96         return ((uint8_t *)cursor->current);
  97 }
  98
  99 /*
 100  * TLV item DWORD length is tag + length + value (rounded up to DWORD)
 101  * equivalent to tlv_n_words_for_len in mc-comms tlv.c
 102  */
 103 #define TLV_DWORD_COUNT(length) \
 104         (1 + 1 + (((length) + sizeof (uint32_t) - 1) / sizeof (uint32_t)))
 105
 106
 107 static                          uint32_t *
 108 tlv_next_item_ptr(
 109         __in    tlv_cursor_t    *cursor)
 110 {
 111         uint32_t length;
 112
 113         length = tlv_length(cursor);
 114
 115         return (cursor->current + TLV_DWORD_COUNT(length));
 116 }
 117
 118 static  __checkReturn           efx_rc_t
 119 tlv_advance(
 120         __inout tlv_cursor_t    *cursor)
 121 {
 122         efx_rc_t rc;
 123
 124         if ((rc = tlv_validate_state(cursor)) != 0)
 125                 goto fail1;
 126
 127         if (cursor->current == cursor->end) {
 128                 /* No more tags after END tag */
 129                 cursor->current = NULL;
 130                 rc = ENOENT;
 131                 goto fail2;
 132         }
 133
 134         /* Advance to next item and validate */
 135         cursor->current = tlv_next_item_ptr(cursor);
 136
 137         if ((rc = tlv_validate_state(cursor)) != 0)
 138                 goto fail3;
 139
 140         return (0);
 141
 142 fail3:
 143         EFSYS_PROBE(fail3);
 144 fail2:
 145         EFSYS_PROBE(fail2);
 146 fail1:
 147         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 148
 149         return (rc);
 150 }
 151
 152 static                          efx_rc_t
 153 tlv_rewind(
 154         __in    tlv_cursor_t    *cursor)
 155 {
 156         efx_rc_t rc;
 157
 158         cursor->current = cursor->block;
 159
 160         if ((rc = tlv_validate_state(cursor)) != 0)
 161                 goto fail1;
 162
 163         return (0);
 164
 165 fail1:
 166         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 167
 168         return (rc);
 169 }
 170
 171 static                          efx_rc_t
 172 tlv_find(
 173         __inout tlv_cursor_t    *cursor,
 174         __in    uint32_t        tag)
 175 {
 176         efx_rc_t rc;
 177
 178         rc = tlv_rewind(cursor);
 179         while (rc == 0) {
 180                 if (tlv_tag(cursor) == tag)
 181                         break;
 182
 183                 rc = tlv_advance(cursor);
 184         }
 185         return (rc);
 186 }
 187
 188 static  __checkReturn           efx_rc_t
 189 tlv_validate_state(
 190         __inout tlv_cursor_t    *cursor)
 191 {
 192         efx_rc_t rc;
 193
 194         /* Check cursor position */
 195         if (cursor->current < cursor->block) {
 196                 rc = EINVAL;
 197                 goto fail1;
 198         }
 199         if (cursor->current > cursor->limit) {
 200                 rc = EINVAL;
 201                 goto fail2;
 202         }
 203
 204         if (tlv_tag(cursor) != TLV_TAG_END) {
 205                 /* Check current item has space for tag and length */
 206                 if (cursor->current > (cursor->limit - 2)) {
 207                         cursor->current = NULL;
 208                         rc = EFAULT;
 209                         goto fail3;
 210                 }
 211
 212                 /* Check we have value data for current item and another tag */
 213                 if (tlv_next_item_ptr(cursor) > (cursor->limit - 1)) {
 214                         cursor->current = NULL;
 215                         rc = EFAULT;
 216                         goto fail4;
 217                 }
 218         }
 219
 220         return (0);
 221
 222 fail4:
 223         EFSYS_PROBE(fail4);
 224 fail3:
 225         EFSYS_PROBE(fail3);
 226 fail2:
 227         EFSYS_PROBE(fail2);
 228 fail1:
 229         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 230
 231         return (rc);
 232 }
 233
 234 static                          efx_rc_t
 235 tlv_init_cursor(
 236         __out   tlv_cursor_t    *cursor,
 237         __in    uint32_t        *block,
 238         __in    uint32_t        *limit,
 239         __in    uint32_t        *current)
 240 {
 241         cursor->block   = block;
 242         cursor->limit   = limit;
 243
 244         cursor->current = current;
 245         cursor->end     = NULL;
 246
 247         return (tlv_validate_state(cursor));
 248 }
 249
 250 static  __checkReturn           efx_rc_t
 251 tlv_init_cursor_from_size(
 252         __out   tlv_cursor_t    *cursor,
 253         __in_bcount(size)
 254                 uint8_t         *block,
 255         __in    size_t          size)
 256 {
 257         uint32_t *limit;
 258         limit = (uint32_t *)(block + size - sizeof (uint32_t));
 259         return (tlv_init_cursor(cursor, (uint32_t *)block,
 260                 limit, (uint32_t *)block));
 261 }
 262
 263 static  __checkReturn           efx_rc_t
 264 tlv_init_cursor_at_offset(
 265         __out   tlv_cursor_t    *cursor,
 266         __in_bcount(size)
 267                 uint8_t         *block,
 268         __in    size_t          size,
 269         __in    size_t          offset)
 270 {
 271         uint32_t *limit;
 272         uint32_t *current;
 273         limit = (uint32_t *)(block + size - sizeof (uint32_t));
 274         current = (uint32_t *)(block + offset);
 275         return (tlv_init_cursor(cursor, (uint32_t *)block, limit, current));
 276 }
 277
 278 static  __checkReturn           efx_rc_t
 279 tlv_require_end(
 280         __inout tlv_cursor_t    *cursor)
 281 {
 282         uint32_t *pos;
 283         efx_rc_t rc;
 284
 285         if (cursor->end == NULL) {
 286                 pos = cursor->current;
 287                 if ((rc = tlv_find(cursor, TLV_TAG_END)) != 0)
 288                         goto fail1;
 289
 290                 cursor->end = cursor->current;
 291                 cursor->current = pos;
 292         }
 293
 294         return (0);
 295
 296 fail1:
 297         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 298
 299         return (rc);
 300 }
 301
 302 static                          size_t
 303 tlv_block_length_used(
 304         __inout tlv_cursor_t    *cursor)
 305 {
 306         efx_rc_t rc;
 307
 308         if ((rc = tlv_validate_state(cursor)) != 0)
 309                 goto fail1;
 310
 311         if ((rc = tlv_require_end(cursor)) != 0)
 312                 goto fail2;
 313
 314         /* Return space used (including the END tag) */
 315         return (cursor->end + 1 - cursor->block) * sizeof (uint32_t);
 316
 317 fail2:
 318         EFSYS_PROBE(fail2);
 319 fail1:
 320         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 321
 322         return (0);
 323 }
 324
 325 static          uint32_t *
 326 tlv_last_segment_end(
 327         __in    tlv_cursor_t *cursor)
 328 {
 329         tlv_cursor_t segment_cursor;
 330         uint32_t *last_segment_end = cursor->block;
 331         uint32_t *segment_start = cursor->block;
 332
 333         /*
 334          * Go through each segment and check that it has an end tag. If there
 335          * is no end tag then the previous segment was the last valid one,
 336          * so return the pointer to its end tag.
 337          */
 338         for (;;) {
 339                 if (tlv_init_cursor(&segment_cursor, segment_start,
 340                     cursor->limit, segment_start) != 0)
 341                         break;
 342                 if (tlv_require_end(&segment_cursor) != 0)
 343                         break;
 344                 last_segment_end = segment_cursor.end;
 345                 segment_start = segment_cursor.end + 1;
 346         }
 347
 348         return (last_segment_end);
 349 }
 350
 351
 352 static                          uint32_t *
 353 tlv_write(
 354         __in                    tlv_cursor_t *cursor,
 355         __in                    uint32_t tag,
 356         __in_bcount(size)       uint8_t *data,
 357         __in                    size_t size)
 358 {
 359         uint32_t len = size;
 360         uint32_t *ptr;
 361
 362         ptr = cursor->current;
 363
 364         *ptr++ = __CPU_TO_LE_32(tag);
 365         *ptr++ = __CPU_TO_LE_32(len);
 366
 367         if (len > 0) {
 368                 ptr[(len - 1) / sizeof (uint32_t)] = 0;
 369                 memcpy(ptr, data, len);
 370                 ptr += P2ROUNDUP(len, sizeof (uint32_t)) / sizeof (*ptr);
 371         }
 372
 373         return (ptr);
 374 }
 375
 376 static  __checkReturn           efx_rc_t
 377 tlv_insert(
 378         __inout tlv_cursor_t    *cursor,
 379         __in    uint32_t        tag,
 380         __in_bcount(size)
 381                 uint8_t         *data,
 382         __in    size_t          size)
 383 {
 384         unsigned int delta;
 385         uint32_t *last_segment_end;
 386         efx_rc_t rc;
 387
 388         if ((rc = tlv_validate_state(cursor)) != 0)
 389                 goto fail1;
 390
 391         if ((rc = tlv_require_end(cursor)) != 0)
 392                 goto fail2;
 393
 394         if (tag == TLV_TAG_END) {
 395                 rc = EINVAL;
 396                 goto fail3;
 397         }
 398
 399         last_segment_end = tlv_last_segment_end(cursor);
 400
 401         delta = TLV_DWORD_COUNT(size);
 402         if (last_segment_end + 1 + delta > cursor->limit) {
 403                 rc = ENOSPC;
 404                 goto fail4;
 405         }
 406
 407         /* Move data up: new space at cursor->current */
 408         memmove(cursor->current + delta, cursor->current,
 409             (last_segment_end + 1 - cursor->current) * sizeof (uint32_t));
 410
 411         /* Adjust the end pointer */
 412         cursor->end += delta;
 413
 414         /* Write new TLV item */
 415         tlv_write(cursor, tag, data, size);
 416
 417         return (0);
 418
 419 fail4:
 420         EFSYS_PROBE(fail4);
 421 fail3:
 422         EFSYS_PROBE(fail3);
 423 fail2:
 424         EFSYS_PROBE(fail2);
 425 fail1:
 426         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 427
 428         return (rc);
 429 }
 430
 431 static  __checkReturn           efx_rc_t
 432 tlv_delete(
 433         __inout tlv_cursor_t    *cursor)
 434 {
 435         unsigned int delta;
 436         uint32_t *last_segment_end;
 437         efx_rc_t rc;
 438
 439         if ((rc = tlv_validate_state(cursor)) != 0)
 440                 goto fail1;
 441
 442         if (tlv_tag(cursor) == TLV_TAG_END) {
 443                 rc = EINVAL;
 444                 goto fail2;
 445         }
 446
 447         delta = TLV_DWORD_COUNT(tlv_length(cursor));
 448
 449         if ((rc = tlv_require_end(cursor)) != 0)
 450                 goto fail3;
 451
 452         last_segment_end = tlv_last_segment_end(cursor);
 453
 454         /* Shuffle things down, destroying the item at cursor->current */
 455         memmove(cursor->current, cursor->current + delta,
 456             (last_segment_end + 1 - cursor->current) * sizeof (uint32_t));
 457         /* Zero the new space at the end of the TLV chain */
 458         memset(last_segment_end + 1 - delta, 0, delta * sizeof (uint32_t));
 459         /* Adjust the end pointer */
 460         cursor->end -= delta;
 461
 462         return (0);
 463
 464 fail3:
 465         EFSYS_PROBE(fail3);
 466 fail2:
 467         EFSYS_PROBE(fail2);
 468 fail1:
 469         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 470
 471         return (rc);
 472 }
 473
 474 static  __checkReturn           efx_rc_t
 475 tlv_modify(
 476         __inout tlv_cursor_t    *cursor,
 477         __in    uint32_t        tag,
 478         __in_bcount(size)
 479                 uint8_t         *data,
 480         __in    size_t          size)
 481 {
 482         uint32_t *pos;
 483         unsigned int old_ndwords;
 484         unsigned int new_ndwords;
 485         unsigned int delta;
 486         uint32_t *last_segment_end;
 487         efx_rc_t rc;
 488
 489         if ((rc = tlv_validate_state(cursor)) != 0)
 490                 goto fail1;
 491
 492         if (tlv_tag(cursor) == TLV_TAG_END) {
 493                 rc = EINVAL;
 494                 goto fail2;
 495         }
 496         if (tlv_tag(cursor) != tag) {
 497                 rc = EINVAL;
 498                 goto fail3;
 499         }
 500
 501         old_ndwords = TLV_DWORD_COUNT(tlv_length(cursor));
 502         new_ndwords = TLV_DWORD_COUNT(size);
 503
 504         if ((rc = tlv_require_end(cursor)) != 0)
 505                 goto fail4;
 506
 507         last_segment_end = tlv_last_segment_end(cursor);
 508
 509         if (new_ndwords > old_ndwords) {
 510                 /* Expand space used for TLV item */
 511                 delta = new_ndwords - old_ndwords;
 512                 pos = cursor->current + old_ndwords;
 513
 514                 if (last_segment_end + 1 + delta > cursor->limit) {
 515                         rc = ENOSPC;
 516                         goto fail5;
 517                 }
 518
 519                 /* Move up: new space at (cursor->current + old_ndwords) */
 520                 memmove(pos + delta, pos,
 521                     (last_segment_end + 1 - pos) * sizeof (uint32_t));
 522
 523                 /* Adjust the end pointer */
 524                 cursor->end += delta;
 525
 526         } else if (new_ndwords < old_ndwords) {
 527                 /* Shrink space used for TLV item */
 528                 delta = old_ndwords - new_ndwords;
 529                 pos = cursor->current + new_ndwords;
 530
 531                 /* Move down: remove words at (cursor->current + new_ndwords) */
 532                 memmove(pos, pos + delta,
 533                     (last_segment_end + 1 - pos) * sizeof (uint32_t));
 534
 535                 /* Zero the new space at the end of the TLV chain */
 536                 memset(last_segment_end + 1 - delta, 0,
 537                     delta * sizeof (uint32_t));
 538
 539                 /* Adjust the end pointer */
 540                 cursor->end -= delta;
 541         }
 542
 543         /* Write new data */
 544         tlv_write(cursor, tag, data, size);
 545
 546         return (0);
 547
 548 fail5:
 549         EFSYS_PROBE(fail5);
 550 fail4:
 551         EFSYS_PROBE(fail4);
 552 fail3:
 553         EFSYS_PROBE(fail3);
 554 fail2:
 555         EFSYS_PROBE(fail2);
 556 fail1:
 557         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 558
 559         return (rc);
 560 }
 561
 562 static uint32_t checksum_tlv_partition(
 563         __in    nvram_partition_t *partition)
 564 {
 565         tlv_cursor_t *cursor;
 566         uint32_t *ptr;
 567         uint32_t *end;
 568         uint32_t csum;
 569         size_t len;
 570
 571         cursor = &partition->tlv_cursor;
 572         len = tlv_block_length_used(cursor);
 573         EFSYS_ASSERT3U((len & 3), ==, 0);
 574
 575         csum = 0;
 576         ptr = partition->data;
 577         end = &ptr[len >> 2];
 578
 579         while (ptr < end)
 580                 csum += __LE_TO_CPU_32(*ptr++);
 581
 582         return (csum);
 583 }
 584
 585 static  __checkReturn           efx_rc_t
 586 tlv_update_partition_len_and_cks(
 587         __in    tlv_cursor_t *cursor)
 588 {
 589         efx_rc_t rc;
 590         nvram_partition_t partition;
 591         struct tlv_partition_header *header;
 592         struct tlv_partition_trailer *trailer;
 593         size_t new_len;
 594
 595         /*
 596          * We just modified the partition, so the total length may not be
 597          * valid. Don't use tlv_find(), which performs some sanity checks
 598          * that may fail here.
 599          */
 600         partition.data = cursor->block;
 601         memcpy(&partition.tlv_cursor, cursor, sizeof (*cursor));
 602         header = (struct tlv_partition_header *)partition.data;
 603         /* Sanity check. */
 604         if (__LE_TO_CPU_32(header->tag) != TLV_TAG_PARTITION_HEADER) {
 605                 rc = EFAULT;
 606                 goto fail1;
 607         }
 608         new_len =  tlv_block_length_used(&partition.tlv_cursor);
 609         if (new_len == 0) {
 610                 rc = EFAULT;
 611                 goto fail2;
 612         }
 613         header->total_length = __CPU_TO_LE_32(new_len);
 614         /* Ensure the modified partition always has a new generation count. */
 615         header->generation = __CPU_TO_LE_32(
 616             __LE_TO_CPU_32(header->generation) + 1);
 617
 618         trailer = (struct tlv_partition_trailer *)((uint8_t *)header +
 619             new_len - sizeof (*trailer) - sizeof (uint32_t));
 620         trailer->generation = header->generation;
 621         trailer->checksum = __CPU_TO_LE_32(
 622             __LE_TO_CPU_32(trailer->checksum) -
 623             checksum_tlv_partition(&partition));
 624
 625         return (0);
 626
 627 fail2:
 628         EFSYS_PROBE(fail2);
 629 fail1:
 630         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 631
 632         return (rc);
 633 }
 634
 635 /* Validate buffer contents (before writing to flash) */
 636         __checkReturn           efx_rc_t
 637 ef10_nvram_buffer_validate(
 638         __in                    efx_nic_t *enp,
 639         __in                    uint32_t partn,
 640         __in_bcount(partn_size) caddr_t partn_data,
 641         __in                    size_t partn_size)
 642 {
 643         tlv_cursor_t cursor;
 644         struct tlv_partition_header *header;
 645         struct tlv_partition_trailer *trailer;
 646         size_t total_length;
 647         uint32_t cksum;
 648         int pos;
 649         efx_rc_t rc;
 650
 651         _NOTE(ARGUNUSED(enp, partn))
 652         EFX_STATIC_ASSERT(sizeof (*header) <= EF10_NVRAM_CHUNK);
 653
 654         if ((partn_data == NULL) || (partn_size == 0)) {
 655                 rc = EINVAL;
 656                 goto fail1;
 657         }
 658
 659         /* The partition header must be the first item (at offset zero) */
 660         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)partn_data,
 661                     partn_size)) != 0) {
 662                 rc = EFAULT;
 663                 goto fail2;
 664         }
 665         if (tlv_tag(&cursor) != TLV_TAG_PARTITION_HEADER) {
 666                 rc = EINVAL;
 667                 goto fail3;
 668         }
 669         header = (struct tlv_partition_header *)tlv_item(&cursor);
 670
 671         /* Check TLV partition length (includes the END tag) */
 672         total_length = __LE_TO_CPU_32(header->total_length);
 673         if (total_length > partn_size) {
 674                 rc = EFBIG;
 675                 goto fail4;
 676         }
 677
 678         /* Check partition ends with PARTITION_TRAILER and END tags */
 679         if ((rc = tlv_find(&cursor, TLV_TAG_PARTITION_TRAILER)) != 0) {
 680                 rc = EINVAL;
 681                 goto fail5;
 682         }
 683         trailer = (struct tlv_partition_trailer *)tlv_item(&cursor);
 684
 685         if ((rc = tlv_advance(&cursor)) != 0) {
 686                 rc = EINVAL;
 687                 goto fail6;
 688         }
 689         if (tlv_tag(&cursor) != TLV_TAG_END) {
 690                 rc = EINVAL;
 691                 goto fail7;
 692         }
 693
 694         /* Check generation counts are consistent */
 695         if (trailer->generation != header->generation) {
 696                 rc = EINVAL;
 697                 goto fail8;
 698         }
 699
 700         /* Verify partition checksum */
 701         cksum = 0;
 702         for (pos = 0; (size_t)pos < total_length; pos += sizeof (uint32_t)) {
 703                 cksum += *((uint32_t *)(partn_data + pos));
 704         }
 705         if (cksum != 0) {
 706                 rc = EINVAL;
 707                 goto fail9;
 708         }
 709
 710         return (0);
 711
 712 fail9:
 713         EFSYS_PROBE(fail9);
 714 fail8:
 715         EFSYS_PROBE(fail8);
 716 fail7:
 717         EFSYS_PROBE(fail7);
 718 fail6:
 719         EFSYS_PROBE(fail6);
 720 fail5:
 721         EFSYS_PROBE(fail5);
 722 fail4:
 723         EFSYS_PROBE(fail4);
 724 fail3:
 725         EFSYS_PROBE(fail3);
 726 fail2:
 727         EFSYS_PROBE(fail2);
 728 fail1:
 729         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 730
 731         return (rc);
 732 }
 733
 734
 735
 736         __checkReturn           efx_rc_t
 737 ef10_nvram_buffer_create(
 738         __in                    efx_nic_t *enp,
 739         __in                    uint16_t partn_type,
 740         __in_bcount(partn_size) caddr_t partn_data,
 741         __in                    size_t partn_size)
 742 {
 743         uint32_t *buf = (uint32_t *)partn_data;
 744         efx_rc_t rc;
 745         tlv_cursor_t cursor;
 746         struct tlv_partition_header header;
 747         struct tlv_partition_trailer trailer;
 748
 749         unsigned int min_buf_size = sizeof (struct tlv_partition_header) +
 750             sizeof (struct tlv_partition_trailer);
 751         if (partn_size < min_buf_size) {
 752                 rc = EINVAL;
 753                 goto fail1;
 754         }
 755
 756         memset(buf, 0xff, partn_size);
 757
 758         tlv_init_block(buf);
 759         if ((rc = tlv_init_cursor(&cursor, buf,
 760             (uint32_t *)((uint8_t *)buf + partn_size),
 761             buf)) != 0) {
 762                 goto fail2;
 763         }
 764
 765         header.tag = __CPU_TO_LE_32(TLV_TAG_PARTITION_HEADER);
 766         header.length = __CPU_TO_LE_32(sizeof (header) - 8);
 767         header.type_id = __CPU_TO_LE_16(partn_type);
 768         header.preset = 0;
 769         header.generation = __CPU_TO_LE_32(1);
 770         header.total_length = 0;  /* This will be fixed below. */
 771         if ((rc = tlv_insert(
 772             &cursor, TLV_TAG_PARTITION_HEADER,
 773             (uint8_t *)&header.type_id, sizeof (header) - 8)) != 0)
 774                 goto fail3;
 775         if ((rc = tlv_advance(&cursor)) != 0)
 776                 goto fail4;
 777
 778         trailer.tag = __CPU_TO_LE_32(TLV_TAG_PARTITION_TRAILER);
 779         trailer.length = __CPU_TO_LE_32(sizeof (trailer) - 8);
 780         trailer.generation = header.generation;
 781         trailer.checksum = 0;  /* This will be fixed below. */
 782         if ((rc = tlv_insert(&cursor, TLV_TAG_PARTITION_TRAILER,
 783             (uint8_t *)&trailer.generation, sizeof (trailer) - 8)) != 0)
 784                 goto fail5;
 785
 786         if ((rc = tlv_update_partition_len_and_cks(&cursor)) != 0)
 787                 goto fail6;
 788
 789         /* Check that the partition is valid. */
 790         if ((rc = ef10_nvram_buffer_validate(enp, partn_type,
 791             partn_data, partn_size)) != 0)
 792                 goto fail7;
 793
 794         return (0);
 795
 796 fail7:
 797         EFSYS_PROBE(fail7);
 798 fail6:
 799         EFSYS_PROBE(fail6);
 800 fail5:
 801         EFSYS_PROBE(fail5);
 802 fail4:
 803         EFSYS_PROBE(fail4);
 804 fail3:
 805         EFSYS_PROBE(fail3);
 806 fail2:
 807         EFSYS_PROBE(fail2);
 808 fail1:
 809         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 810
 811         return (rc);
 812 }
 813
 814 static                  uint32_t
 815 byte_offset(
 816         __in            uint32_t *position,
 817         __in            uint32_t *base)
 818 {
 819         return (uint32_t)((uint8_t *)position - (uint8_t *)base);
 820 }
 821
 822         __checkReturn           efx_rc_t
 823 ef10_nvram_buffer_find_item_start(
 824         __in_bcount(buffer_size)
 825                                 caddr_t bufferp,
 826         __in                    size_t buffer_size,
 827         __out                   uint32_t *startp)
 828 {
 829         /* Read past partition header to find start address of the first key */
 830         tlv_cursor_t cursor;
 831         efx_rc_t rc;
 832
 833         /* A PARTITION_HEADER tag must be the first item (at offset zero) */
 834         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)bufferp,
 835                         buffer_size)) != 0) {
 836                 rc = EFAULT;
 837                 goto fail1;
 838         }
 839         if (tlv_tag(&cursor) != TLV_TAG_PARTITION_HEADER) {
 840                 rc = EINVAL;
 841                 goto fail2;
 842         }
 843
 844         if ((rc = tlv_advance(&cursor)) != 0) {
 845                 rc = EINVAL;
 846                 goto fail3;
 847         }
 848         *startp = byte_offset(cursor.current, cursor.block);
 849
 850         if ((rc = tlv_require_end(&cursor)) != 0)
 851                 goto fail4;
 852
 853         return (0);
 854
 855 fail4:
 856         EFSYS_PROBE(fail4);
 857 fail3:
 858         EFSYS_PROBE(fail3);
 859 fail2:
 860         EFSYS_PROBE(fail2);
 861 fail1:
 862         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 863
 864         return (rc);
 865 }
 866
 867         __checkReturn           efx_rc_t
 868 ef10_nvram_buffer_find_end(
 869         __in_bcount(buffer_size)
 870                                 caddr_t bufferp,
 871         __in                    size_t buffer_size,
 872         __in                    uint32_t offset,
 873         __out                   uint32_t *endp)
 874 {
 875         /* Read to end of partition */
 876         tlv_cursor_t cursor;
 877         efx_rc_t rc;
 878         uint32_t *segment_used;
 879
 880         _NOTE(ARGUNUSED(offset))
 881
 882         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)bufferp,
 883                         buffer_size)) != 0) {
 884                 rc = EFAULT;
 885                 goto fail1;
 886         }
 887
 888         segment_used = cursor.block;
 889
 890         /*
 891          * Go through each segment and check that it has an end tag. If there
 892          * is no end tag then the previous segment was the last valid one,
 893          * so return the used space including that end tag.
 894          */
 895         while (tlv_tag(&cursor) == TLV_TAG_PARTITION_HEADER) {
 896                 if (tlv_require_end(&cursor) != 0) {
 897                         if (segment_used == cursor.block) {
 898                                 /*
 899                                  * First segment is corrupt, so there is
 900                                  * no valid data in partition.
 901                                  */
 902                                 rc = EINVAL;
 903                                 goto fail2;
 904                         }
 905                         break;
 906                 }
 907                 segment_used = cursor.end + 1;
 908
 909                 cursor.current = segment_used;
 910         }
 911         /* Return space used (including the END tag) */
 912         *endp = (segment_used - cursor.block) * sizeof (uint32_t);
 913
 914         return (0);
 915
 916 fail2:
 917         EFSYS_PROBE(fail2);
 918 fail1:
 919         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 920
 921         return (rc);
 922 }
 923
 924         __checkReturn   __success(return != B_FALSE)    boolean_t
 925 ef10_nvram_buffer_find_item(
 926         __in_bcount(buffer_size)
 927                                 caddr_t bufferp,
 928         __in                    size_t buffer_size,
 929         __in                    uint32_t offset,
 930         __out                   uint32_t *startp,
 931         __out                   uint32_t *lengthp)
 932 {
 933         /* Find TLV at offset and return key start and length */
 934         tlv_cursor_t cursor;
 935         uint8_t *key;
 936         uint32_t tag;
 937
 938         if (tlv_init_cursor_at_offset(&cursor, (uint8_t *)bufferp,
 939                         buffer_size, offset) != 0) {
 940                 return (B_FALSE);
 941         }
 942
 943         while ((key = tlv_item(&cursor)) != NULL) {
 944                 tag = tlv_tag(&cursor);
 945                 if (tag == TLV_TAG_PARTITION_HEADER ||
 946                     tag == TLV_TAG_PARTITION_TRAILER) {
 947                         if (tlv_advance(&cursor) != 0) {
 948                                 break;
 949                         }
 950                         continue;
 951                 }
 952                 *startp = byte_offset(cursor.current, cursor.block);
 953                 *lengthp = byte_offset(tlv_next_item_ptr(&cursor),
 954                     cursor.current);
 955                 return (B_TRUE);
 956         }
 957
 958         return (B_FALSE);
 959 }
 960
 961         __checkReturn           efx_rc_t
 962 ef10_nvram_buffer_get_item(
 963         __in_bcount(buffer_size)
 964                                 caddr_t bufferp,
 965         __in                    size_t buffer_size,
 966         __in                    uint32_t offset,
 967         __in                    uint32_t length,
 968         __out_bcount_part(item_max_size, *lengthp)
 969                                 caddr_t itemp,
 970         __in                    size_t item_max_size,
 971         __out                   uint32_t *lengthp)
 972 {
 973         efx_rc_t rc;
 974         tlv_cursor_t cursor;
 975         uint32_t item_length;
 976
 977         if (item_max_size < length) {
 978                 rc = ENOSPC;
 979                 goto fail1;
 980         }
 981
 982         if ((rc = tlv_init_cursor_at_offset(&cursor, (uint8_t *)bufferp,
 983                         buffer_size, offset)) != 0) {
 984                 goto fail2;
 985         }
 986
 987         item_length = tlv_length(&cursor);
 988         if (length < item_length) {
 989                 rc = ENOSPC;
 990                 goto fail3;
 991         }
 992         memcpy(itemp, tlv_value(&cursor), item_length);
 993
 994         *lengthp = item_length;
 995
 996         return (0);
 997
 998 fail3:
 999         EFSYS_PROBE(fail3);
1000 fail2:
1001         EFSYS_PROBE(fail2);
1002 fail1:
1003         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1004
1005         return (rc);
1006 }
1007
1008         __checkReturn           efx_rc_t
1009 ef10_nvram_buffer_insert_item(
1010         __in_bcount(buffer_size)
1011                                 caddr_t bufferp,
1012         __in                    size_t buffer_size,
1013         __in                    uint32_t offset,
1014         __in_bcount(length)     caddr_t keyp,
1015         __in                    uint32_t length,
1016         __out                   uint32_t *lengthp)
1017 {
1018         efx_rc_t rc;
1019         tlv_cursor_t cursor;
1020
1021         if ((rc = tlv_init_cursor_at_offset(&cursor, (uint8_t *)bufferp,
1022                         buffer_size, offset)) != 0) {
1023                 goto fail1;
1024         }
1025
1026         rc = tlv_insert(&cursor, TLV_TAG_LICENSE, (uint8_t *)keyp, length);
1027
1028         if (rc != 0) {
1029                 goto fail2;
1030         }
1031
1032         *lengthp = byte_offset(tlv_next_item_ptr(&cursor),
1033                     cursor.current);
1034
1035         return (0);
1036
1037 fail2:
1038         EFSYS_PROBE(fail2);
1039 fail1:
1040         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1041
1042         return (rc);
1043 }
1044
1045         __checkReturn           efx_rc_t
1046 ef10_nvram_buffer_delete_item(
1047         __in_bcount(buffer_size)
1048                                 caddr_t bufferp,
1049         __in                    size_t buffer_size,
1050         __in                    uint32_t offset,
1051         __in                    uint32_t length,
1052         __in                    uint32_t end)
1053 {
1054         efx_rc_t rc;
1055         tlv_cursor_t cursor;
1056
1057         _NOTE(ARGUNUSED(length, end))
1058
1059         if ((rc = tlv_init_cursor_at_offset(&cursor, (uint8_t *)bufferp,
1060                         buffer_size, offset)) != 0) {
1061                 goto fail1;
1062         }
1063
1064         if ((rc = tlv_delete(&cursor)) != 0)
1065                 goto fail2;
1066
1067         return (0);
1068
1069 fail2:
1070         EFSYS_PROBE(fail2);
1071 fail1:
1072         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1073
1074         return (rc);
1075 }
1076
1077         __checkReturn           efx_rc_t
1078 ef10_nvram_buffer_finish(
1079         __in_bcount(buffer_size)
1080                                 caddr_t bufferp,
1081         __in                    size_t buffer_size)
1082 {
1083         efx_rc_t rc;
1084         tlv_cursor_t cursor;
1085
1086         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)bufferp,
1087                         buffer_size)) != 0) {
1088                 rc = EFAULT;
1089                 goto fail1;
1090         }
1091
1092         if ((rc = tlv_require_end(&cursor)) != 0)
1093                 goto fail2;
1094
1095         if ((rc = tlv_update_partition_len_and_cks(&cursor)) != 0)
1096                 goto fail3;
1097
1098         return (0);
1099
1100 fail3:
1101         EFSYS_PROBE(fail3);
1102 fail2:
1103         EFSYS_PROBE(fail2);
1104 fail1:
1105         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1106
1107         return (rc);
1108 }
1109
1110
1111
1112 /*
1113  * Read and validate a segment from a partition. A segment is a complete
1114  * tlv chain between PARTITION_HEADER and PARTITION_END tags. There may
1115  * be multiple segments in a partition, so seg_offset allows segments
1116  * beyond the first to be read.
1117  */
1118 static  __checkReturn                   efx_rc_t
1119 ef10_nvram_read_tlv_segment(
1120         __in                            efx_nic_t *enp,
1121         __in                            uint32_t partn,
1122         __in                            size_t seg_offset,
1123         __in_bcount(max_seg_size)       caddr_t seg_data,
1124         __in                            size_t max_seg_size)
1125 {
1126         tlv_cursor_t cursor;
1127         struct tlv_partition_header *header;
1128         struct tlv_partition_trailer *trailer;
1129         size_t total_length;
1130         uint32_t cksum;
1131         int pos;
1132         efx_rc_t rc;
1133
1134         EFX_STATIC_ASSERT(sizeof (*header) <= EF10_NVRAM_CHUNK);
1135
1136         if ((seg_data == NULL) || (max_seg_size == 0)) {
1137                 rc = EINVAL;
1138                 goto fail1;
1139         }
1140
1141         /* Read initial chunk of the segment, starting at offset */
1142         if ((rc = ef10_nvram_partn_read_mode(enp, partn, seg_offset, seg_data,
1143                     EF10_NVRAM_CHUNK,
1144                     MC_CMD_NVRAM_READ_IN_V2_TARGET_CURRENT)) != 0) {
1145                 goto fail2;
1146         }
1147
1148         /* A PARTITION_HEADER tag must be the first item at the given offset */
1149         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)seg_data,
1150                     max_seg_size)) != 0) {
1151                 rc = EFAULT;
1152                 goto fail3;
1153         }
1154         if (tlv_tag(&cursor) != TLV_TAG_PARTITION_HEADER) {
1155                 rc = EINVAL;
1156                 goto fail4;
1157         }
1158         header = (struct tlv_partition_header *)tlv_item(&cursor);
1159
1160         /* Check TLV segment length (includes the END tag) */
1161         total_length = __LE_TO_CPU_32(header->total_length);
1162         if (total_length > max_seg_size) {
1163                 rc = EFBIG;
1164                 goto fail5;
1165         }
1166
1167         /* Read the remaining segment content */
1168         if (total_length > EF10_NVRAM_CHUNK) {
1169                 if ((rc = ef10_nvram_partn_read_mode(enp, partn,
1170                             seg_offset + EF10_NVRAM_CHUNK,
1171                             seg_data + EF10_NVRAM_CHUNK,
1172                             total_length - EF10_NVRAM_CHUNK,
1173                             MC_CMD_NVRAM_READ_IN_V2_TARGET_CURRENT)) != 0)
1174                         goto fail6;
1175         }
1176
1177         /* Check segment ends with PARTITION_TRAILER and END tags */
1178         if ((rc = tlv_find(&cursor, TLV_TAG_PARTITION_TRAILER)) != 0) {
1179                 rc = EINVAL;
1180                 goto fail7;
1181         }
1182         trailer = (struct tlv_partition_trailer *)tlv_item(&cursor);
1183
1184         if ((rc = tlv_advance(&cursor)) != 0) {
1185                 rc = EINVAL;
1186                 goto fail8;
1187         }
1188         if (tlv_tag(&cursor) != TLV_TAG_END) {
1189                 rc = EINVAL;
1190                 goto fail9;
1191         }
1192
1193         /* Check data read from segment is consistent */
1194         if (trailer->generation != header->generation) {
1195                 /*
1196                  * The partition data may have been modified between successive
1197                  * MCDI NVRAM_READ requests by the MC or another PCI function.
1198                  *
1199                  * The caller must retry to obtain consistent partition data.
1200                  */
1201                 rc = EAGAIN;
1202                 goto fail10;
1203         }
1204
1205         /* Verify segment checksum */
1206         cksum = 0;
1207         for (pos = 0; (size_t)pos < total_length; pos += sizeof (uint32_t)) {
1208                 cksum += *((uint32_t *)(seg_data + pos));
1209         }
1210         if (cksum != 0) {
1211                 rc = EINVAL;
1212                 goto fail11;
1213         }
1214
1215         return (0);
1216
1217 fail11:
1218         EFSYS_PROBE(fail11);
1219 fail10:
1220         EFSYS_PROBE(fail10);
1221 fail9:
1222         EFSYS_PROBE(fail9);
1223 fail8:
1224         EFSYS_PROBE(fail8);
1225 fail7:
1226         EFSYS_PROBE(fail7);
1227 fail6:
1228         EFSYS_PROBE(fail6);
1229 fail5:
1230         EFSYS_PROBE(fail5);
1231 fail4:
1232         EFSYS_PROBE(fail4);
1233 fail3:
1234         EFSYS_PROBE(fail3);
1235 fail2:
1236         EFSYS_PROBE(fail2);
1237 fail1:
1238         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1239
1240         return (rc);
1241 }
1242
1243 /*
1244  * Read a single TLV item from a host memory
1245  * buffer containing a TLV formatted segment.
1246  */
1247         __checkReturn           efx_rc_t
1248 ef10_nvram_buf_read_tlv(
1249         __in                            efx_nic_t *enp,
1250         __in_bcount(max_seg_size)       caddr_t seg_data,
1251         __in                            size_t max_seg_size,
1252         __in                            uint32_t tag,
1253         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
1254         __out                           size_t *sizep)
1255 {
1256         tlv_cursor_t cursor;
1257         caddr_t data;
1258         size_t length;
1259         caddr_t value;
1260         efx_rc_t rc;
1261
1262         _NOTE(ARGUNUSED(enp))
1263
1264         if ((seg_data == NULL) || (max_seg_size == 0)) {
1265                 rc = EINVAL;
1266                 goto fail1;
1267         }
1268
1269         /* Find requested TLV tag in segment data */
1270         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)seg_data,
1271                     max_seg_size)) != 0) {
1272                 rc = EFAULT;
1273                 goto fail2;
1274         }
1275         if ((rc = tlv_find(&cursor, tag)) != 0) {
1276                 rc = ENOENT;
1277                 goto fail3;
1278         }
1279         value = (caddr_t)tlv_value(&cursor);
1280         length = tlv_length(&cursor);
1281
1282         if (length == 0)
1283                 data = NULL;
1284         else {
1285                 /* Copy out data from TLV item */
1286                 EFSYS_KMEM_ALLOC(enp->en_esip, length, data);
1287                 if (data == NULL) {
1288                         rc = ENOMEM;
1289                         goto fail4;
1290                 }
1291                 memcpy(data, value, length);
1292         }
1293
1294         *datap = data;
1295         *sizep = length;
1296
1297         return (0);
1298
1299 fail4:
1300         EFSYS_PROBE(fail4);
1301 fail3:
1302         EFSYS_PROBE(fail3);
1303 fail2:
1304         EFSYS_PROBE(fail2);
1305 fail1:
1306         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1307
1308         return (rc);
1309 }
1310
1311 /* Read a single TLV item from the first segment in a TLV formatted partition */
1312         __checkReturn           efx_rc_t
1313 ef10_nvram_partn_read_tlv(
1314         __in                                    efx_nic_t *enp,
1315         __in                                    uint32_t partn,
1316         __in                                    uint32_t tag,
1317         __deref_out_bcount_opt(*seg_sizep)      caddr_t *seg_datap,
1318         __out                                   size_t *seg_sizep)
1319 {
1320         caddr_t seg_data = NULL;
1321         size_t partn_size = 0;
1322         size_t length;
1323         caddr_t data;
1324         int retry;
1325         efx_rc_t rc;
1326
1327         /* Allocate sufficient memory for the entire partition */
1328         if ((rc = ef10_nvram_partn_size(enp, partn, &partn_size)) != 0)
1329                 goto fail1;
1330
1331         if (partn_size == 0) {
1332                 rc = ENOENT;
1333                 goto fail2;
1334         }
1335
1336         EFSYS_KMEM_ALLOC(enp->en_esip, partn_size, seg_data);
1337         if (seg_data == NULL) {
1338                 rc = ENOMEM;
1339                 goto fail3;
1340         }
1341
1342         /*
1343          * Read the first segment in a TLV partition. Retry until consistent
1344          * segment contents are returned. Inconsistent data may be read if:
1345          *  a) the segment contents are invalid
1346          *  b) the MC has rebooted while we were reading the partition
1347          *  c) the partition has been modified while we were reading it
1348          * Limit retry attempts to ensure forward progress.
1349          */
1350         retry = 10;
1351         do {
1352                 if ((rc = ef10_nvram_read_tlv_segment(enp, partn, 0,
1353                     seg_data, partn_size)) != 0)
1354                         --retry;
1355         } while ((rc == EAGAIN) && (retry > 0));
1356
1357         if (rc != 0) {
1358                 /* Failed to obtain consistent segment data */
1359                 if (rc == EAGAIN)
1360                         rc = EIO;
1361
1362                 goto fail4;
1363         }
1364
1365         if ((rc = ef10_nvram_buf_read_tlv(enp, seg_data, partn_size,
1366                     tag, &data, &length)) != 0)
1367                 goto fail5;
1368
1369         EFSYS_KMEM_FREE(enp->en_esip, partn_size, seg_data);
1370
1371         *seg_datap = data;
1372         *seg_sizep = length;
1373
1374         return (0);
1375
1376 fail5:
1377         EFSYS_PROBE(fail5);
1378 fail4:
1379         EFSYS_PROBE(fail4);
1380
1381         EFSYS_KMEM_FREE(enp->en_esip, partn_size, seg_data);
1382 fail3:
1383         EFSYS_PROBE(fail3);
1384 fail2:
1385         EFSYS_PROBE(fail2);
1386 fail1:
1387         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1388
1389         return (rc);
1390 }
1391
1392 /* Compute the size of a segment. */
1393         static  __checkReturn   efx_rc_t
1394 ef10_nvram_buf_segment_size(
1395         __in                    caddr_t seg_data,
1396         __in                    size_t max_seg_size,
1397         __out                   size_t *seg_sizep)
1398 {
1399         efx_rc_t rc;
1400         tlv_cursor_t cursor;
1401         struct tlv_partition_header *header;
1402         uint32_t cksum;
1403         int pos;
1404         uint32_t *end_tag_position;
1405         uint32_t segment_length;
1406
1407         /* A PARTITION_HEADER tag must be the first item at the given offset */
1408         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)seg_data,
1409                     max_seg_size)) != 0) {
1410                 rc = EFAULT;
1411                 goto fail1;
1412         }
1413         if (tlv_tag(&cursor) != TLV_TAG_PARTITION_HEADER) {
1414                 rc = EINVAL;
1415                 goto fail2;
1416         }
1417         header = (struct tlv_partition_header *)tlv_item(&cursor);
1418
1419         /* Check TLV segment length (includes the END tag) */
1420         *seg_sizep = __LE_TO_CPU_32(header->total_length);
1421         if (*seg_sizep > max_seg_size) {
1422                 rc = EFBIG;
1423                 goto fail3;
1424         }
1425
1426         /* Check segment ends with PARTITION_TRAILER and END tags */
1427         if ((rc = tlv_find(&cursor, TLV_TAG_PARTITION_TRAILER)) != 0) {
1428                 rc = EINVAL;
1429                 goto fail4;
1430         }
1431
1432         if ((rc = tlv_advance(&cursor)) != 0) {
1433                 rc = EINVAL;
1434                 goto fail5;
1435         }
1436         if (tlv_tag(&cursor) != TLV_TAG_END) {
1437                 rc = EINVAL;
1438                 goto fail6;
1439         }
1440         end_tag_position = cursor.current;
1441
1442         /* Verify segment checksum */
1443         cksum = 0;
1444         for (pos = 0; (size_t)pos < *seg_sizep; pos += sizeof (uint32_t)) {
1445                 cksum += *((uint32_t *)(seg_data + pos));
1446         }
1447         if (cksum != 0) {
1448                 rc = EINVAL;
1449                 goto fail7;
1450         }
1451
1452         /*
1453          * Calculate total length from HEADER to END tags and compare to
1454          * max_seg_size and the total_length field in the HEADER tag.
1455          */
1456         segment_length = tlv_block_length_used(&cursor);
1457
1458         if (segment_length > max_seg_size) {
1459                 rc = EINVAL;
1460                 goto fail8;
1461         }
1462
1463         if (segment_length != *seg_sizep) {
1464                 rc = EINVAL;
1465                 goto fail9;
1466         }
1467
1468         /* Skip over the first HEADER tag. */
1469         rc = tlv_rewind(&cursor);
1470         rc = tlv_advance(&cursor);
1471
1472         while (rc == 0) {
1473                 if (tlv_tag(&cursor) == TLV_TAG_END) {
1474                         /* Check that the END tag is the one found earlier. */
1475                         if (cursor.current != end_tag_position)
1476                                 goto fail10;
1477                         break;
1478                 }
1479                 /* Check for duplicate HEADER tags before the END tag. */
1480                 if (tlv_tag(&cursor) == TLV_TAG_PARTITION_HEADER) {
1481                         rc = EINVAL;
1482                         goto fail11;
1483                 }
1484
1485                 rc = tlv_advance(&cursor);
1486         }
1487         if (rc != 0)
1488                 goto fail12;
1489
1490         return (0);
1491
1492 fail12:
1493         EFSYS_PROBE(fail12);
1494 fail11:
1495         EFSYS_PROBE(fail11);
1496 fail10:
1497         EFSYS_PROBE(fail10);
1498 fail9:
1499         EFSYS_PROBE(fail9);
1500 fail8:
1501         EFSYS_PROBE(fail8);
1502 fail7:
1503         EFSYS_PROBE(fail7);
1504 fail6:
1505         EFSYS_PROBE(fail6);
1506 fail5:
1507         EFSYS_PROBE(fail5);
1508 fail4:
1509         EFSYS_PROBE(fail4);
1510 fail3:
1511         EFSYS_PROBE(fail3);
1512 fail2:
1513         EFSYS_PROBE(fail2);
1514 fail1:
1515         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1516
1517         return (rc);
1518 }
1519
1520 /*
1521  * Add or update a single TLV item in a host memory buffer containing a TLV
1522  * formatted segment. Historically partitions consisted of only one segment.
1523  */
1524         __checkReturn                   efx_rc_t
1525 ef10_nvram_buf_write_tlv(
1526         __inout_bcount(max_seg_size)    caddr_t seg_data,
1527         __in                            size_t max_seg_size,
1528         __in                            uint32_t tag,
1529         __in_bcount(tag_size)           caddr_t tag_data,
1530         __in                            size_t tag_size,
1531         __out                           size_t *total_lengthp)
1532 {
1533         tlv_cursor_t cursor;
1534         struct tlv_partition_header *header;
1535         struct tlv_partition_trailer *trailer;
1536         uint32_t generation;
1537         uint32_t cksum;
1538         int pos;
1539         efx_rc_t rc;
1540
1541         /* A PARTITION_HEADER tag must be the first item (at offset zero) */
1542         if ((rc = tlv_init_cursor_from_size(&cursor, (uint8_t *)seg_data,
1543                         max_seg_size)) != 0) {
1544                 rc = EFAULT;
1545                 goto fail1;
1546         }
1547         if (tlv_tag(&cursor) != TLV_TAG_PARTITION_HEADER) {
1548                 rc = EINVAL;
1549                 goto fail2;
1550         }
1551         header = (struct tlv_partition_header *)tlv_item(&cursor);
1552
1553         /* Update the TLV chain to contain the new data */
1554         if ((rc = tlv_find(&cursor, tag)) == 0) {
1555                 /* Modify existing TLV item */
1556                 if ((rc = tlv_modify(&cursor, tag,
1557                             (uint8_t *)tag_data, tag_size)) != 0)
1558                         goto fail3;
1559         } else {
1560                 /* Insert a new TLV item before the PARTITION_TRAILER */
1561                 rc = tlv_find(&cursor, TLV_TAG_PARTITION_TRAILER);
1562                 if (rc != 0) {
1563                         rc = EINVAL;
1564                         goto fail4;
1565                 }
1566                 if ((rc = tlv_insert(&cursor, tag,
1567                             (uint8_t *)tag_data, tag_size)) != 0) {
1568                         rc = EINVAL;
1569                         goto fail5;
1570                 }
1571         }
1572
1573         /* Find the trailer tag */
1574         if ((rc = tlv_find(&cursor, TLV_TAG_PARTITION_TRAILER)) != 0) {
1575                 rc = EINVAL;
1576                 goto fail6;
1577         }
1578         trailer = (struct tlv_partition_trailer *)tlv_item(&cursor);
1579
1580         /* Update PARTITION_HEADER and PARTITION_TRAILER fields */
1581         *total_lengthp = tlv_block_length_used(&cursor);
1582         if (*total_lengthp > max_seg_size) {
1583                 rc = ENOSPC;
1584                 goto fail7;
1585         }
1586         generation = __LE_TO_CPU_32(header->generation) + 1;
1587
1588         header->total_length    = __CPU_TO_LE_32(*total_lengthp);
1589         header->generation      = __CPU_TO_LE_32(generation);
1590         trailer->generation     = __CPU_TO_LE_32(generation);
1591
1592         /* Recompute PARTITION_TRAILER checksum */
1593         trailer->checksum = 0;
1594         cksum = 0;
1595         for (pos = 0; (size_t)pos < *total_lengthp; pos += sizeof (uint32_t)) {
1596                 cksum += *((uint32_t *)(seg_data + pos));
1597         }
1598         trailer->checksum = ~cksum + 1;
1599
1600         return (0);
1601
1602 fail7:
1603         EFSYS_PROBE(fail7);
1604 fail6:
1605         EFSYS_PROBE(fail6);
1606 fail5:
1607         EFSYS_PROBE(fail5);
1608 fail4:
1609         EFSYS_PROBE(fail4);
1610 fail3:
1611         EFSYS_PROBE(fail3);
1612 fail2:
1613         EFSYS_PROBE(fail2);
1614 fail1:
1615         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1616
1617         return (rc);
1618 }
1619
1620 /*
1621  * Add or update a single TLV item in the first segment of a TLV formatted
1622  * dynamic config partition. The first segment is the current active
1623  * configuration.
1624  */
1625         __checkReturn           efx_rc_t
1626 ef10_nvram_partn_write_tlv(
1627         __in                    efx_nic_t *enp,
1628         __in                    uint32_t partn,
1629         __in                    uint32_t tag,
1630         __in_bcount(size)       caddr_t data,
1631         __in                    size_t size)
1632 {
1633         return ef10_nvram_partn_write_segment_tlv(enp, partn, tag, data,
1634             size, B_FALSE);
1635 }
1636
1637 /*
1638  * Read a segment from nvram at the given offset into a buffer (segment_data)
1639  * and optionally write a new tag to it.
1640  */
1641 static  __checkReturn           efx_rc_t
1642 ef10_nvram_segment_write_tlv(
1643         __in                    efx_nic_t *enp,
1644         __in                    uint32_t partn,
1645         __in                    uint32_t tag,
1646         __in_bcount(size)       caddr_t data,
1647         __in                    size_t size,
1648         __inout                 caddr_t *seg_datap,
1649         __inout                 size_t *partn_offsetp,
1650         __inout                 size_t *src_remain_lenp,
1651         __inout                 size_t *dest_remain_lenp,
1652         __in                    boolean_t write)
1653 {
1654         efx_rc_t rc;
1655         efx_rc_t status;
1656         size_t original_segment_size;
1657         size_t modified_segment_size;
1658
1659         /*
1660          * Read the segment from NVRAM into the segment_data buffer and validate
1661          * it, returning if it does not validate. This is not a failure unless
1662          * this is the first segment in a partition. In this case the caller
1663          * must propagate the error.
1664          */
1665         status = ef10_nvram_read_tlv_segment(enp, partn, *partn_offsetp,
1666             *seg_datap, *src_remain_lenp);
1667         if (status != 0) {
1668                 rc = EINVAL;
1669                 goto fail1;
1670         }
1671
1672         status = ef10_nvram_buf_segment_size(*seg_datap,
1673             *src_remain_lenp, &original_segment_size);
1674         if (status != 0) {
1675                 rc = EINVAL;
1676                 goto fail2;
1677         }
1678
1679         if (write) {
1680                 /* Update the contents of the segment in the buffer */
1681                 if ((rc = ef10_nvram_buf_write_tlv(*seg_datap,
1682                         *dest_remain_lenp, tag, data, size,
1683                         &modified_segment_size)) != 0) {
1684                         goto fail3;
1685                 }
1686                 *dest_remain_lenp -= modified_segment_size;
1687                 *seg_datap += modified_segment_size;
1688         } else {
1689                 /*
1690                  * We won't modify this segment, but still need to update the
1691                  * remaining lengths and pointers.
1692                  */
1693                 *dest_remain_lenp -= original_segment_size;
1694                 *seg_datap += original_segment_size;
1695         }
1696
1697         *partn_offsetp += original_segment_size;
1698         *src_remain_lenp -= original_segment_size;
1699
1700         return (0);
1701
1702 fail3:
1703         EFSYS_PROBE(fail3);
1704 fail2:
1705         EFSYS_PROBE(fail2);
1706 fail1:
1707         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1708
1709         return (rc);
1710 }
1711
1712 /*
1713  * Add or update a single TLV item in either the first segment or in all
1714  * segments in a TLV formatted dynamic config partition. Dynamic config
1715  * partitions on boards that support RFID are divided into a number of segments,
1716  * each formatted like a partition, with header, trailer and end tags. The first
1717  * segment is the current active configuration.
1718  *
1719  * The segments are initialised by manftest and each contain a different
1720  * configuration e.g. firmware variant. The firmware can be instructed
1721  * via RFID to copy a segment to replace the first segment, hence changing the
1722  * active configuration.  This allows ops to change the configuration of a board
1723  * prior to shipment using RFID.
1724  *
1725  * Changes to the dynamic config may need to be written to all segments (e.g.
1726  * firmware versions) or just the first segment (changes to the active
1727  * configuration). See SF-111324-SW "The use of RFID in Solarflare Products".
1728  * If only the first segment is written the code still needs to be aware of the
1729  * possible presence of subsequent segments as writing to a segment may cause
1730  * its size to increase, which would overwrite the subsequent segments and
1731  * invalidate them.
1732  */
1733         __checkReturn           efx_rc_t
1734 ef10_nvram_partn_write_segment_tlv(
1735         __in                    efx_nic_t *enp,
1736         __in                    uint32_t partn,
1737         __in                    uint32_t tag,
1738         __in_bcount(size)       caddr_t data,
1739         __in                    size_t size,
1740         __in                    boolean_t all_segments)
1741 {
1742         size_t partn_size = 0;
1743         caddr_t partn_data;
1744         size_t total_length = 0;
1745         efx_rc_t rc;
1746         size_t current_offset = 0;
1747         size_t remaining_original_length;
1748         size_t remaining_modified_length;
1749         caddr_t segment_data;
1750
1751         EFSYS_ASSERT3U(partn, ==, NVRAM_PARTITION_TYPE_DYNAMIC_CONFIG);
1752
1753         /* Allocate sufficient memory for the entire partition */
1754         if ((rc = ef10_nvram_partn_size(enp, partn, &partn_size)) != 0)
1755                 goto fail1;
1756
1757         EFSYS_KMEM_ALLOC(enp->en_esip, partn_size, partn_data);
1758         if (partn_data == NULL) {
1759                 rc = ENOMEM;
1760                 goto fail2;
1761         }
1762
1763         remaining_original_length = partn_size;
1764         remaining_modified_length = partn_size;
1765         segment_data = partn_data;
1766
1767         /* Lock the partition */
1768         if ((rc = ef10_nvram_partn_lock(enp, partn)) != 0)
1769                 goto fail3;
1770
1771         /* Iterate over each (potential) segment to update it. */
1772         do {
1773                 boolean_t write = all_segments || current_offset == 0;
1774
1775                 rc = ef10_nvram_segment_write_tlv(enp, partn, tag, data, size,
1776                     &segment_data, &current_offset, &remaining_original_length,
1777                     &remaining_modified_length, write);
1778                 if (rc != 0) {
1779                         if (current_offset == 0) {
1780                                 /*
1781                                  * If no data has been read then the first
1782                                  * segment is invalid, which is an error.
1783                                  */
1784                                 goto fail4;
1785                         }
1786                         break;
1787                 }
1788         } while (current_offset < partn_size);
1789
1790         total_length = segment_data - partn_data;
1791
1792         /*
1793          * We've run out of space.  This should actually be dealt with by
1794          * ef10_nvram_buf_write_tlv returning ENOSPC.
1795          */
1796         if (total_length > partn_size) {
1797                 rc = ENOSPC;
1798                 goto fail5;
1799         }
1800
1801         /* Erase the whole partition in NVRAM */
1802         if ((rc = ef10_nvram_partn_erase(enp, partn, 0, partn_size)) != 0)
1803                 goto fail6;
1804
1805         /* Write new partition contents from the buffer to NVRAM */
1806         if ((rc = ef10_nvram_partn_write(enp, partn, 0, partn_data,
1807                     total_length)) != 0)
1808                 goto fail7;
1809
1810         /* Unlock the partition */
1811         ef10_nvram_partn_unlock(enp, partn, NULL);
1812
1813         EFSYS_KMEM_FREE(enp->en_esip, partn_size, partn_data);
1814
1815         return (0);
1816
1817 fail7:
1818         EFSYS_PROBE(fail7);
1819 fail6:
1820         EFSYS_PROBE(fail6);
1821 fail5:
1822         EFSYS_PROBE(fail5);
1823 fail4:
1824         EFSYS_PROBE(fail4);
1825
1826         ef10_nvram_partn_unlock(enp, partn, NULL);
1827 fail3:
1828         EFSYS_PROBE(fail3);
1829
1830         EFSYS_KMEM_FREE(enp->en_esip, partn_size, partn_data);
1831 fail2:
1832         EFSYS_PROBE(fail2);
1833 fail1:
1834         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1835
1836         return (rc);
1837 }
1838
1839 /*
1840  * Get the size of a NVRAM partition. This is the total size allocated in nvram,
1841  * not the data used by the segments in the partition.
1842  */
1843         __checkReturn           efx_rc_t
1844 ef10_nvram_partn_size(
1845         __in                    efx_nic_t *enp,
1846         __in                    uint32_t partn,
1847         __out                   size_t *sizep)
1848 {
1849         efx_rc_t rc;
1850
1851         if ((rc = efx_mcdi_nvram_info(enp, partn, sizep,
1852             NULL, NULL, NULL)) != 0)
1853                 goto fail1;
1854
1855         return (0);
1856
1857 fail1:
1858         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1859
1860         return (rc);
1861 }
1862
1863         __checkReturn           efx_rc_t
1864 ef10_nvram_partn_lock(
1865         __in                    efx_nic_t *enp,
1866         __in                    uint32_t partn)
1867 {
1868         efx_rc_t rc;
1869
1870         if ((rc = efx_mcdi_nvram_update_start(enp, partn)) != 0)
1871                 goto fail1;
1872
1873         return (0);
1874
1875 fail1:
1876         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1877
1878         return (rc);
1879 }
1880
1881         __checkReturn           efx_rc_t
1882 ef10_nvram_partn_read_mode(
1883         __in                    efx_nic_t *enp,
1884         __in                    uint32_t partn,
1885         __in                    unsigned int offset,
1886         __out_bcount(size)      caddr_t data,
1887         __in                    size_t size,
1888         __in                    uint32_t mode)
1889 {
1890         size_t chunk;
1891         efx_rc_t rc;
1892
1893         while (size > 0) {
1894                 chunk = MIN(size, EF10_NVRAM_CHUNK);
1895
1896                 if ((rc = efx_mcdi_nvram_read(enp, partn, offset,
1897                             data, chunk, mode)) != 0) {
1898                         goto fail1;
1899                 }
1900
1901                 size -= chunk;
1902                 data += chunk;
1903                 offset += chunk;
1904         }
1905
1906         return (0);
1907
1908 fail1:
1909         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1910
1911         return (rc);
1912 }
1913
1914         __checkReturn           efx_rc_t
1915 ef10_nvram_partn_read(
1916         __in                    efx_nic_t *enp,
1917         __in                    uint32_t partn,
1918         __in                    unsigned int offset,
1919         __out_bcount(size)      caddr_t data,
1920         __in                    size_t size)
1921 {
1922         /*
1923          * An A/B partition has two data stores (current and backup).
1924          * Read requests which come in through the EFX API expect to read the
1925          * current, active store of an A/B partition. For non A/B partitions,
1926          * there is only a single store and so the mode param is ignored.
1927          */
1928         return ef10_nvram_partn_read_mode(enp, partn, offset, data, size,
1929                             MC_CMD_NVRAM_READ_IN_V2_TARGET_CURRENT);
1930 }
1931
1932         __checkReturn           efx_rc_t
1933 ef10_nvram_partn_read_backup(
1934         __in                    efx_nic_t *enp,
1935         __in                    uint32_t partn,
1936         __in                    unsigned int offset,
1937         __out_bcount(size)      caddr_t data,
1938         __in                    size_t size)
1939 {
1940         /*
1941          * An A/B partition has two data stores (current and backup).
1942          * Read the backup store of an A/B partition (i.e. the store currently
1943          * being written to if the partition is locked).
1944          *
1945          * This is needed when comparing the existing partition content to avoid
1946          * unnecessary writes, or to read back what has been written to check
1947          * that the writes have succeeded.
1948          */
1949         return ef10_nvram_partn_read_mode(enp, partn, offset, data, size,
1950                             MC_CMD_NVRAM_READ_IN_V2_TARGET_BACKUP);
1951 }
1952
1953         __checkReturn           efx_rc_t
1954 ef10_nvram_partn_erase(
1955         __in                    efx_nic_t *enp,
1956         __in                    uint32_t partn,
1957         __in                    unsigned int offset,
1958         __in                    size_t size)
1959 {
1960         efx_rc_t rc;
1961         uint32_t erase_size;
1962
1963         if ((rc = efx_mcdi_nvram_info(enp, partn, NULL, NULL,
1964             &erase_size, NULL)) != 0)
1965                 goto fail1;
1966
1967         if (erase_size == 0) {
1968                 if ((rc = efx_mcdi_nvram_erase(enp, partn, offset, size)) != 0)
1969                         goto fail2;
1970         } else {
1971                 if (size % erase_size != 0) {
1972                         rc = EINVAL;
1973                         goto fail3;
1974                 }
1975                 while (size > 0) {
1976                         if ((rc = efx_mcdi_nvram_erase(enp, partn, offset,
1977                             erase_size)) != 0)
1978                                 goto fail4;
1979                         offset += erase_size;
1980                         size -= erase_size;
1981                 }
1982         }
1983
1984         return (0);
1985
1986 fail4:
1987         EFSYS_PROBE(fail4);
1988 fail3:
1989         EFSYS_PROBE(fail3);
1990 fail2:
1991         EFSYS_PROBE(fail2);
1992 fail1:
1993         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1994
1995         return (rc);
1996 }
1997
1998         __checkReturn           efx_rc_t
1999 ef10_nvram_partn_write(
2000         __in                    efx_nic_t *enp,
2001         __in                    uint32_t partn,
2002         __in                    unsigned int offset,
2003         __out_bcount(size)      caddr_t data,
2004         __in                    size_t size)
2005 {
2006         size_t chunk;
2007         uint32_t write_size;
2008         efx_rc_t rc;
2009
2010         if ((rc = efx_mcdi_nvram_info(enp, partn, NULL, NULL,
2011             NULL, &write_size)) != 0)
2012                 goto fail1;
2013
2014         if (write_size != 0) {
2015                 /*
2016                  * Check that the size is a multiple of the write chunk size if
2017                  * the write chunk size is available.
2018                  */
2019                 if (size % write_size != 0) {
2020                         rc = EINVAL;
2021                         goto fail2;
2022                 }
2023         } else {
2024                 write_size = EF10_NVRAM_CHUNK;
2025         }
2026
2027         while (size > 0) {
2028                 chunk = MIN(size, write_size);
2029
2030                 if ((rc = efx_mcdi_nvram_write(enp, partn, offset,
2031                             data, chunk)) != 0) {
2032                         goto fail3;
2033                 }
2034
2035                 size -= chunk;
2036                 data += chunk;
2037                 offset += chunk;
2038         }
2039
2040         return (0);
2041
2042 fail3:
2043         EFSYS_PROBE(fail3);
2044 fail2:
2045         EFSYS_PROBE(fail2);
2046 fail1:
2047         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2048
2049         return (rc);
2050 }
2051
2052         __checkReturn           efx_rc_t
2053 ef10_nvram_partn_unlock(
2054         __in                    efx_nic_t *enp,
2055         __in                    uint32_t partn,
2056         __out_opt               uint32_t *verify_resultp)
2057 {
2058         boolean_t reboot = B_FALSE;
2059         efx_rc_t rc;
2060
2061         if (verify_resultp != NULL)
2062                 *verify_resultp = MC_CMD_NVRAM_VERIFY_RC_UNKNOWN;
2063
2064         rc = efx_mcdi_nvram_update_finish(enp, partn, reboot, verify_resultp);
2065         if (rc != 0)
2066                 goto fail1;
2067
2068         return (0);
2069
2070 fail1:
2071         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2072
2073         return (rc);
2074 }
2075
2076         __checkReturn           efx_rc_t
2077 ef10_nvram_partn_set_version(
2078         __in                    efx_nic_t *enp,
2079         __in                    uint32_t partn,
2080         __in_ecount(4)          uint16_t version[4])
2081 {
2082         struct tlv_partition_version partn_version;
2083         size_t size;
2084         efx_rc_t rc;
2085
2086         /* Add or modify partition version TLV item */
2087         partn_version.version_w = __CPU_TO_LE_16(version[0]);
2088         partn_version.version_x = __CPU_TO_LE_16(version[1]);
2089         partn_version.version_y = __CPU_TO_LE_16(version[2]);
2090         partn_version.version_z = __CPU_TO_LE_16(version[3]);
2091
2092         size = sizeof (partn_version) - (2 * sizeof (uint32_t));
2093
2094         /* Write the version number to all segments in the partition */
2095         if ((rc = ef10_nvram_partn_write_segment_tlv(enp,
2096                     NVRAM_PARTITION_TYPE_DYNAMIC_CONFIG,
2097                     TLV_TAG_PARTITION_VERSION(partn),
2098                     (caddr_t)&partn_version.version_w, size, B_TRUE)) != 0)
2099                 goto fail1;
2100
2101         return (0);
2102
2103 fail1:
2104         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2105
2106         return (rc);
2107 }
2108
2109 #endif /* EFSYS_OPT_VPD || EFSYS_OPT_NVRAM */
2110
2111 #if EFSYS_OPT_NVRAM
2112
2113 typedef struct ef10_parttbl_entry_s {
2114         unsigned int            partn;
2115         unsigned int            port_mask;
2116         efx_nvram_type_t        nvtype;
2117 } ef10_parttbl_entry_t;
2118
2119 /* Port mask values */
2120 #define PORT_1          (1u << 1)
2121 #define PORT_2          (1u << 2)
2122 #define PORT_3          (1u << 3)
2123 #define PORT_4          (1u << 4)
2124 #define PORT_ALL        (0xffffffffu)
2125
2126 #define PARTN_MAP_ENTRY(partn, port_mask, nvtype)       \
2127 { (NVRAM_PARTITION_TYPE_##partn), (PORT_##port_mask), (EFX_NVRAM_##nvtype) }
2128
2129 /* Translate EFX NVRAM types to firmware partition types */
2130 static ef10_parttbl_entry_t hunt_parttbl[] = {
2131         /*              partn                   ports   nvtype */
2132         PARTN_MAP_ENTRY(MC_FIRMWARE,            ALL,    MC_FIRMWARE),
2133         PARTN_MAP_ENTRY(MC_FIRMWARE_BACKUP,     ALL,    MC_GOLDEN),
2134         PARTN_MAP_ENTRY(EXPANSION_ROM,          ALL,    BOOTROM),
2135         PARTN_MAP_ENTRY(EXPROM_CONFIG_PORT0,    1,      BOOTROM_CFG),
2136         PARTN_MAP_ENTRY(EXPROM_CONFIG_PORT1,    2,      BOOTROM_CFG),
2137         PARTN_MAP_ENTRY(EXPROM_CONFIG_PORT2,    3,      BOOTROM_CFG),
2138         PARTN_MAP_ENTRY(EXPROM_CONFIG_PORT3,    4,      BOOTROM_CFG),
2139         PARTN_MAP_ENTRY(DYNAMIC_CONFIG,         ALL,    DYNAMIC_CFG),
2140         PARTN_MAP_ENTRY(FPGA,                   ALL,    FPGA),
2141         PARTN_MAP_ENTRY(FPGA_BACKUP,            ALL,    FPGA_BACKUP),
2142         PARTN_MAP_ENTRY(LICENSE,                ALL,    LICENSE),
2143 };
2144
2145 static ef10_parttbl_entry_t medford_parttbl[] = {
2146         /*              partn                   ports   nvtype */
2147         PARTN_MAP_ENTRY(MC_FIRMWARE,            ALL,    MC_FIRMWARE),
2148         PARTN_MAP_ENTRY(MC_FIRMWARE_BACKUP,     ALL,    MC_GOLDEN),
2149         PARTN_MAP_ENTRY(EXPANSION_ROM,          ALL,    BOOTROM),
2150         PARTN_MAP_ENTRY(EXPROM_CONFIG,          ALL,    BOOTROM_CFG),
2151         PARTN_MAP_ENTRY(DYNAMIC_CONFIG,         ALL,    DYNAMIC_CFG),
2152         PARTN_MAP_ENTRY(FPGA,                   ALL,    FPGA),
2153         PARTN_MAP_ENTRY(FPGA_BACKUP,            ALL,    FPGA_BACKUP),
2154         PARTN_MAP_ENTRY(LICENSE,                ALL,    LICENSE),
2155         PARTN_MAP_ENTRY(EXPANSION_UEFI,         ALL,    UEFIROM),
2156         PARTN_MAP_ENTRY(MUM_FIRMWARE,           ALL,    MUM_FIRMWARE),
2157 };
2158
2159 static ef10_parttbl_entry_t medford2_parttbl[] = {
2160         /*              partn                   ports   nvtype */
2161         PARTN_MAP_ENTRY(MC_FIRMWARE,            ALL,    MC_FIRMWARE),
2162         PARTN_MAP_ENTRY(MC_FIRMWARE_BACKUP,     ALL,    MC_GOLDEN),
2163         PARTN_MAP_ENTRY(EXPANSION_ROM,          ALL,    BOOTROM),
2164         PARTN_MAP_ENTRY(EXPROM_CONFIG,          ALL,    BOOTROM_CFG),
2165         PARTN_MAP_ENTRY(DYNAMIC_CONFIG,         ALL,    DYNAMIC_CFG),
2166         PARTN_MAP_ENTRY(FPGA,                   ALL,    FPGA),
2167         PARTN_MAP_ENTRY(FPGA_BACKUP,            ALL,    FPGA_BACKUP),
2168         PARTN_MAP_ENTRY(LICENSE,                ALL,    LICENSE),
2169         PARTN_MAP_ENTRY(EXPANSION_UEFI,         ALL,    UEFIROM),
2170         PARTN_MAP_ENTRY(MUM_FIRMWARE,           ALL,    MUM_FIRMWARE),
2171 };
2172
2173 static  __checkReturn           efx_rc_t
2174 ef10_parttbl_get(
2175         __in                    efx_nic_t *enp,
2176         __out                   ef10_parttbl_entry_t **parttblp,
2177         __out                   size_t *parttbl_rowsp)
2178 {
2179         switch (enp->en_family) {
2180         case EFX_FAMILY_HUNTINGTON:
2181                 *parttblp = hunt_parttbl;
2182                 *parttbl_rowsp = EFX_ARRAY_SIZE(hunt_parttbl);
2183                 break;
2184
2185         case EFX_FAMILY_MEDFORD:
2186                 *parttblp = medford_parttbl;
2187                 *parttbl_rowsp = EFX_ARRAY_SIZE(medford_parttbl);
2188                 break;
2189
2190         case EFX_FAMILY_MEDFORD2:
2191                 *parttblp = medford2_parttbl;
2192                 *parttbl_rowsp = EFX_ARRAY_SIZE(medford2_parttbl);
2193                 break;
2194
2195         default:
2196                 EFSYS_ASSERT(B_FALSE);
2197                 return (EINVAL);
2198         }
2199         return (0);
2200 }
2201
2202         __checkReturn           efx_rc_t
2203 ef10_nvram_type_to_partn(
2204         __in                    efx_nic_t *enp,
2205         __in                    efx_nvram_type_t type,
2206         __out                   uint32_t *partnp)
2207 {
2208         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
2209         ef10_parttbl_entry_t *parttbl = NULL;
2210         size_t parttbl_rows = 0;
2211         unsigned int i;
2212
2213         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
2214         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
2215         EFSYS_ASSERT(partnp != NULL);
2216
2217         if (ef10_parttbl_get(enp, &parttbl, &parttbl_rows) == 0) {
2218                 for (i = 0; i < parttbl_rows; i++) {
2219                         ef10_parttbl_entry_t *entry = &parttbl[i];
2220
2221                         if ((entry->nvtype == type) &&
2222                             (entry->port_mask & (1u << emip->emi_port))) {
2223                                 *partnp = entry->partn;
2224                                 return (0);
2225                         }
2226                 }
2227         }
2228
2229         return (ENOTSUP);
2230 }
2231
2232 #if EFSYS_OPT_DIAG
2233
2234 static  __checkReturn           efx_rc_t
2235 ef10_nvram_partn_to_type(
2236         __in                    efx_nic_t *enp,
2237         __in                    uint32_t partn,
2238         __out                   efx_nvram_type_t *typep)
2239 {
2240         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
2241         ef10_parttbl_entry_t *parttbl = NULL;
2242         size_t parttbl_rows = 0;
2243         unsigned int i;
2244
2245         EFSYS_ASSERT(typep != NULL);
2246
2247         if (ef10_parttbl_get(enp, &parttbl, &parttbl_rows) == 0) {
2248                 for (i = 0; i < parttbl_rows; i++) {
2249                         ef10_parttbl_entry_t *entry = &parttbl[i];
2250
2251                         if ((entry->partn == partn) &&
2252                             (entry->port_mask & (1u << emip->emi_port))) {
2253                                 *typep = entry->nvtype;
2254                                 return (0);
2255                         }
2256                 }
2257         }
2258
2259         return (ENOTSUP);
2260 }
2261
2262         __checkReturn           efx_rc_t
2263 ef10_nvram_test(
2264         __in                    efx_nic_t *enp)
2265 {
2266         efx_nvram_type_t type;
2267         unsigned int npartns = 0;
2268         uint32_t *partns = NULL;
2269         size_t size;
2270         unsigned int i;
2271         efx_rc_t rc;
2272
2273         /* Read available partitions from NVRAM partition map */
2274         size = MC_CMD_NVRAM_PARTITIONS_OUT_TYPE_ID_MAXNUM * sizeof (uint32_t);
2275         EFSYS_KMEM_ALLOC(enp->en_esip, size, partns);
2276         if (partns == NULL) {
2277                 rc = ENOMEM;
2278                 goto fail1;
2279         }
2280
2281         if ((rc = efx_mcdi_nvram_partitions(enp, (caddr_t)partns, size,
2282                     &npartns)) != 0) {
2283                 goto fail2;
2284         }
2285
2286         for (i = 0; i < npartns; i++) {
2287                 /* Check if the partition is supported for this port */
2288                 if ((rc = ef10_nvram_partn_to_type(enp, partns[i], &type)) != 0)
2289                         continue;
2290
2291                 if ((rc = efx_mcdi_nvram_test(enp, partns[i])) != 0)
2292                         goto fail3;
2293         }
2294
2295         EFSYS_KMEM_FREE(enp->en_esip, size, partns);
2296         return (0);
2297
2298 fail3:
2299         EFSYS_PROBE(fail3);
2300 fail2:
2301         EFSYS_PROBE(fail2);
2302         EFSYS_KMEM_FREE(enp->en_esip, size, partns);
2303 fail1:
2304         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2305         return (rc);
2306 }
2307
2308 #endif  /* EFSYS_OPT_DIAG */
2309
2310         __checkReturn           efx_rc_t
2311 ef10_nvram_partn_get_version(
2312         __in                    efx_nic_t *enp,
2313         __in                    uint32_t partn,
2314         __out                   uint32_t *subtypep,
2315         __out_ecount(4)         uint16_t version[4])
2316 {
2317         efx_rc_t rc;
2318
2319         /* FIXME: get highest partn version from all ports */
2320         /* FIXME: return partn description if available */
2321
2322         if ((rc = efx_mcdi_nvram_metadata(enp, partn, subtypep,
2323                     version, NULL, 0)) != 0)
2324                 goto fail1;
2325
2326         return (0);
2327
2328 fail1:
2329         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2330
2331         return (rc);
2332 }
2333
2334         __checkReturn           efx_rc_t
2335 ef10_nvram_partn_rw_start(
2336         __in                    efx_nic_t *enp,
2337         __in                    uint32_t partn,
2338         __out                   size_t *chunk_sizep)
2339 {
2340         uint32_t write_size = 0;
2341         efx_rc_t rc;
2342
2343         if ((rc = efx_mcdi_nvram_info(enp, partn, NULL, NULL,
2344             NULL, &write_size)) != 0)
2345                 goto fail1;
2346
2347         if ((rc = ef10_nvram_partn_lock(enp, partn)) != 0)
2348                 goto fail2;
2349
2350         if (chunk_sizep != NULL) {
2351                 if (write_size == 0)
2352                         *chunk_sizep = EF10_NVRAM_CHUNK;
2353                 else
2354                         *chunk_sizep = write_size;
2355         }
2356
2357         return (0);
2358
2359 fail2:
2360         EFSYS_PROBE(fail2);
2361 fail1:
2362         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2363
2364         return (rc);
2365 }
2366
2367         __checkReturn           efx_rc_t
2368 ef10_nvram_partn_rw_finish(
2369         __in                    efx_nic_t *enp,
2370         __in                    uint32_t partn,
2371         __out_opt               uint32_t *verify_resultp)
2372 {
2373         efx_rc_t rc;
2374
2375         if ((rc = ef10_nvram_partn_unlock(enp, partn, verify_resultp)) != 0)
2376                 goto fail1;
2377
2378         return (0);
2379
2380 fail1:
2381         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2382
2383         return (rc);
2384 }
2385
2386 #endif  /* EFSYS_OPT_NVRAM */
2387
2388 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */