drivers/net/sfc/base/efx_nvram.c

   1 /*
   2  * Copyright (c) 2009-2016 Solarflare Communications Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  24  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * The views and conclusions contained in the software and documentation are
  27  * those of the authors and should not be interpreted as representing official
  28  * policies, either expressed or implied, of the FreeBSD Project.
  29  */
  30
  31 #include "efx.h"
  32 #include "efx_impl.h"
  33
  34 #if EFSYS_OPT_NVRAM
  35
  36 #if EFSYS_OPT_SIENA
  37
  38 static const efx_nvram_ops_t    __efx_nvram_siena_ops = {
  39 #if EFSYS_OPT_DIAG
  40         siena_nvram_test,               /* envo_test */
  41 #endif  /* EFSYS_OPT_DIAG */
  42         siena_nvram_type_to_partn,      /* envo_type_to_partn */
  43         siena_nvram_partn_size,         /* envo_partn_size */
  44         siena_nvram_partn_rw_start,     /* envo_partn_rw_start */
  45         siena_nvram_partn_read,         /* envo_partn_read */
  46         siena_nvram_partn_erase,        /* envo_partn_erase */
  47         siena_nvram_partn_write,        /* envo_partn_write */
  48         siena_nvram_partn_rw_finish,    /* envo_partn_rw_finish */
  49         siena_nvram_partn_get_version,  /* envo_partn_get_version */
  50         siena_nvram_partn_set_version,  /* envo_partn_set_version */
  51         NULL,                           /* envo_partn_validate */
  52 };
  53
  54 #endif  /* EFSYS_OPT_SIENA */
  55
  56 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
  57
  58 static const efx_nvram_ops_t    __efx_nvram_ef10_ops = {
  59 #if EFSYS_OPT_DIAG
  60         ef10_nvram_test,                /* envo_test */
  61 #endif  /* EFSYS_OPT_DIAG */
  62         ef10_nvram_type_to_partn,       /* envo_type_to_partn */
  63         ef10_nvram_partn_size,          /* envo_partn_size */
  64         ef10_nvram_partn_rw_start,      /* envo_partn_rw_start */
  65         ef10_nvram_partn_read,          /* envo_partn_read */
  66         ef10_nvram_partn_erase,         /* envo_partn_erase */
  67         ef10_nvram_partn_write,         /* envo_partn_write */
  68         ef10_nvram_partn_rw_finish,     /* envo_partn_rw_finish */
  69         ef10_nvram_partn_get_version,   /* envo_partn_get_version */
  70         ef10_nvram_partn_set_version,   /* envo_partn_set_version */
  71         ef10_nvram_buffer_validate,     /* envo_buffer_validate */
  72 };
  73
  74 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */
  75
  76         __checkReturn   efx_rc_t
  77 efx_nvram_init(
  78         __in            efx_nic_t *enp)
  79 {
  80         const efx_nvram_ops_t *envop;
  81         efx_rc_t rc;
  82
  83         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
  84         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
  85         EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_NVRAM));
  86
  87         switch (enp->en_family) {
  88 #if EFSYS_OPT_SIENA
  89         case EFX_FAMILY_SIENA:
  90                 envop = &__efx_nvram_siena_ops;
  91                 break;
  92 #endif  /* EFSYS_OPT_SIENA */
  93
  94 #if EFSYS_OPT_HUNTINGTON
  95         case EFX_FAMILY_HUNTINGTON:
  96                 envop = &__efx_nvram_ef10_ops;
  97                 break;
  98 #endif  /* EFSYS_OPT_HUNTINGTON */
  99
 100 #if EFSYS_OPT_MEDFORD
 101         case EFX_FAMILY_MEDFORD:
 102                 envop = &__efx_nvram_ef10_ops;
 103                 break;
 104 #endif  /* EFSYS_OPT_MEDFORD */
 105
 106         default:
 107                 EFSYS_ASSERT(0);
 108                 rc = ENOTSUP;
 109                 goto fail1;
 110         }
 111
 112         enp->en_envop = envop;
 113         enp->en_mod_flags |= EFX_MOD_NVRAM;
 114
 115         return (0);
 116
 117 fail1:
 118         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 119
 120         return (rc);
 121 }
 122
 123 #if EFSYS_OPT_DIAG
 124
 125         __checkReturn           efx_rc_t
 126 efx_nvram_test(
 127         __in                    efx_nic_t *enp)
 128 {
 129         const efx_nvram_ops_t *envop = enp->en_envop;
 130         efx_rc_t rc;
 131
 132         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 133         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 134
 135         if ((rc = envop->envo_test(enp)) != 0)
 136                 goto fail1;
 137
 138         return (0);
 139
 140 fail1:
 141         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 142
 143         return (rc);
 144 }
 145
 146 #endif  /* EFSYS_OPT_DIAG */
 147
 148         __checkReturn           efx_rc_t
 149 efx_nvram_size(
 150         __in                    efx_nic_t *enp,
 151         __in                    efx_nvram_type_t type,
 152         __out                   size_t *sizep)
 153 {
 154         const efx_nvram_ops_t *envop = enp->en_envop;
 155         uint32_t partn;
 156         efx_rc_t rc;
 157
 158         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 159         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 160
 161         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 162
 163         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 164                 goto fail1;
 165
 166         if ((rc = envop->envo_partn_size(enp, partn, sizep)) != 0)
 167                 goto fail2;
 168
 169         return (0);
 170
 171 fail2:
 172         EFSYS_PROBE(fail2);
 173 fail1:
 174         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 175         *sizep = 0;
 176
 177         return (rc);
 178 }
 179
 180         __checkReturn           efx_rc_t
 181 efx_nvram_get_version(
 182         __in                    efx_nic_t *enp,
 183         __in                    efx_nvram_type_t type,
 184         __out                   uint32_t *subtypep,
 185         __out_ecount(4)         uint16_t version[4])
 186 {
 187         const efx_nvram_ops_t *envop = enp->en_envop;
 188         uint32_t partn;
 189         efx_rc_t rc;
 190
 191         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 192         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
 193         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 194
 195         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 196
 197         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 198                 goto fail1;
 199
 200         if ((rc = envop->envo_partn_get_version(enp, partn,
 201                     subtypep, version)) != 0)
 202                 goto fail2;
 203
 204         return (0);
 205
 206 fail2:
 207         EFSYS_PROBE(fail2);
 208 fail1:
 209         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 210
 211         return (rc);
 212 }
 213
 214         __checkReturn           efx_rc_t
 215 efx_nvram_rw_start(
 216         __in                    efx_nic_t *enp,
 217         __in                    efx_nvram_type_t type,
 218         __out_opt               size_t *chunk_sizep)
 219 {
 220         const efx_nvram_ops_t *envop = enp->en_envop;
 221         uint32_t partn;
 222         efx_rc_t rc;
 223
 224         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 225         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 226
 227         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 228         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
 229
 230         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, EFX_NVRAM_INVALID);
 231
 232         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 233                 goto fail1;
 234
 235         if ((rc = envop->envo_partn_rw_start(enp, partn, chunk_sizep)) != 0)
 236                 goto fail2;
 237
 238         enp->en_nvram_locked = type;
 239
 240         return (0);
 241
 242 fail2:
 243         EFSYS_PROBE(fail2);
 244 fail1:
 245         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 246
 247         return (rc);
 248 }
 249
 250         __checkReturn           efx_rc_t
 251 efx_nvram_read_chunk(
 252         __in                    efx_nic_t *enp,
 253         __in                    efx_nvram_type_t type,
 254         __in                    unsigned int offset,
 255         __out_bcount(size)      caddr_t data,
 256         __in                    size_t size)
 257 {
 258         const efx_nvram_ops_t *envop = enp->en_envop;
 259         uint32_t partn;
 260         efx_rc_t rc;
 261
 262         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 263         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 264
 265         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 266         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
 267
 268         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, type);
 269
 270         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 271                 goto fail1;
 272
 273         if ((rc = envop->envo_partn_read(enp, partn, offset, data, size)) != 0)
 274                 goto fail2;
 275
 276         return (0);
 277
 278 fail2:
 279         EFSYS_PROBE(fail2);
 280 fail1:
 281         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 282
 283         return (rc);
 284 }
 285
 286         __checkReturn           efx_rc_t
 287 efx_nvram_erase(
 288         __in                    efx_nic_t *enp,
 289         __in                    efx_nvram_type_t type)
 290 {
 291         const efx_nvram_ops_t *envop = enp->en_envop;
 292         unsigned int offset = 0;
 293         size_t size = 0;
 294         uint32_t partn;
 295         efx_rc_t rc;
 296
 297         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 298         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 299
 300         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 301         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
 302
 303         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, type);
 304
 305         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 306                 goto fail1;
 307
 308         if ((rc = envop->envo_partn_size(enp, partn, &size)) != 0)
 309                 goto fail2;
 310
 311         if ((rc = envop->envo_partn_erase(enp, partn, offset, size)) != 0)
 312                 goto fail3;
 313
 314         return (0);
 315
 316 fail3:
 317         EFSYS_PROBE(fail3);
 318 fail2:
 319         EFSYS_PROBE(fail2);
 320 fail1:
 321         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 322
 323         return (rc);
 324 }
 325
 326         __checkReturn           efx_rc_t
 327 efx_nvram_write_chunk(
 328         __in                    efx_nic_t *enp,
 329         __in                    efx_nvram_type_t type,
 330         __in                    unsigned int offset,
 331         __in_bcount(size)       caddr_t data,
 332         __in                    size_t size)
 333 {
 334         const efx_nvram_ops_t *envop = enp->en_envop;
 335         uint32_t partn;
 336         efx_rc_t rc;
 337
 338         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 339         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 340
 341         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 342         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
 343
 344         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, type);
 345
 346         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 347                 goto fail1;
 348
 349         if ((rc = envop->envo_partn_write(enp, partn, offset, data, size)) != 0)
 350                 goto fail2;
 351
 352         return (0);
 353
 354 fail2:
 355         EFSYS_PROBE(fail2);
 356 fail1:
 357         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 358
 359         return (rc);
 360 }
 361
 362         __checkReturn           efx_rc_t
 363 efx_nvram_rw_finish(
 364         __in                    efx_nic_t *enp,
 365         __in                    efx_nvram_type_t type)
 366 {
 367         const efx_nvram_ops_t *envop = enp->en_envop;
 368         uint32_t partn;
 369         efx_rc_t rc;
 370
 371         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 372         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 373
 374         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 375         EFSYS_ASSERT3U(type, !=, EFX_NVRAM_INVALID);
 376
 377         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, type);
 378
 379         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 380                 goto fail1;
 381
 382         if ((rc = envop->envo_partn_rw_finish(enp, partn)) != 0)
 383                 goto fail2;
 384
 385         enp->en_nvram_locked = EFX_NVRAM_INVALID;
 386
 387         return (0);
 388
 389 fail2:
 390         EFSYS_PROBE(fail2);
 391         enp->en_nvram_locked = EFX_NVRAM_INVALID;
 392
 393 fail1:
 394         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 395
 396         return (rc);
 397 }
 398
 399         __checkReturn           efx_rc_t
 400 efx_nvram_set_version(
 401         __in                    efx_nic_t *enp,
 402         __in                    efx_nvram_type_t type,
 403         __in_ecount(4)          uint16_t version[4])
 404 {
 405         const efx_nvram_ops_t *envop = enp->en_envop;
 406         uint32_t partn;
 407         efx_rc_t rc;
 408
 409         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 410         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
 411         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 412
 413         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 414
 415         /*
 416          * The Siena implementation of envo_set_version() will attempt to
 417          * acquire the NVRAM_UPDATE lock for the DYNAMIC_CONFIG sector.
 418          * Therefore, you can't have already acquired the NVRAM_UPDATE lock.
 419          */
 420         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, EFX_NVRAM_INVALID);
 421
 422         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 423                 goto fail1;
 424
 425         if ((rc = envop->envo_partn_set_version(enp, partn, version)) != 0)
 426                 goto fail2;
 427
 428         return (0);
 429
 430 fail2:
 431         EFSYS_PROBE(fail2);
 432 fail1:
 433         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 434
 435         return (rc);
 436 }
 437
 438 /* Validate buffer contents (before writing to flash) */
 439         __checkReturn           efx_rc_t
 440 efx_nvram_validate(
 441         __in                    efx_nic_t *enp,
 442         __in                    efx_nvram_type_t type,
 443         __in_bcount(partn_size) caddr_t partn_data,
 444         __in                    size_t partn_size)
 445 {
 446         const efx_nvram_ops_t *envop = enp->en_envop;
 447         uint32_t partn;
 448         efx_rc_t rc;
 449
 450         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 451         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
 452         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 453
 454         EFSYS_ASSERT3U(type, <, EFX_NVRAM_NTYPES);
 455
 456
 457         if ((rc = envop->envo_type_to_partn(enp, type, &partn)) != 0)
 458                 goto fail1;
 459
 460         if (envop->envo_type_to_partn != NULL &&
 461             ((rc = envop->envo_buffer_validate(enp, partn,
 462             partn_data, partn_size)) != 0))
 463                 goto fail2;
 464
 465         return (0);
 466
 467 fail2:
 468         EFSYS_PROBE(fail2);
 469 fail1:
 470         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 471
 472         return (rc);
 473 }
 474
 475
 476 void
 477 efx_nvram_fini(
 478         __in            efx_nic_t *enp)
 479 {
 480         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 481         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
 482         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NVRAM);
 483
 484         EFSYS_ASSERT3U(enp->en_nvram_locked, ==, EFX_NVRAM_INVALID);
 485
 486         enp->en_envop = NULL;
 487         enp->en_mod_flags &= ~EFX_MOD_NVRAM;
 488 }
 489
 490 #endif  /* EFSYS_OPT_NVRAM */
 491
 492 #if EFSYS_OPT_NVRAM || EFSYS_OPT_VPD
 493
 494 /*
 495  * Internal MCDI request handling
 496  */
 497
 498         __checkReturn           efx_rc_t
 499 efx_mcdi_nvram_partitions(
 500         __in                    efx_nic_t *enp,
 501         __out_bcount(size)      caddr_t data,
 502         __in                    size_t size,
 503         __out                   unsigned int *npartnp)
 504 {
 505         efx_mcdi_req_t req;
 506         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_PARTITIONS_IN_LEN,
 507                 MC_CMD_NVRAM_PARTITIONS_OUT_LENMAX);
 508         unsigned int npartn;
 509         efx_rc_t rc;
 510
 511         req.emr_cmd = MC_CMD_NVRAM_PARTITIONS;
 512         req.emr_in_buf = payload;
 513         req.emr_in_length = MC_CMD_NVRAM_PARTITIONS_IN_LEN;
 514         req.emr_out_buf = payload;
 515         req.emr_out_length = MC_CMD_NVRAM_PARTITIONS_OUT_LENMAX;
 516
 517         efx_mcdi_execute(enp, &req);
 518
 519         if (req.emr_rc != 0) {
 520                 rc = req.emr_rc;
 521                 goto fail1;
 522         }
 523
 524         if (req.emr_out_length_used < MC_CMD_NVRAM_PARTITIONS_OUT_LENMIN) {
 525                 rc = EMSGSIZE;
 526                 goto fail2;
 527         }
 528         npartn = MCDI_OUT_DWORD(req, NVRAM_PARTITIONS_OUT_NUM_PARTITIONS);
 529
 530         if (req.emr_out_length_used < MC_CMD_NVRAM_PARTITIONS_OUT_LEN(npartn)) {
 531                 rc = ENOENT;
 532                 goto fail3;
 533         }
 534
 535         if (size < npartn * sizeof (uint32_t)) {
 536                 rc = ENOSPC;
 537                 goto fail3;
 538         }
 539
 540         *npartnp = npartn;
 541
 542         memcpy(data,
 543             MCDI_OUT2(req, uint32_t, NVRAM_PARTITIONS_OUT_TYPE_ID),
 544             (npartn * sizeof (uint32_t)));
 545
 546         return (0);
 547
 548 fail3:
 549         EFSYS_PROBE(fail3);
 550 fail2:
 551         EFSYS_PROBE(fail2);
 552 fail1:
 553         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 554
 555         return (rc);
 556 }
 557
 558         __checkReturn           efx_rc_t
 559 efx_mcdi_nvram_metadata(
 560         __in                    efx_nic_t *enp,
 561         __in                    uint32_t partn,
 562         __out                   uint32_t *subtypep,
 563         __out_ecount(4)         uint16_t version[4],
 564         __out_bcount_opt(size)  char *descp,
 565         __in                    size_t size)
 566 {
 567         efx_mcdi_req_t req;
 568         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_METADATA_IN_LEN,
 569                 MC_CMD_NVRAM_METADATA_OUT_LENMAX);
 570         efx_rc_t rc;
 571
 572         req.emr_cmd = MC_CMD_NVRAM_METADATA;
 573         req.emr_in_buf = payload;
 574         req.emr_in_length = MC_CMD_NVRAM_METADATA_IN_LEN;
 575         req.emr_out_buf = payload;
 576         req.emr_out_length = MC_CMD_NVRAM_METADATA_OUT_LENMAX;
 577
 578         MCDI_IN_SET_DWORD(req, NVRAM_METADATA_IN_TYPE, partn);
 579
 580         efx_mcdi_execute(enp, &req);
 581
 582         if (req.emr_rc != 0) {
 583                 rc = req.emr_rc;
 584                 goto fail1;
 585         }
 586
 587         if (req.emr_out_length_used < MC_CMD_NVRAM_METADATA_OUT_LENMIN) {
 588                 rc = EMSGSIZE;
 589                 goto fail2;
 590         }
 591
 592         if (MCDI_OUT_DWORD_FIELD(req, NVRAM_METADATA_OUT_FLAGS,
 593                 NVRAM_METADATA_OUT_SUBTYPE_VALID)) {
 594                 *subtypep = MCDI_OUT_DWORD(req, NVRAM_METADATA_OUT_SUBTYPE);
 595         } else {
 596                 *subtypep = 0;
 597         }
 598
 599         if (MCDI_OUT_DWORD_FIELD(req, NVRAM_METADATA_OUT_FLAGS,
 600                 NVRAM_METADATA_OUT_VERSION_VALID)) {
 601                 version[0] = MCDI_OUT_WORD(req, NVRAM_METADATA_OUT_VERSION_W);
 602                 version[1] = MCDI_OUT_WORD(req, NVRAM_METADATA_OUT_VERSION_X);
 603                 version[2] = MCDI_OUT_WORD(req, NVRAM_METADATA_OUT_VERSION_Y);
 604                 version[3] = MCDI_OUT_WORD(req, NVRAM_METADATA_OUT_VERSION_Z);
 605         } else {
 606                 version[0] = version[1] = version[2] = version[3] = 0;
 607         }
 608
 609         if (MCDI_OUT_DWORD_FIELD(req, NVRAM_METADATA_OUT_FLAGS,
 610                 NVRAM_METADATA_OUT_DESCRIPTION_VALID)) {
 611                 /* Return optional descrition string */
 612                 if ((descp != NULL) && (size > 0)) {
 613                         size_t desclen;
 614
 615                         descp[0] = '\0';
 616                         desclen = (req.emr_out_length_used
 617                             - MC_CMD_NVRAM_METADATA_OUT_LEN(0));
 618
 619                         EFSYS_ASSERT3U(desclen, <=,
 620                             MC_CMD_NVRAM_METADATA_OUT_DESCRIPTION_MAXNUM);
 621
 622                         if (size < desclen) {
 623                                 rc = ENOSPC;
 624                                 goto fail3;
 625                         }
 626
 627                         memcpy(descp, MCDI_OUT2(req, char,
 628                                 NVRAM_METADATA_OUT_DESCRIPTION),
 629                             desclen);
 630
 631                         /* Ensure string is NUL terminated */
 632                         descp[desclen] = '\0';
 633                 }
 634         }
 635
 636         return (0);
 637
 638 fail3:
 639         EFSYS_PROBE(fail3);
 640 fail2:
 641         EFSYS_PROBE(fail2);
 642 fail1:
 643         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 644
 645         return (rc);
 646 }
 647
 648         __checkReturn           efx_rc_t
 649 efx_mcdi_nvram_info(
 650         __in                    efx_nic_t *enp,
 651         __in                    uint32_t partn,
 652         __out_opt               size_t *sizep,
 653         __out_opt               uint32_t *addressp,
 654         __out_opt               uint32_t *erase_sizep,
 655         __out_opt               uint32_t *write_sizep)
 656 {
 657         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_INFO_IN_LEN,
 658                 MC_CMD_NVRAM_INFO_V2_OUT_LEN);
 659         efx_mcdi_req_t req;
 660         efx_rc_t rc;
 661
 662         req.emr_cmd = MC_CMD_NVRAM_INFO;
 663         req.emr_in_buf = payload;
 664         req.emr_in_length = MC_CMD_NVRAM_INFO_IN_LEN;
 665         req.emr_out_buf = payload;
 666         req.emr_out_length = MC_CMD_NVRAM_INFO_V2_OUT_LEN;
 667
 668         MCDI_IN_SET_DWORD(req, NVRAM_INFO_IN_TYPE, partn);
 669
 670         efx_mcdi_execute_quiet(enp, &req);
 671
 672         if (req.emr_rc != 0) {
 673                 rc = req.emr_rc;
 674                 goto fail1;
 675         }
 676
 677         if (req.emr_out_length_used < MC_CMD_NVRAM_INFO_OUT_LEN) {
 678                 rc = EMSGSIZE;
 679                 goto fail2;
 680         }
 681
 682         if (sizep)
 683                 *sizep = MCDI_OUT_DWORD(req, NVRAM_INFO_OUT_SIZE);
 684
 685         if (addressp)
 686                 *addressp = MCDI_OUT_DWORD(req, NVRAM_INFO_OUT_PHYSADDR);
 687
 688         if (erase_sizep)
 689                 *erase_sizep = MCDI_OUT_DWORD(req, NVRAM_INFO_OUT_ERASESIZE);
 690
 691         if (write_sizep) {
 692                 *write_sizep =
 693                         (req.emr_out_length_used <
 694                             MC_CMD_NVRAM_INFO_V2_OUT_LEN) ?
 695                         0 : MCDI_OUT_DWORD(req, NVRAM_INFO_V2_OUT_WRITESIZE);
 696         }
 697
 698         return (0);
 699
 700 fail2:
 701         EFSYS_PROBE(fail2);
 702 fail1:
 703         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 704
 705         return (rc);
 706 }
 707
 708 /*
 709  * MC_CMD_NVRAM_UPDATE_START_V2 must be used to support firmware-verified
 710  * NVRAM updates. Older firmware will ignore the flags field in the request.
 711  */
 712         __checkReturn           efx_rc_t
 713 efx_mcdi_nvram_update_start(
 714         __in                    efx_nic_t *enp,
 715         __in                    uint32_t partn)
 716 {
 717         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_UPDATE_START_V2_IN_LEN,
 718                 MC_CMD_NVRAM_UPDATE_START_OUT_LEN);
 719         efx_mcdi_req_t req;
 720         efx_rc_t rc;
 721
 722         req.emr_cmd = MC_CMD_NVRAM_UPDATE_START;
 723         req.emr_in_buf = payload;
 724         req.emr_in_length = MC_CMD_NVRAM_UPDATE_START_V2_IN_LEN;
 725         req.emr_out_buf = payload;
 726         req.emr_out_length = MC_CMD_NVRAM_UPDATE_START_OUT_LEN;
 727
 728         MCDI_IN_SET_DWORD(req, NVRAM_UPDATE_START_V2_IN_TYPE, partn);
 729
 730         MCDI_IN_POPULATE_DWORD_1(req, NVRAM_UPDATE_START_V2_IN_FLAGS,
 731             NVRAM_UPDATE_START_V2_IN_FLAG_REPORT_VERIFY_RESULT, 1);
 732
 733         efx_mcdi_execute(enp, &req);
 734
 735         if (req.emr_rc != 0) {
 736                 rc = req.emr_rc;
 737                 goto fail1;
 738         }
 739
 740         return (0);
 741
 742 fail1:
 743         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 744
 745         return (rc);
 746 }
 747
 748         __checkReturn           efx_rc_t
 749 efx_mcdi_nvram_read(
 750         __in                    efx_nic_t *enp,
 751         __in                    uint32_t partn,
 752         __in                    uint32_t offset,
 753         __out_bcount(size)      caddr_t data,
 754         __in                    size_t size,
 755         __in                    uint32_t mode)
 756 {
 757         efx_mcdi_req_t req;
 758         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_READ_IN_V2_LEN,
 759                 MC_CMD_NVRAM_READ_OUT_LENMAX);
 760         efx_rc_t rc;
 761
 762         if (size > MC_CMD_NVRAM_READ_OUT_LENMAX) {
 763                 rc = EINVAL;
 764                 goto fail1;
 765         }
 766
 767         req.emr_cmd = MC_CMD_NVRAM_READ;
 768         req.emr_in_buf = payload;
 769         req.emr_in_length = MC_CMD_NVRAM_READ_IN_V2_LEN;
 770         req.emr_out_buf = payload;
 771         req.emr_out_length = MC_CMD_NVRAM_READ_OUT_LENMAX;
 772
 773         MCDI_IN_SET_DWORD(req, NVRAM_READ_IN_V2_TYPE, partn);
 774         MCDI_IN_SET_DWORD(req, NVRAM_READ_IN_V2_OFFSET, offset);
 775         MCDI_IN_SET_DWORD(req, NVRAM_READ_IN_V2_LENGTH, size);
 776         MCDI_IN_SET_DWORD(req, NVRAM_READ_IN_V2_MODE, mode);
 777
 778         efx_mcdi_execute(enp, &req);
 779
 780         if (req.emr_rc != 0) {
 781                 rc = req.emr_rc;
 782                 goto fail1;
 783         }
 784
 785         if (req.emr_out_length_used < MC_CMD_NVRAM_READ_OUT_LEN(size)) {
 786                 rc = EMSGSIZE;
 787                 goto fail2;
 788         }
 789
 790         memcpy(data,
 791             MCDI_OUT2(req, uint8_t, NVRAM_READ_OUT_READ_BUFFER),
 792             size);
 793
 794         return (0);
 795
 796 fail2:
 797         EFSYS_PROBE(fail2);
 798 fail1:
 799         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 800
 801         return (rc);
 802 }
 803
 804         __checkReturn           efx_rc_t
 805 efx_mcdi_nvram_erase(
 806         __in                    efx_nic_t *enp,
 807         __in                    uint32_t partn,
 808         __in                    uint32_t offset,
 809         __in                    size_t size)
 810 {
 811         efx_mcdi_req_t req;
 812         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_ERASE_IN_LEN,
 813                 MC_CMD_NVRAM_ERASE_OUT_LEN);
 814         efx_rc_t rc;
 815
 816         req.emr_cmd = MC_CMD_NVRAM_ERASE;
 817         req.emr_in_buf = payload;
 818         req.emr_in_length = MC_CMD_NVRAM_ERASE_IN_LEN;
 819         req.emr_out_buf = payload;
 820         req.emr_out_length = MC_CMD_NVRAM_ERASE_OUT_LEN;
 821
 822         MCDI_IN_SET_DWORD(req, NVRAM_ERASE_IN_TYPE, partn);
 823         MCDI_IN_SET_DWORD(req, NVRAM_ERASE_IN_OFFSET, offset);
 824         MCDI_IN_SET_DWORD(req, NVRAM_ERASE_IN_LENGTH, size);
 825
 826         efx_mcdi_execute(enp, &req);
 827
 828         if (req.emr_rc != 0) {
 829                 rc = req.emr_rc;
 830                 goto fail1;
 831         }
 832
 833         return (0);
 834
 835 fail1:
 836         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 837
 838         return (rc);
 839 }
 840
 841 /*
 842  * The NVRAM_WRITE MCDI command is a V1 command and so is supported by both
 843  * Sienna and EF10 based boards.  However EF10 based boards support the use
 844  * of this command with payloads up to the maximum MCDI V2 payload length.
 845  */
 846         __checkReturn           efx_rc_t
 847 efx_mcdi_nvram_write(
 848         __in                    efx_nic_t *enp,
 849         __in                    uint32_t partn,
 850         __in                    uint32_t offset,
 851         __in_bcount(size)       caddr_t data,
 852         __in                    size_t size)
 853 {
 854         efx_mcdi_req_t req;
 855         uint8_t *payload;
 856         efx_rc_t rc;
 857         size_t max_data_size;
 858         size_t payload_len = enp->en_nic_cfg.enc_mcdi_max_payload_length;
 859
 860         max_data_size = payload_len - MC_CMD_NVRAM_WRITE_IN_LEN(0);
 861         EFSYS_ASSERT3U(payload_len, >, 0);
 862         EFSYS_ASSERT3U(max_data_size, <, payload_len);
 863
 864         if (size > max_data_size) {
 865                 rc = EINVAL;
 866                 goto fail1;
 867         }
 868
 869         EFSYS_KMEM_ALLOC(enp->en_esip, payload_len, payload);
 870         if (payload == NULL) {
 871                 rc = ENOMEM;
 872                 goto fail2;
 873         }
 874
 875         (void) memset(payload, 0, payload_len);
 876         req.emr_cmd = MC_CMD_NVRAM_WRITE;
 877         req.emr_in_buf = payload;
 878         req.emr_in_length = MC_CMD_NVRAM_WRITE_IN_LEN(size);
 879         req.emr_out_buf = payload;
 880         req.emr_out_length = MC_CMD_NVRAM_WRITE_OUT_LEN;
 881
 882         MCDI_IN_SET_DWORD(req, NVRAM_WRITE_IN_TYPE, partn);
 883         MCDI_IN_SET_DWORD(req, NVRAM_WRITE_IN_OFFSET, offset);
 884         MCDI_IN_SET_DWORD(req, NVRAM_WRITE_IN_LENGTH, size);
 885
 886         memcpy(MCDI_IN2(req, uint8_t, NVRAM_WRITE_IN_WRITE_BUFFER),
 887             data, size);
 888
 889         efx_mcdi_execute(enp, &req);
 890
 891         if (req.emr_rc != 0) {
 892                 rc = req.emr_rc;
 893                 goto fail3;
 894         }
 895
 896         EFSYS_KMEM_FREE(enp->en_esip, payload_len, payload);
 897
 898         return (0);
 899
 900 fail3:
 901         EFSYS_PROBE(fail3);
 902         EFSYS_KMEM_FREE(enp->en_esip, payload_len, payload);
 903 fail2:
 904         EFSYS_PROBE(fail2);
 905 fail1:
 906         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 907
 908         return (rc);
 909 }
 910
 911
 912 /*
 913  * MC_CMD_NVRAM_UPDATE_FINISH_V2 must be used to support firmware-verified
 914  * NVRAM updates. Older firmware will ignore the flags field in the request.
 915  */
 916         __checkReturn           efx_rc_t
 917 efx_mcdi_nvram_update_finish(
 918         __in                    efx_nic_t *enp,
 919         __in                    uint32_t partn,
 920         __in                    boolean_t reboot,
 921         __out_opt               uint32_t *resultp)
 922 {
 923         const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
 924         efx_mcdi_req_t req;
 925         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_UPDATE_FINISH_V2_IN_LEN,
 926                 MC_CMD_NVRAM_UPDATE_FINISH_V2_OUT_LEN);
 927         uint32_t result = 0; /* FIXME: use MC_CMD_NVRAM_VERIFY_RC_UNKNOWN */
 928         efx_rc_t rc;
 929
 930         req.emr_cmd = MC_CMD_NVRAM_UPDATE_FINISH;
 931         req.emr_in_buf = payload;
 932         req.emr_in_length = MC_CMD_NVRAM_UPDATE_FINISH_V2_IN_LEN;
 933         req.emr_out_buf = payload;
 934         req.emr_out_length = MC_CMD_NVRAM_UPDATE_FINISH_V2_OUT_LEN;
 935
 936         MCDI_IN_SET_DWORD(req, NVRAM_UPDATE_FINISH_V2_IN_TYPE, partn);
 937         MCDI_IN_SET_DWORD(req, NVRAM_UPDATE_FINISH_V2_IN_REBOOT, reboot);
 938
 939         MCDI_IN_POPULATE_DWORD_1(req, NVRAM_UPDATE_FINISH_V2_IN_FLAGS,
 940             NVRAM_UPDATE_FINISH_V2_IN_FLAG_REPORT_VERIFY_RESULT, 1);
 941
 942         efx_mcdi_execute(enp, &req);
 943
 944         if (req.emr_rc != 0) {
 945                 rc = req.emr_rc;
 946                 goto fail1;
 947         }
 948
 949         if (encp->enc_fw_verified_nvram_update_required == B_FALSE) {
 950                 /* Report success if verified updates are not supported. */
 951                 result = MC_CMD_NVRAM_VERIFY_RC_SUCCESS;
 952         } else {
 953                 /* Firmware-verified NVRAM updates are required */
 954                 if (req.emr_out_length_used <
 955                     MC_CMD_NVRAM_UPDATE_FINISH_V2_OUT_LEN) {
 956                         rc = EMSGSIZE;
 957                         goto fail2;
 958                 }
 959                 result =
 960                     MCDI_OUT_DWORD(req, NVRAM_UPDATE_FINISH_V2_OUT_RESULT_CODE);
 961
 962                 if (result != MC_CMD_NVRAM_VERIFY_RC_SUCCESS) {
 963                         /* Mandatory verification failed */
 964                         rc = EINVAL;
 965                         goto fail3;
 966                 }
 967         }
 968
 969         if (resultp != NULL)
 970                 *resultp = result;
 971
 972         return (0);
 973
 974 fail3:
 975         EFSYS_PROBE(fail3);
 976 fail2:
 977         EFSYS_PROBE(fail2);
 978 fail1:
 979         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 980
 981         /* Always report verification result */
 982         if (resultp != NULL)
 983                 *resultp = result;
 984
 985         return (rc);
 986 }
 987
 988 #if EFSYS_OPT_DIAG
 989
 990         __checkReturn           efx_rc_t
 991 efx_mcdi_nvram_test(
 992         __in                    efx_nic_t *enp,
 993         __in                    uint32_t partn)
 994 {
 995         efx_mcdi_req_t req;
 996         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_NVRAM_TEST_IN_LEN,
 997                 MC_CMD_NVRAM_TEST_OUT_LEN);
 998         int result;
 999         efx_rc_t rc;
1000
1001         req.emr_cmd = MC_CMD_NVRAM_TEST;
1002         req.emr_in_buf = payload;
1003         req.emr_in_length = MC_CMD_NVRAM_TEST_IN_LEN;
1004         req.emr_out_buf = payload;
1005         req.emr_out_length = MC_CMD_NVRAM_TEST_OUT_LEN;
1006
1007         MCDI_IN_SET_DWORD(req, NVRAM_TEST_IN_TYPE, partn);
1008
1009         efx_mcdi_execute(enp, &req);
1010
1011         if (req.emr_rc != 0) {
1012                 rc = req.emr_rc;
1013                 goto fail1;
1014         }
1015
1016         if (req.emr_out_length_used < MC_CMD_NVRAM_TEST_OUT_LEN) {
1017                 rc = EMSGSIZE;
1018                 goto fail2;
1019         }
1020
1021         result = MCDI_OUT_DWORD(req, NVRAM_TEST_OUT_RESULT);
1022         if (result == MC_CMD_NVRAM_TEST_FAIL) {
1023
1024                 EFSYS_PROBE1(nvram_test_failure, int, partn);
1025
1026                 rc = (EINVAL);
1027                 goto fail3;
1028         }
1029
1030         return (0);
1031
1032 fail3:
1033         EFSYS_PROBE(fail3);
1034 fail2:
1035         EFSYS_PROBE(fail2);
1036 fail1:
1037         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1038
1039         return (rc);
1040 }
1041
1042 #endif  /* EFSYS_OPT_DIAG */
1043
1044
1045 #endif /* EFSYS_OPT_NVRAM || EFSYS_OPT_VPD */