sys/dev/sfxge/common/hunt_nic.c

   1 /*-
   2  * Copyright (c) 2012-2015 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 <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include "efsys.h"
  35 #include "efx.h"
  36 #include "efx_impl.h"
  37 #include "mcdi_mon.h"
  38
  39 #if EFSYS_OPT_HUNTINGTON
  40
  41 #include "ef10_tlv_layout.h"
  42
  43 static  __checkReturn   efx_rc_t
  44 efx_mcdi_get_port_assignment(
  45         __in            efx_nic_t *enp,
  46         __out           uint32_t *portp)
  47 {
  48         efx_mcdi_req_t req;
  49         uint8_t payload[MAX(MC_CMD_GET_PORT_ASSIGNMENT_IN_LEN,
  50                             MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN)];
  51         efx_rc_t rc;
  52
  53         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
  54
  55         (void) memset(payload, 0, sizeof (payload));
  56         req.emr_cmd = MC_CMD_GET_PORT_ASSIGNMENT;
  57         req.emr_in_buf = payload;
  58         req.emr_in_length = MC_CMD_GET_PORT_ASSIGNMENT_IN_LEN;
  59         req.emr_out_buf = payload;
  60         req.emr_out_length = MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN;
  61
  62         efx_mcdi_execute(enp, &req);
  63
  64         if (req.emr_rc != 0) {
  65                 rc = req.emr_rc;
  66                 goto fail1;
  67         }
  68
  69         if (req.emr_out_length_used < MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN) {
  70                 rc = EMSGSIZE;
  71                 goto fail2;
  72         }
  73
  74         *portp = MCDI_OUT_DWORD(req, GET_PORT_ASSIGNMENT_OUT_PORT);
  75
  76         return (0);
  77
  78 fail2:
  79         EFSYS_PROBE(fail2);
  80 fail1:
  81         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  82
  83         return (rc);
  84 }
  85
  86 static  __checkReturn   efx_rc_t
  87 efx_mcdi_get_port_modes(
  88         __in            efx_nic_t *enp,
  89         __out           uint32_t *modesp)
  90 {
  91         efx_mcdi_req_t req;
  92         uint8_t payload[MAX(MC_CMD_GET_PORT_MODES_IN_LEN,
  93                             MC_CMD_GET_PORT_MODES_OUT_LEN)];
  94         efx_rc_t rc;
  95
  96         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
  97
  98         (void) memset(payload, 0, sizeof (payload));
  99         req.emr_cmd = MC_CMD_GET_PORT_MODES;
 100         req.emr_in_buf = payload;
 101         req.emr_in_length = MC_CMD_GET_PORT_MODES_IN_LEN;
 102         req.emr_out_buf = payload;
 103         req.emr_out_length = MC_CMD_GET_PORT_MODES_OUT_LEN;
 104
 105         efx_mcdi_execute(enp, &req);
 106
 107         if (req.emr_rc != 0) {
 108                 rc = req.emr_rc;
 109                 goto fail1;
 110         }
 111
 112         /* Accept pre-Medford size (8 bytes - no CurrentMode field) */
 113         if (req.emr_out_length_used <
 114             MC_CMD_GET_PORT_MODES_OUT_CURRENT_MODE_OFST) {
 115                 rc = EMSGSIZE;
 116                 goto fail2;
 117         }
 118
 119         *modesp = MCDI_OUT_DWORD(req, GET_PORT_MODES_OUT_MODES);
 120
 121         return (0);
 122
 123 fail2:
 124         EFSYS_PROBE(fail2);
 125 fail1:
 126         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 127
 128         return (rc);
 129 }
 130
 131
 132 static  __checkReturn           efx_rc_t
 133 efx_mcdi_vadaptor_alloc(
 134         __in                    efx_nic_t *enp,
 135         __in                    uint32_t port_id)
 136 {
 137         efx_mcdi_req_t req;
 138         uint8_t payload[MAX(MC_CMD_VADAPTOR_ALLOC_IN_LEN,
 139                             MC_CMD_VADAPTOR_ALLOC_OUT_LEN)];
 140         efx_rc_t rc;
 141
 142         EFSYS_ASSERT3U(enp->en_vport_id, ==, EVB_PORT_ID_NULL);
 143
 144         (void) memset(payload, 0, sizeof (payload));
 145         req.emr_cmd = MC_CMD_VADAPTOR_ALLOC;
 146         req.emr_in_buf = payload;
 147         req.emr_in_length = MC_CMD_VADAPTOR_ALLOC_IN_LEN;
 148         req.emr_out_buf = payload;
 149         req.emr_out_length = MC_CMD_VADAPTOR_ALLOC_OUT_LEN;
 150
 151         MCDI_IN_SET_DWORD(req, VADAPTOR_ALLOC_IN_UPSTREAM_PORT_ID, port_id);
 152
 153         efx_mcdi_execute(enp, &req);
 154
 155         if (req.emr_rc != 0) {
 156                 rc = req.emr_rc;
 157                 goto fail1;
 158         }
 159
 160         return (0);
 161
 162 fail1:
 163         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 164
 165         return (rc);
 166 }
 167
 168 static  __checkReturn           efx_rc_t
 169 efx_mcdi_vadaptor_free(
 170         __in                    efx_nic_t *enp,
 171         __in                    uint32_t port_id)
 172 {
 173         efx_mcdi_req_t req;
 174         uint8_t payload[MAX(MC_CMD_VADAPTOR_FREE_IN_LEN,
 175                             MC_CMD_VADAPTOR_FREE_OUT_LEN)];
 176         efx_rc_t rc;
 177
 178         (void) memset(payload, 0, sizeof (payload));
 179         req.emr_cmd = MC_CMD_VADAPTOR_FREE;
 180         req.emr_in_buf = payload;
 181         req.emr_in_length = MC_CMD_VADAPTOR_FREE_IN_LEN;
 182         req.emr_out_buf = payload;
 183         req.emr_out_length = MC_CMD_VADAPTOR_FREE_OUT_LEN;
 184
 185         MCDI_IN_SET_DWORD(req, VADAPTOR_FREE_IN_UPSTREAM_PORT_ID, port_id);
 186
 187         efx_mcdi_execute(enp, &req);
 188
 189         if (req.emr_rc != 0) {
 190                 rc = req.emr_rc;
 191                 goto fail1;
 192         }
 193
 194         return (0);
 195
 196 fail1:
 197         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 198
 199         return (rc);
 200 }
 201
 202 static  __checkReturn   efx_rc_t
 203 efx_mcdi_get_mac_address_pf(
 204         __in                    efx_nic_t *enp,
 205         __out_ecount_opt(6)     uint8_t mac_addrp[6])
 206 {
 207         efx_mcdi_req_t req;
 208         uint8_t payload[MAX(MC_CMD_GET_MAC_ADDRESSES_IN_LEN,
 209                             MC_CMD_GET_MAC_ADDRESSES_OUT_LEN)];
 210         efx_rc_t rc;
 211
 212         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
 213
 214         (void) memset(payload, 0, sizeof (payload));
 215         req.emr_cmd = MC_CMD_GET_MAC_ADDRESSES;
 216         req.emr_in_buf = payload;
 217         req.emr_in_length = MC_CMD_GET_MAC_ADDRESSES_IN_LEN;
 218         req.emr_out_buf = payload;
 219         req.emr_out_length = MC_CMD_GET_MAC_ADDRESSES_OUT_LEN;
 220
 221         efx_mcdi_execute(enp, &req);
 222
 223         if (req.emr_rc != 0) {
 224                 rc = req.emr_rc;
 225                 goto fail1;
 226         }
 227
 228         if (req.emr_out_length_used < MC_CMD_GET_MAC_ADDRESSES_OUT_LEN) {
 229                 rc = EMSGSIZE;
 230                 goto fail2;
 231         }
 232
 233         if (MCDI_OUT_DWORD(req, GET_MAC_ADDRESSES_OUT_MAC_COUNT) < 1) {
 234                 rc = ENOENT;
 235                 goto fail3;
 236         }
 237
 238         if (mac_addrp != NULL) {
 239                 uint8_t *addrp;
 240
 241                 addrp = MCDI_OUT2(req, uint8_t,
 242                     GET_MAC_ADDRESSES_OUT_MAC_ADDR_BASE);
 243
 244                 EFX_MAC_ADDR_COPY(mac_addrp, addrp);
 245         }
 246
 247         return (0);
 248
 249 fail3:
 250         EFSYS_PROBE(fail3);
 251 fail2:
 252         EFSYS_PROBE(fail2);
 253 fail1:
 254         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 255
 256         return (rc);
 257 }
 258
 259 static  __checkReturn   efx_rc_t
 260 efx_mcdi_get_mac_address_vf(
 261         __in                    efx_nic_t *enp,
 262         __out_ecount_opt(6)     uint8_t mac_addrp[6])
 263 {
 264         efx_mcdi_req_t req;
 265         uint8_t payload[MAX(MC_CMD_VPORT_GET_MAC_ADDRESSES_IN_LEN,
 266                             MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMAX)];
 267         efx_rc_t rc;
 268
 269         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
 270
 271         (void) memset(payload, 0, sizeof (payload));
 272         req.emr_cmd = MC_CMD_VPORT_GET_MAC_ADDRESSES;
 273         req.emr_in_buf = payload;
 274         req.emr_in_length = MC_CMD_VPORT_GET_MAC_ADDRESSES_IN_LEN;
 275         req.emr_out_buf = payload;
 276         req.emr_out_length = MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMAX;
 277
 278         MCDI_IN_SET_DWORD(req, VPORT_GET_MAC_ADDRESSES_IN_VPORT_ID,
 279             EVB_PORT_ID_ASSIGNED);
 280
 281         efx_mcdi_execute(enp, &req);
 282
 283         if (req.emr_rc != 0) {
 284                 rc = req.emr_rc;
 285                 goto fail1;
 286         }
 287
 288         if (req.emr_out_length_used <
 289             MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMIN) {
 290                 rc = EMSGSIZE;
 291                 goto fail2;
 292         }
 293
 294         if (MCDI_OUT_DWORD(req,
 295                 VPORT_GET_MAC_ADDRESSES_OUT_MACADDR_COUNT) < 1) {
 296                 rc = ENOENT;
 297                 goto fail3;
 298         }
 299
 300         if (mac_addrp != NULL) {
 301                 uint8_t *addrp;
 302
 303                 addrp = MCDI_OUT2(req, uint8_t,
 304                     VPORT_GET_MAC_ADDRESSES_OUT_MACADDR);
 305
 306                 EFX_MAC_ADDR_COPY(mac_addrp, addrp);
 307         }
 308
 309         return (0);
 310
 311 fail3:
 312         EFSYS_PROBE(fail3);
 313 fail2:
 314         EFSYS_PROBE(fail2);
 315 fail1:
 316         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 317
 318         return (rc);
 319 }
 320
 321 static  __checkReturn   efx_rc_t
 322 efx_mcdi_get_clock(
 323         __in            efx_nic_t *enp,
 324         __out           uint32_t *sys_freqp)
 325 {
 326         efx_mcdi_req_t req;
 327         uint8_t payload[MAX(MC_CMD_GET_CLOCK_IN_LEN,
 328                             MC_CMD_GET_CLOCK_OUT_LEN)];
 329         efx_rc_t rc;
 330
 331         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
 332
 333         (void) memset(payload, 0, sizeof (payload));
 334         req.emr_cmd = MC_CMD_GET_CLOCK;
 335         req.emr_in_buf = payload;
 336         req.emr_in_length = MC_CMD_GET_CLOCK_IN_LEN;
 337         req.emr_out_buf = payload;
 338         req.emr_out_length = MC_CMD_GET_CLOCK_OUT_LEN;
 339
 340         efx_mcdi_execute(enp, &req);
 341
 342         if (req.emr_rc != 0) {
 343                 rc = req.emr_rc;
 344                 goto fail1;
 345         }
 346
 347         if (req.emr_out_length_used < MC_CMD_GET_CLOCK_OUT_LEN) {
 348                 rc = EMSGSIZE;
 349                 goto fail2;
 350         }
 351
 352         *sys_freqp = MCDI_OUT_DWORD(req, GET_CLOCK_OUT_SYS_FREQ);
 353         if (*sys_freqp == 0) {
 354                 rc = EINVAL;
 355                 goto fail3;
 356         }
 357
 358         return (0);
 359
 360 fail3:
 361         EFSYS_PROBE(fail3);
 362 fail2:
 363         EFSYS_PROBE(fail2);
 364 fail1:
 365         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 366
 367         return (rc);
 368 }
 369
 370 static  __checkReturn   efx_rc_t
 371 efx_mcdi_get_vector_cfg(
 372         __in            efx_nic_t *enp,
 373         __out_opt       uint32_t *vec_basep,
 374         __out_opt       uint32_t *pf_nvecp,
 375         __out_opt       uint32_t *vf_nvecp)
 376 {
 377         efx_mcdi_req_t req;
 378         uint8_t payload[MAX(MC_CMD_GET_VECTOR_CFG_IN_LEN,
 379                             MC_CMD_GET_VECTOR_CFG_OUT_LEN)];
 380         efx_rc_t rc;
 381
 382         (void) memset(payload, 0, sizeof (payload));
 383         req.emr_cmd = MC_CMD_GET_VECTOR_CFG;
 384         req.emr_in_buf = payload;
 385         req.emr_in_length = MC_CMD_GET_VECTOR_CFG_IN_LEN;
 386         req.emr_out_buf = payload;
 387         req.emr_out_length = MC_CMD_GET_VECTOR_CFG_OUT_LEN;
 388
 389         efx_mcdi_execute(enp, &req);
 390
 391         if (req.emr_rc != 0) {
 392                 rc = req.emr_rc;
 393                 goto fail1;
 394         }
 395
 396         if (req.emr_out_length_used < MC_CMD_GET_VECTOR_CFG_OUT_LEN) {
 397                 rc = EMSGSIZE;
 398                 goto fail2;
 399         }
 400
 401         if (vec_basep != NULL)
 402                 *vec_basep = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VEC_BASE);
 403         if (pf_nvecp != NULL)
 404                 *pf_nvecp = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VECS_PER_PF);
 405         if (vf_nvecp != NULL)
 406                 *vf_nvecp = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VECS_PER_VF);
 407
 408         return (0);
 409
 410 fail2:
 411         EFSYS_PROBE(fail2);
 412 fail1:
 413         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 414
 415         return (rc);
 416 }
 417
 418 static  __checkReturn   efx_rc_t
 419 efx_mcdi_get_capabilities(
 420         __in            efx_nic_t *enp,
 421         __out           efx_dword_t *flagsp)
 422 {
 423         efx_mcdi_req_t req;
 424         uint8_t payload[MAX(MC_CMD_GET_CAPABILITIES_IN_LEN,
 425                             MC_CMD_GET_CAPABILITIES_OUT_LEN)];
 426         efx_rc_t rc;
 427
 428         (void) memset(payload, 0, sizeof (payload));
 429         req.emr_cmd = MC_CMD_GET_CAPABILITIES;
 430         req.emr_in_buf = payload;
 431         req.emr_in_length = MC_CMD_GET_CAPABILITIES_IN_LEN;
 432         req.emr_out_buf = payload;
 433         req.emr_out_length = MC_CMD_GET_CAPABILITIES_OUT_LEN;
 434
 435         efx_mcdi_execute(enp, &req);
 436
 437         if (req.emr_rc != 0) {
 438                 rc = req.emr_rc;
 439                 goto fail1;
 440         }
 441
 442         if (req.emr_out_length_used < MC_CMD_GET_CAPABILITIES_OUT_LEN) {
 443                 rc = EMSGSIZE;
 444                 goto fail2;
 445         }
 446
 447         *flagsp = *MCDI_OUT2(req, efx_dword_t, GET_CAPABILITIES_OUT_FLAGS1);
 448
 449         return (0);
 450
 451 fail2:
 452         EFSYS_PROBE(fail2);
 453 fail1:
 454         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 455
 456         return (rc);
 457 }
 458
 459
 460 static  __checkReturn   efx_rc_t
 461 efx_mcdi_alloc_vis(
 462         __in            efx_nic_t *enp,
 463         __in            uint32_t min_vi_count,
 464         __in            uint32_t max_vi_count,
 465         __out_opt       uint32_t *vi_basep,
 466         __out           uint32_t *vi_countp)
 467
 468 {
 469         efx_mcdi_req_t req;
 470         uint8_t payload[MAX(MC_CMD_ALLOC_VIS_IN_LEN,
 471                             MC_CMD_ALLOC_VIS_OUT_LEN)];
 472         efx_rc_t rc;
 473
 474         if (vi_countp == NULL) {
 475                 rc = EINVAL;
 476                 goto fail1;
 477         }
 478
 479         (void) memset(payload, 0, sizeof (payload));
 480         req.emr_cmd = MC_CMD_ALLOC_VIS;
 481         req.emr_in_buf = payload;
 482         req.emr_in_length = MC_CMD_ALLOC_VIS_IN_LEN;
 483         req.emr_out_buf = payload;
 484         req.emr_out_length = MC_CMD_ALLOC_VIS_OUT_LEN;
 485
 486         MCDI_IN_SET_DWORD(req, ALLOC_VIS_IN_MIN_VI_COUNT, min_vi_count);
 487         MCDI_IN_SET_DWORD(req, ALLOC_VIS_IN_MAX_VI_COUNT, max_vi_count);
 488
 489         efx_mcdi_execute(enp, &req);
 490
 491         if (req.emr_rc != 0) {
 492                 rc = req.emr_rc;
 493                 goto fail2;
 494         }
 495
 496         if (req.emr_out_length_used < MC_CMD_ALLOC_VIS_OUT_LEN) {
 497                 rc = EMSGSIZE;
 498                 goto fail3;
 499         }
 500
 501         if (vi_basep != NULL)
 502                 *vi_basep = MCDI_OUT_DWORD(req, ALLOC_VIS_OUT_VI_BASE);
 503
 504         if (vi_countp != NULL)
 505                 *vi_countp = MCDI_OUT_DWORD(req, ALLOC_VIS_OUT_VI_COUNT);
 506
 507         return (0);
 508
 509 fail3:
 510         EFSYS_PROBE(fail3);
 511 fail2:
 512         EFSYS_PROBE(fail2);
 513 fail1:
 514         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 515
 516         return (rc);
 517 }
 518
 519
 520 static  __checkReturn   efx_rc_t
 521 efx_mcdi_free_vis(
 522         __in            efx_nic_t *enp)
 523 {
 524         efx_mcdi_req_t req;
 525         efx_rc_t rc;
 526
 527         EFX_STATIC_ASSERT(MC_CMD_FREE_VIS_IN_LEN == 0);
 528         EFX_STATIC_ASSERT(MC_CMD_FREE_VIS_OUT_LEN == 0);
 529
 530         req.emr_cmd = MC_CMD_FREE_VIS;
 531         req.emr_in_buf = NULL;
 532         req.emr_in_length = 0;
 533         req.emr_out_buf = NULL;
 534         req.emr_out_length = 0;
 535
 536         efx_mcdi_execute_quiet(enp, &req);
 537
 538         /* Ignore ELREADY (no allocated VIs, so nothing to free) */
 539         if ((req.emr_rc != 0) && (req.emr_rc != EALREADY)) {
 540                 rc = req.emr_rc;
 541                 goto fail1;
 542         }
 543
 544         return (0);
 545
 546 fail1:
 547         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 548
 549         return (rc);
 550 }
 551
 552
 553 static  __checkReturn   efx_rc_t
 554 efx_mcdi_alloc_piobuf(
 555         __in            efx_nic_t *enp,
 556         __out           efx_piobuf_handle_t *handlep)
 557 {
 558         efx_mcdi_req_t req;
 559         uint8_t payload[MAX(MC_CMD_ALLOC_PIOBUF_IN_LEN,
 560                             MC_CMD_ALLOC_PIOBUF_OUT_LEN)];
 561         efx_rc_t rc;
 562
 563         if (handlep == NULL) {
 564                 rc = EINVAL;
 565                 goto fail1;
 566         }
 567
 568         (void) memset(payload, 0, sizeof (payload));
 569         req.emr_cmd = MC_CMD_ALLOC_PIOBUF;
 570         req.emr_in_buf = payload;
 571         req.emr_in_length = MC_CMD_ALLOC_PIOBUF_IN_LEN;
 572         req.emr_out_buf = payload;
 573         req.emr_out_length = MC_CMD_ALLOC_PIOBUF_OUT_LEN;
 574
 575         efx_mcdi_execute_quiet(enp, &req);
 576
 577         if (req.emr_rc != 0) {
 578                 rc = req.emr_rc;
 579                 goto fail2;
 580         }
 581
 582         if (req.emr_out_length_used < MC_CMD_ALLOC_PIOBUF_OUT_LEN) {
 583                 rc = EMSGSIZE;
 584                 goto fail3;
 585         }
 586
 587         *handlep = MCDI_OUT_DWORD(req, ALLOC_PIOBUF_OUT_PIOBUF_HANDLE);
 588
 589         return (0);
 590
 591 fail3:
 592         EFSYS_PROBE(fail3);
 593 fail2:
 594         EFSYS_PROBE(fail2);
 595 fail1:
 596         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 597
 598         return (rc);
 599 }
 600
 601 static  __checkReturn   efx_rc_t
 602 efx_mcdi_free_piobuf(
 603         __in            efx_nic_t *enp,
 604         __in            efx_piobuf_handle_t handle)
 605 {
 606         efx_mcdi_req_t req;
 607         uint8_t payload[MAX(MC_CMD_FREE_PIOBUF_IN_LEN,
 608                             MC_CMD_FREE_PIOBUF_OUT_LEN)];
 609         efx_rc_t rc;
 610
 611         (void) memset(payload, 0, sizeof (payload));
 612         req.emr_cmd = MC_CMD_FREE_PIOBUF;
 613         req.emr_in_buf = payload;
 614         req.emr_in_length = MC_CMD_FREE_PIOBUF_IN_LEN;
 615         req.emr_out_buf = payload;
 616         req.emr_out_length = MC_CMD_FREE_PIOBUF_OUT_LEN;
 617
 618         MCDI_IN_SET_DWORD(req, FREE_PIOBUF_IN_PIOBUF_HANDLE, handle);
 619
 620         efx_mcdi_execute_quiet(enp, &req);
 621
 622         if (req.emr_rc != 0) {
 623                 rc = req.emr_rc;
 624                 goto fail1;
 625         }
 626
 627         return (0);
 628
 629 fail1:
 630         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 631
 632         return (rc);
 633 }
 634
 635 static  __checkReturn   efx_rc_t
 636 efx_mcdi_link_piobuf(
 637         __in            efx_nic_t *enp,
 638         __in            uint32_t vi_index,
 639         __in            efx_piobuf_handle_t handle)
 640 {
 641         efx_mcdi_req_t req;
 642         uint8_t payload[MAX(MC_CMD_LINK_PIOBUF_IN_LEN,
 643                             MC_CMD_LINK_PIOBUF_OUT_LEN)];
 644         efx_rc_t rc;
 645
 646         (void) memset(payload, 0, sizeof (payload));
 647         req.emr_cmd = MC_CMD_LINK_PIOBUF;
 648         req.emr_in_buf = payload;
 649         req.emr_in_length = MC_CMD_LINK_PIOBUF_IN_LEN;
 650         req.emr_out_buf = payload;
 651         req.emr_out_length = MC_CMD_LINK_PIOBUF_OUT_LEN;
 652
 653         MCDI_IN_SET_DWORD(req, LINK_PIOBUF_IN_PIOBUF_HANDLE, handle);
 654         MCDI_IN_SET_DWORD(req, LINK_PIOBUF_IN_TXQ_INSTANCE, vi_index);
 655
 656         efx_mcdi_execute(enp, &req);
 657
 658         if (req.emr_rc != 0) {
 659                 rc = req.emr_rc;
 660                 goto fail1;
 661         }
 662
 663         return (0);
 664
 665 fail1:
 666         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 667
 668         return (rc);
 669 }
 670
 671 static  __checkReturn   efx_rc_t
 672 efx_mcdi_unlink_piobuf(
 673         __in            efx_nic_t *enp,
 674         __in            uint32_t vi_index)
 675 {
 676         efx_mcdi_req_t req;
 677         uint8_t payload[MAX(MC_CMD_UNLINK_PIOBUF_IN_LEN,
 678                             MC_CMD_UNLINK_PIOBUF_OUT_LEN)];
 679         efx_rc_t rc;
 680
 681         (void) memset(payload, 0, sizeof (payload));
 682         req.emr_cmd = MC_CMD_UNLINK_PIOBUF;
 683         req.emr_in_buf = payload;
 684         req.emr_in_length = MC_CMD_UNLINK_PIOBUF_IN_LEN;
 685         req.emr_out_buf = payload;
 686         req.emr_out_length = MC_CMD_UNLINK_PIOBUF_OUT_LEN;
 687
 688         MCDI_IN_SET_DWORD(req, UNLINK_PIOBUF_IN_TXQ_INSTANCE, vi_index);
 689
 690         efx_mcdi_execute(enp, &req);
 691
 692         if (req.emr_rc != 0) {
 693                 rc = req.emr_rc;
 694                 goto fail1;
 695         }
 696
 697         return (0);
 698
 699 fail1:
 700         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 701
 702         return (rc);
 703 }
 704
 705 static                  void
 706 hunt_nic_alloc_piobufs(
 707         __in            efx_nic_t *enp,
 708         __in            uint32_t max_piobuf_count)
 709 {
 710         efx_piobuf_handle_t *handlep;
 711         unsigned int i;
 712         efx_rc_t rc;
 713
 714         EFSYS_ASSERT3U(max_piobuf_count, <=,
 715             EFX_ARRAY_SIZE(enp->en_u.hunt.enu_piobuf_handle));
 716
 717         enp->en_u.hunt.enu_piobuf_count = 0;
 718
 719         for (i = 0; i < max_piobuf_count; i++) {
 720                 handlep = &enp->en_u.hunt.enu_piobuf_handle[i];
 721
 722                 if ((rc = efx_mcdi_alloc_piobuf(enp, handlep)) != 0)
 723                         goto fail1;
 724
 725                 enp->en_u.hunt.enu_pio_alloc_map[i] = 0;
 726                 enp->en_u.hunt.enu_piobuf_count++;
 727         }
 728
 729         return;
 730
 731 fail1:
 732         for (i = 0; i < enp->en_u.hunt.enu_piobuf_count; i++) {
 733                 handlep = &enp->en_u.hunt.enu_piobuf_handle[i];
 734
 735                 efx_mcdi_free_piobuf(enp, *handlep);
 736                 *handlep = EFX_PIOBUF_HANDLE_INVALID;
 737         }
 738         enp->en_u.hunt.enu_piobuf_count = 0;
 739 }
 740
 741
 742 static                  void
 743 hunt_nic_free_piobufs(
 744         __in            efx_nic_t *enp)
 745 {
 746         efx_piobuf_handle_t *handlep;
 747         unsigned int i;
 748
 749         for (i = 0; i < enp->en_u.hunt.enu_piobuf_count; i++) {
 750                 handlep = &enp->en_u.hunt.enu_piobuf_handle[i];
 751
 752                 efx_mcdi_free_piobuf(enp, *handlep);
 753                 *handlep = EFX_PIOBUF_HANDLE_INVALID;
 754         }
 755         enp->en_u.hunt.enu_piobuf_count = 0;
 756 }
 757
 758 /* Sub-allocate a block from a piobuf */
 759         __checkReturn   efx_rc_t
 760 hunt_nic_pio_alloc(
 761         __inout         efx_nic_t *enp,
 762         __out           uint32_t *bufnump,
 763         __out           efx_piobuf_handle_t *handlep,
 764         __out           uint32_t *blknump,
 765         __out           uint32_t *offsetp,
 766         __out           size_t *sizep)
 767 {
 768         efx_drv_cfg_t *edcp = &enp->en_drv_cfg;
 769         uint32_t blk_per_buf;
 770         uint32_t buf, blk;
 771         efx_rc_t rc;
 772
 773         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
 774         EFSYS_ASSERT(bufnump);
 775         EFSYS_ASSERT(handlep);
 776         EFSYS_ASSERT(blknump);
 777         EFSYS_ASSERT(offsetp);
 778         EFSYS_ASSERT(sizep);
 779
 780         if ((edcp->edc_pio_alloc_size == 0) ||
 781             (enp->en_u.hunt.enu_piobuf_count == 0)) {
 782                 rc = ENOMEM;
 783                 goto fail1;
 784         }
 785         blk_per_buf = HUNT_PIOBUF_SIZE / edcp->edc_pio_alloc_size;
 786
 787         for (buf = 0; buf < enp->en_u.hunt.enu_piobuf_count; buf++) {
 788                 uint32_t *map = &enp->en_u.hunt.enu_pio_alloc_map[buf];
 789
 790                 if (~(*map) == 0)
 791                         continue;
 792
 793                 EFSYS_ASSERT3U(blk_per_buf, <=, (8 * sizeof (*map)));
 794                 for (blk = 0; blk < blk_per_buf; blk++) {
 795                         if ((*map & (1u << blk)) == 0) {
 796                                 *map |= (1u << blk);
 797                                 goto done;
 798                         }
 799                 }
 800         }
 801         rc = ENOMEM;
 802         goto fail2;
 803
 804 done:
 805         *handlep = enp->en_u.hunt.enu_piobuf_handle[buf];
 806         *bufnump = buf;
 807         *blknump = blk;
 808         *sizep = edcp->edc_pio_alloc_size;
 809         *offsetp = blk * (*sizep);
 810
 811         return (0);
 812
 813 fail2:
 814         EFSYS_PROBE(fail2);
 815 fail1:
 816         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 817
 818         return (rc);
 819 }
 820
 821 /* Free a piobuf sub-allocated block */
 822         __checkReturn   efx_rc_t
 823 hunt_nic_pio_free(
 824         __inout         efx_nic_t *enp,
 825         __in            uint32_t bufnum,
 826         __in            uint32_t blknum)
 827 {
 828         uint32_t *map;
 829         efx_rc_t rc;
 830
 831         if ((bufnum >= enp->en_u.hunt.enu_piobuf_count) ||
 832             (blknum >= (8 * sizeof (*map)))) {
 833                 rc = EINVAL;
 834                 goto fail1;
 835         }
 836
 837         map = &enp->en_u.hunt.enu_pio_alloc_map[bufnum];
 838         if ((*map & (1u << blknum)) == 0) {
 839                 rc = ENOENT;
 840                 goto fail2;
 841         }
 842         *map &= ~(1u << blknum);
 843
 844         return (0);
 845
 846 fail2:
 847         EFSYS_PROBE(fail2);
 848 fail1:
 849         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 850
 851         return (rc);
 852 }
 853
 854         __checkReturn   efx_rc_t
 855 hunt_nic_pio_link(
 856         __inout         efx_nic_t *enp,
 857         __in            uint32_t vi_index,
 858         __in            efx_piobuf_handle_t handle)
 859 {
 860         return (efx_mcdi_link_piobuf(enp, vi_index, handle));
 861 }
 862
 863         __checkReturn   efx_rc_t
 864 hunt_nic_pio_unlink(
 865         __inout         efx_nic_t *enp,
 866         __in            uint32_t vi_index)
 867 {
 868         return (efx_mcdi_unlink_piobuf(enp, vi_index));
 869 }
 870
 871 static  __checkReturn   efx_rc_t
 872 hunt_get_datapath_caps(
 873         __in            efx_nic_t *enp)
 874 {
 875         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 876         efx_dword_t datapath_capabilities;
 877         efx_rc_t rc;
 878
 879         if ((rc = efx_mcdi_get_capabilities(enp, &datapath_capabilities)) != 0)
 880                 goto fail1;
 881
 882         /*
 883          * Huntington RXDP firmware inserts a 0 or 14 byte prefix.
 884          * We only support the 14 byte prefix here.
 885          */
 886         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 887                 GET_CAPABILITIES_OUT_RX_PREFIX_LEN_14) != 1) {
 888                 rc = ENOTSUP;
 889                 goto fail2;
 890         }
 891         encp->enc_rx_prefix_size = 14;
 892
 893         /* Check if the firmware supports TSO */
 894         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 895                                 GET_CAPABILITIES_OUT_TX_TSO) == 1)
 896                 encp->enc_fw_assisted_tso_enabled = B_TRUE;
 897         else
 898                 encp->enc_fw_assisted_tso_enabled = B_FALSE;
 899
 900         /* Check if the firmware has vadapter/vport/vswitch support */
 901         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 902                                 GET_CAPABILITIES_OUT_EVB) == 1)
 903                 encp->enc_datapath_cap_evb = B_TRUE;
 904         else
 905                 encp->enc_datapath_cap_evb = B_FALSE;
 906
 907         /* Check if the firmware supports VLAN insertion */
 908         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 909                                 GET_CAPABILITIES_OUT_TX_VLAN_INSERTION) == 1)
 910                 encp->enc_hw_tx_insert_vlan_enabled = B_TRUE;
 911         else
 912                 encp->enc_hw_tx_insert_vlan_enabled = B_FALSE;
 913
 914         /* Check if the firmware supports RX event batching */
 915         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 916                 GET_CAPABILITIES_OUT_RX_BATCHING) == 1) {
 917                 encp->enc_rx_batching_enabled = B_TRUE;
 918                 encp->enc_rx_batch_max = 16;
 919         } else {
 920                 encp->enc_rx_batching_enabled = B_FALSE;
 921         }
 922
 923         /* Check if the firmware supports disabling scatter on RXQs */
 924         if (MCDI_CMD_DWORD_FIELD(&datapath_capabilities,
 925                             GET_CAPABILITIES_OUT_RX_DISABLE_SCATTER) == 1) {
 926                 encp->enc_rx_disable_scatter_supported = B_TRUE;
 927         } else {
 928                 encp->enc_rx_disable_scatter_supported = B_FALSE;
 929         }
 930
 931         return (0);
 932
 933 fail2:
 934         EFSYS_PROBE(fail2);
 935 fail1:
 936         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 937
 938         return (rc);
 939 }
 940
 941 /*
 942  * The external port mapping is a one-based numbering of the external
 943  * connectors on the board. It does not distinguish off-board separated
 944  * outputs such as multi-headed cables.
 945  * The number of ports that map to each external port connector
 946  * on the board is determined by the chip family and the port modes to
 947  * which the NIC can be configured. The mapping table lists modes with
 948  * port numbering requirements in increasing order.
 949  */
 950 static struct {
 951         efx_family_t    family;
 952         uint32_t        modes_mask;
 953         uint32_t        stride;
 954 }       __hunt_external_port_mappings[] = {
 955         /* Supported modes requiring 1 output per port */
 956         {
 957                 EFX_FAMILY_HUNTINGTON,
 958                 (1 << TLV_PORT_MODE_10G) |
 959                 (1 << TLV_PORT_MODE_10G_10G) |
 960                 (1 << TLV_PORT_MODE_10G_10G_10G_10G),
 961                 1
 962         },
 963         /* Supported modes requiring 2 outputs per port */
 964         {
 965                 EFX_FAMILY_HUNTINGTON,
 966                 (1 << TLV_PORT_MODE_40G) |
 967                 (1 << TLV_PORT_MODE_40G_40G) |
 968                 (1 << TLV_PORT_MODE_40G_10G_10G) |
 969                 (1 << TLV_PORT_MODE_10G_10G_40G),
 970                 2
 971         }
 972         /*
 973          * NOTE: Medford modes will require 4 outputs per port:
 974          *      TLV_PORT_MODE_10G_10G_10G_10G_Q
 975          *      TLV_PORT_MODE_10G_10G_10G_10G_Q2
 976          * The Q2 mode routes outputs to external port 2. Support for this
 977          * will require a new field specifying the number to add after
 978          * scaling by stride. This is fixed at 1 currently.
 979          */
 980 };
 981
 982 static  __checkReturn   efx_rc_t
 983 hunt_external_port_mapping(
 984         __in            efx_nic_t *enp,
 985         __in            uint32_t port,
 986         __out           uint8_t *external_portp)
 987 {
 988         efx_rc_t rc;
 989         int i;
 990         uint32_t port_modes;
 991         uint32_t matches;
 992         uint32_t stride = 1; /* default 1-1 mapping */
 993
 994         if ((rc = efx_mcdi_get_port_modes(enp, &port_modes)) != 0) {
 995                 /* No port mode information available - use default mapping */
 996                 goto out;
 997         }
 998
 999         /*
1000          * Infer the internal port -> external port mapping from
1001          * the possible port modes for this NIC.
1002          */
1003         for (i = 0; i < EFX_ARRAY_SIZE(__hunt_external_port_mappings); ++i) {
1004                 if (__hunt_external_port_mappings[i].family !=
1005                     enp->en_family)
1006                         continue;
1007                 matches = (__hunt_external_port_mappings[i].modes_mask &
1008                     port_modes);
1009                 if (matches != 0) {
1010                         stride = __hunt_external_port_mappings[i].stride;
1011                         port_modes &= ~matches;
1012                 }
1013         }
1014
1015         if (port_modes != 0) {
1016                 /* Some advertised modes are not supported */
1017                 rc = ENOTSUP;
1018                 goto fail1;
1019         }
1020
1021 out:
1022         /*
1023          * Scale as required by last matched mode and then convert to
1024          * one-based numbering
1025          */
1026         *external_portp = (uint8_t)(port / stride) + 1;
1027         return (0);
1028
1029 fail1:
1030         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1031
1032         return (rc);
1033 }
1034
1035 static  __checkReturn   efx_rc_t
1036 hunt_board_cfg(
1037         __in            efx_nic_t *enp)
1038 {
1039         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
1040         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1041         uint8_t mac_addr[6];
1042         uint32_t board_type = 0;
1043         hunt_link_state_t hls;
1044         efx_port_t *epp = &(enp->en_port);
1045         uint32_t port;
1046         uint32_t pf;
1047         uint32_t vf;
1048         uint32_t mask;
1049         uint32_t flags;
1050         uint32_t sysclk;
1051         uint32_t base, nvec;
1052         efx_rc_t rc;
1053
1054         if ((rc = efx_mcdi_get_port_assignment(enp, &port)) != 0)
1055                 goto fail1;
1056
1057         /*
1058          * NOTE: The MCDI protocol numbers ports from zero.
1059          * The common code MCDI interface numbers ports from one.
1060          */
1061         emip->emi_port = port + 1;
1062
1063         if ((rc = hunt_external_port_mapping(enp, port,
1064                     &encp->enc_external_port)) != 0)
1065                 goto fail2;
1066
1067         /*
1068          * Get PCIe function number from firmware (used for
1069          * per-function privilege and dynamic config info).
1070          *  - PCIe PF: pf = PF number, vf = 0xffff.
1071          *  - PCIe VF: pf = parent PF, vf = VF number.
1072          */
1073         if ((rc = efx_mcdi_get_function_info(enp, &pf, &vf)) != 0)
1074                 goto fail3;
1075
1076         encp->enc_pf = pf;
1077         encp->enc_vf = vf;
1078
1079         /* MAC address for this function */
1080         if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1081                 rc = efx_mcdi_get_mac_address_pf(enp, mac_addr);
1082                 if ((rc == 0) && (mac_addr[0] & 0x02)) {
1083                         /*
1084                          * If the static config does not include a global MAC
1085                          * address pool then the board may return a locally
1086                          * administered MAC address (this should only happen on
1087                          * incorrectly programmed boards).
1088                          */
1089                         rc = EINVAL;
1090                 }
1091         } else {
1092                 rc = efx_mcdi_get_mac_address_vf(enp, mac_addr);
1093         }
1094         if (rc != 0)
1095                 goto fail4;
1096
1097         EFX_MAC_ADDR_COPY(encp->enc_mac_addr, mac_addr);
1098
1099         /* Board configuration */
1100         rc = efx_mcdi_get_board_cfg(enp, &board_type, NULL, NULL);
1101         if (rc != 0) {
1102                 /* Unprivileged functions may not be able to read board cfg */
1103                 if (rc == EACCES)
1104                         board_type = 0;
1105                 else
1106                         goto fail5;
1107         }
1108
1109         encp->enc_board_type = board_type;
1110         encp->enc_clk_mult = 1; /* not used for Huntington */
1111
1112         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
1113         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
1114                 goto fail6;
1115
1116         /* Obtain the default PHY advertised capabilities */
1117         if ((rc = hunt_phy_get_link(enp, &hls)) != 0)
1118                 goto fail7;
1119         epp->ep_default_adv_cap_mask = hls.hls_adv_cap_mask;
1120         epp->ep_adv_cap_mask = hls.hls_adv_cap_mask;
1121
1122         /*
1123          * Enable firmware workarounds for hardware errata.
1124          * Expected responses are:
1125          *  - 0 (zero):
1126          *      Success: workaround enabled or disabled as requested.
1127          *  - MC_CMD_ERR_ENOSYS (reported as ENOTSUP):
1128          *      Firmware does not support the MC_CMD_WORKAROUND request.
1129          *      (assume that the workaround is not supported).
1130          *  - MC_CMD_ERR_ENOENT (reported as ENOENT):
1131          *      Firmware does not support the requested workaround.
1132          *  - MC_CMD_ERR_EPERM  (reported as EACCES):
1133          *      Unprivileged function cannot enable/disable workarounds.
1134          *
1135          * See efx_mcdi_request_errcode() for MCDI error translations.
1136          */
1137
1138         /*
1139          * If the bug35388 workaround is enabled, then use an indirect access
1140          * method to avoid unsafe EVQ writes.
1141          */
1142         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG35388, B_TRUE,
1143             NULL);
1144         if ((rc == 0) || (rc == EACCES))
1145                 encp->enc_bug35388_workaround = B_TRUE;
1146         else if ((rc == ENOTSUP) || (rc == ENOENT))
1147                 encp->enc_bug35388_workaround = B_FALSE;
1148         else
1149                 goto fail8;
1150
1151         /*
1152          * If the bug41750 workaround is enabled, then do not test interrupts,
1153          * as the test will fail (seen with Greenport controllers).
1154          */
1155         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG41750, B_TRUE,
1156             NULL);
1157         if (rc == 0) {
1158                 encp->enc_bug41750_workaround = B_TRUE;
1159         } else if (rc == EACCES) {
1160                 /* Assume a controller with 40G ports needs the workaround. */
1161                 if (epp->ep_default_adv_cap_mask & EFX_PHY_CAP_40000FDX)
1162                         encp->enc_bug41750_workaround = B_TRUE;
1163                 else
1164                         encp->enc_bug41750_workaround = B_FALSE;
1165         } else if ((rc == ENOTSUP) || (rc == ENOENT)) {
1166                 encp->enc_bug41750_workaround = B_FALSE;
1167         } else {
1168                 goto fail9;
1169         }
1170         if (EFX_PCI_FUNCTION_IS_VF(encp)) {
1171                 /* Interrupt testing does not work for VFs. See bug50084. */
1172                 encp->enc_bug41750_workaround = B_TRUE;
1173         }
1174
1175         /*
1176          * If the bug26807 workaround is enabled, then firmware has enabled
1177          * support for chained multicast filters. Firmware will reset (FLR)
1178          * functions which have filters in the hardware filter table when the
1179          * workaround is enabled/disabled.
1180          *
1181          * We must recheck if the workaround is enabled after inserting the
1182          * first hardware filter, in case it has been changed since this check.
1183          */
1184         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG26807,
1185             B_TRUE, &flags);
1186         if (rc == 0) {
1187                 encp->enc_bug26807_workaround = B_TRUE;
1188                 if (flags & (1 << MC_CMD_WORKAROUND_EXT_OUT_FLR_DONE_LBN)) {
1189                         /*
1190                          * Other functions had installed filters before the
1191                          * workaround was enabled, and they have been reset
1192                          * by firmware.
1193                          */
1194                         EFSYS_PROBE(bug26807_workaround_flr_done);
1195                         /* FIXME: bump MC warm boot count ? */
1196                 }
1197         } else if (rc == EACCES) {
1198                 /*
1199                  * Unprivileged functions cannot enable the workaround in older
1200                  * firmware.
1201                  */
1202                 encp->enc_bug26807_workaround = B_FALSE;
1203         } else if ((rc == ENOTSUP) || (rc == ENOENT)) {
1204                 encp->enc_bug26807_workaround = B_FALSE;
1205         } else {
1206                 goto fail10;
1207         }
1208
1209         /* Get sysclk frequency (in MHz). */
1210         if ((rc = efx_mcdi_get_clock(enp, &sysclk)) != 0)
1211                 goto fail11;
1212
1213         /*
1214          * The timer quantum is 1536 sysclk cycles, documented for the
1215          * EV_TMR_VAL field of EV_TIMER_TBL. Scale for MHz and ns units.
1216          */
1217         encp->enc_evq_timer_quantum_ns = 1536000UL / sysclk; /* 1536 cycles */
1218         if (encp->enc_bug35388_workaround) {
1219                 encp->enc_evq_timer_max_us = (encp->enc_evq_timer_quantum_ns <<
1220                 ERF_DD_EVQ_IND_TIMER_VAL_WIDTH) / 1000;
1221         } else {
1222                 encp->enc_evq_timer_max_us = (encp->enc_evq_timer_quantum_ns <<
1223                 FRF_CZ_TC_TIMER_VAL_WIDTH) / 1000;
1224         }
1225
1226         /* Check capabilities of running datapath firmware */
1227         if ((rc = hunt_get_datapath_caps(enp)) != 0)
1228             goto fail12;
1229
1230         /* Alignment for receive packet DMA buffers */
1231         encp->enc_rx_buf_align_start = 1;
1232         encp->enc_rx_buf_align_end = 64; /* RX DMA end padding */
1233
1234         /* Alignment for WPTR updates */
1235         encp->enc_rx_push_align = HUNTINGTON_RX_WPTR_ALIGN;
1236
1237         /*
1238          * Set resource limits for MC_CMD_ALLOC_VIS. Note that we cannot use
1239          * MC_CMD_GET_RESOURCE_LIMITS here as that reports the available
1240          * resources (allocated to this PCIe function), which is zero until
1241          * after we have allocated VIs.
1242          */
1243         encp->enc_evq_limit = 1024;
1244         encp->enc_rxq_limit = EFX_RXQ_LIMIT_TARGET;
1245         encp->enc_txq_limit = EFX_TXQ_LIMIT_TARGET;
1246
1247         encp->enc_buftbl_limit = 0xFFFFFFFF;
1248
1249         encp->enc_piobuf_limit = HUNT_PIOBUF_NBUFS;
1250         encp->enc_piobuf_size = HUNT_PIOBUF_SIZE;
1251
1252         /*
1253          * Get the current privilege mask. Note that this may be modified
1254          * dynamically, so this value is informational only. DO NOT use
1255          * the privilege mask to check for sufficient privileges, as that
1256          * can result in time-of-check/time-of-use bugs.
1257          */
1258         if ((rc = efx_mcdi_privilege_mask(enp, pf, vf, &mask)) != 0) {
1259                 if (rc != ENOTSUP)
1260                         goto fail13;
1261
1262                 /* Fallback for old firmware without privilege mask support */
1263                 if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1264                         /* Assume PF has admin privilege */
1265                         mask = HUNT_LEGACY_PF_PRIVILEGE_MASK;
1266                 } else {
1267                         /* VF is always unprivileged by default */
1268                         mask = HUNT_LEGACY_VF_PRIVILEGE_MASK;
1269                 }
1270         }
1271
1272         encp->enc_privilege_mask = mask;
1273
1274         /* Get interrupt vector limits */
1275         if ((rc = efx_mcdi_get_vector_cfg(enp, &base, &nvec, NULL)) != 0) {
1276                 if (EFX_PCI_FUNCTION_IS_PF(encp))
1277                         goto fail14;
1278
1279                 /* Ignore error (cannot query vector limits from a VF). */
1280                 base = 0;
1281                 nvec = 1024;
1282         }
1283         encp->enc_intr_vec_base = base;
1284         encp->enc_intr_limit = nvec;
1285
1286         /*
1287          * Maximum number of bytes into the frame the TCP header can start for
1288          * firmware assisted TSO to work.
1289          */
1290         encp->enc_tx_tso_tcp_header_offset_limit = 208;
1291
1292         return (0);
1293
1294 fail14:
1295         EFSYS_PROBE(fail14);
1296 fail13:
1297         EFSYS_PROBE(fail13);
1298 fail12:
1299         EFSYS_PROBE(fail12);
1300 fail11:
1301         EFSYS_PROBE(fail11);
1302 fail10:
1303         EFSYS_PROBE(fail10);
1304 fail9:
1305         EFSYS_PROBE(fail9);
1306 fail8:
1307         EFSYS_PROBE(fail8);
1308 fail7:
1309         EFSYS_PROBE(fail7);
1310 fail6:
1311         EFSYS_PROBE(fail6);
1312 fail5:
1313         EFSYS_PROBE(fail5);
1314 fail4:
1315         EFSYS_PROBE(fail4);
1316 fail3:
1317         EFSYS_PROBE(fail3);
1318 fail2:
1319         EFSYS_PROBE(fail2);
1320 fail1:
1321         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1322
1323         return (rc);
1324 }
1325
1326
1327         __checkReturn   efx_rc_t
1328 hunt_nic_probe(
1329         __in            efx_nic_t *enp)
1330 {
1331         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1332         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1333         efx_rc_t rc;
1334
1335         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
1336
1337         /* Read and clear any assertion state */
1338         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
1339                 goto fail1;
1340
1341         /* Exit the assertion handler */
1342         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
1343                 if (rc != EACCES)
1344                         goto fail2;
1345
1346         if ((rc = efx_mcdi_drv_attach(enp, B_TRUE)) != 0)
1347                 goto fail3;
1348
1349         if ((rc = hunt_board_cfg(enp)) != 0)
1350                 if (rc != EACCES)
1351                         goto fail4;
1352
1353         /*
1354          * Set default driver config limits (based on board config).
1355          *
1356          * FIXME: For now allocate a fixed number of VIs which is likely to be
1357          * sufficient and small enough to allow multiple functions on the same
1358          * port.
1359          */
1360         edcp->edc_min_vi_count = edcp->edc_max_vi_count =
1361             MIN(128, MAX(encp->enc_rxq_limit, encp->enc_txq_limit));
1362
1363         /* The client driver must configure and enable PIO buffer support */
1364         edcp->edc_max_piobuf_count = 0;
1365         edcp->edc_pio_alloc_size = 0;
1366
1367 #if EFSYS_OPT_MAC_STATS
1368         /* Wipe the MAC statistics */
1369         if ((rc = efx_mcdi_mac_stats_clear(enp)) != 0)
1370                 goto fail5;
1371 #endif
1372
1373 #if EFSYS_OPT_LOOPBACK
1374         if ((rc = efx_mcdi_get_loopback_modes(enp)) != 0)
1375                 goto fail6;
1376 #endif
1377
1378 #if EFSYS_OPT_MON_STATS
1379         if ((rc = mcdi_mon_cfg_build(enp)) != 0) {
1380                 /* Unprivileged functions do not have access to sensors */
1381                 if (rc != EACCES)
1382                         goto fail7;
1383         }
1384 #endif
1385
1386         encp->enc_features = enp->en_features;
1387
1388         return (0);
1389
1390 #if EFSYS_OPT_MON_STATS
1391 fail7:
1392         EFSYS_PROBE(fail7);
1393 #endif
1394 #if EFSYS_OPT_LOOPBACK
1395 fail6:
1396         EFSYS_PROBE(fail6);
1397 #endif
1398 #if EFSYS_OPT_MAC_STATS
1399 fail5:
1400         EFSYS_PROBE(fail5);
1401 #endif
1402 fail4:
1403         EFSYS_PROBE(fail4);
1404 fail3:
1405         EFSYS_PROBE(fail3);
1406 fail2:
1407         EFSYS_PROBE(fail2);
1408 fail1:
1409         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1410
1411         return (rc);
1412 }
1413
1414         __checkReturn   efx_rc_t
1415 hunt_nic_set_drv_limits(
1416         __inout         efx_nic_t *enp,
1417         __in            efx_drv_limits_t *edlp)
1418 {
1419         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1420         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1421         uint32_t min_evq_count, max_evq_count;
1422         uint32_t min_rxq_count, max_rxq_count;
1423         uint32_t min_txq_count, max_txq_count;
1424         efx_rc_t rc;
1425
1426         if (edlp == NULL) {
1427                 rc = EINVAL;
1428                 goto fail1;
1429         }
1430
1431         /* Get minimum required and maximum usable VI limits */
1432         min_evq_count = MIN(edlp->edl_min_evq_count, encp->enc_evq_limit);
1433         min_rxq_count = MIN(edlp->edl_min_rxq_count, encp->enc_rxq_limit);
1434         min_txq_count = MIN(edlp->edl_min_txq_count, encp->enc_txq_limit);
1435
1436         edcp->edc_min_vi_count =
1437             MAX(min_evq_count, MAX(min_rxq_count, min_txq_count));
1438
1439         max_evq_count = MIN(edlp->edl_max_evq_count, encp->enc_evq_limit);
1440         max_rxq_count = MIN(edlp->edl_max_rxq_count, encp->enc_rxq_limit);
1441         max_txq_count = MIN(edlp->edl_max_txq_count, encp->enc_txq_limit);
1442
1443         edcp->edc_max_vi_count =
1444             MAX(max_evq_count, MAX(max_rxq_count, max_txq_count));
1445
1446         /*
1447          * Check limits for sub-allocated piobuf blocks.
1448          * PIO is optional, so don't fail if the limits are incorrect.
1449          */
1450         if ((encp->enc_piobuf_size == 0) ||
1451             (encp->enc_piobuf_limit == 0) ||
1452             (edlp->edl_min_pio_alloc_size == 0) ||
1453             (edlp->edl_min_pio_alloc_size > encp->enc_piobuf_size)) {
1454                 /* Disable PIO */
1455                 edcp->edc_max_piobuf_count = 0;
1456                 edcp->edc_pio_alloc_size = 0;
1457         } else {
1458                 uint32_t blk_size, blk_count, blks_per_piobuf;
1459
1460                 blk_size =
1461                     MAX(edlp->edl_min_pio_alloc_size, HUNT_MIN_PIO_ALLOC_SIZE);
1462
1463                 blks_per_piobuf = encp->enc_piobuf_size / blk_size;
1464                 EFSYS_ASSERT3U(blks_per_piobuf, <=, 32);
1465
1466                 blk_count = (encp->enc_piobuf_limit * blks_per_piobuf);
1467
1468                 /* A zero max pio alloc count means unlimited */
1469                 if ((edlp->edl_max_pio_alloc_count > 0) &&
1470                     (edlp->edl_max_pio_alloc_count < blk_count)) {
1471                         blk_count = edlp->edl_max_pio_alloc_count;
1472                 }
1473
1474                 edcp->edc_pio_alloc_size = blk_size;
1475                 edcp->edc_max_piobuf_count =
1476                     (blk_count + (blks_per_piobuf - 1)) / blks_per_piobuf;
1477         }
1478
1479         return (0);
1480
1481 fail1:
1482         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1483
1484         return (rc);
1485 }
1486
1487
1488         __checkReturn   efx_rc_t
1489 hunt_nic_reset(
1490         __in            efx_nic_t *enp)
1491 {
1492         efx_mcdi_req_t req;
1493         uint8_t payload[MAX(MC_CMD_ENTITY_RESET_IN_LEN,
1494                             MC_CMD_ENTITY_RESET_OUT_LEN)];
1495         efx_rc_t rc;
1496
1497         /* hunt_nic_reset() is called to recover from BADASSERT failures. */
1498         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
1499                 goto fail1;
1500         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
1501                 goto fail2;
1502
1503         (void) memset(payload, 0, sizeof (payload));
1504         req.emr_cmd = MC_CMD_ENTITY_RESET;
1505         req.emr_in_buf = payload;
1506         req.emr_in_length = MC_CMD_ENTITY_RESET_IN_LEN;
1507         req.emr_out_buf = payload;
1508         req.emr_out_length = MC_CMD_ENTITY_RESET_OUT_LEN;
1509
1510         MCDI_IN_POPULATE_DWORD_1(req, ENTITY_RESET_IN_FLAG,
1511             ENTITY_RESET_IN_FUNCTION_RESOURCE_RESET, 1);
1512
1513         efx_mcdi_execute(enp, &req);
1514
1515         if (req.emr_rc != 0) {
1516                 rc = req.emr_rc;
1517                 goto fail3;
1518         }
1519
1520         /* Clear RX/TX DMA queue errors */
1521         enp->en_reset_flags &= ~(EFX_RESET_RXQ_ERR | EFX_RESET_TXQ_ERR);
1522
1523         return (0);
1524
1525 fail3:
1526         EFSYS_PROBE(fail3);
1527 fail2:
1528         EFSYS_PROBE(fail2);
1529 fail1:
1530         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1531
1532         return (rc);
1533 }
1534
1535         __checkReturn   efx_rc_t
1536 hunt_nic_init(
1537         __in            efx_nic_t *enp)
1538 {
1539         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1540         uint32_t min_vi_count, max_vi_count;
1541         uint32_t vi_count, vi_base;
1542         uint32_t i;
1543         uint32_t retry;
1544         uint32_t delay_us;
1545         efx_rc_t rc;
1546
1547         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
1548
1549         /* Enable reporting of some events (e.g. link change) */
1550         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
1551                 goto fail1;
1552
1553         /* Allocate (optional) on-chip PIO buffers */
1554         hunt_nic_alloc_piobufs(enp, edcp->edc_max_piobuf_count);
1555
1556         /*
1557          * For best performance, PIO writes should use a write-combined
1558          * (WC) memory mapping. Using a separate WC mapping for the PIO
1559          * aperture of each VI would be a burden to drivers (and not
1560          * possible if the host page size is >4Kbyte).
1561          *
1562          * To avoid this we use a single uncached (UC) mapping for VI
1563          * register access, and a single WC mapping for extra VIs used
1564          * for PIO writes.
1565          *
1566          * Each piobuf must be linked to a VI in the WC mapping, and to
1567          * each VI that is using a sub-allocated block from the piobuf.
1568          */
1569         min_vi_count = edcp->edc_min_vi_count;
1570         max_vi_count = edcp->edc_max_vi_count + enp->en_u.hunt.enu_piobuf_count;
1571
1572         /* Ensure that the previously attached driver's VIs are freed */
1573         if ((rc = efx_mcdi_free_vis(enp)) != 0)
1574                 goto fail2;
1575
1576         /*
1577          * Reserve VI resources (EVQ+RXQ+TXQ) for this PCIe function. If this
1578          * fails then retrying the request for fewer VI resources may succeed.
1579          */
1580         vi_count = 0;
1581         if ((rc = efx_mcdi_alloc_vis(enp, min_vi_count, max_vi_count,
1582                     &vi_base, &vi_count)) != 0)
1583                 goto fail3;
1584
1585         EFSYS_PROBE2(vi_alloc, uint32_t, vi_base, uint32_t, vi_count);
1586
1587         if (vi_count < min_vi_count) {
1588                 rc = ENOMEM;
1589                 goto fail4;
1590         }
1591
1592         enp->en_u.hunt.enu_vi_base = vi_base;
1593         enp->en_u.hunt.enu_vi_count = vi_count;
1594
1595         if (vi_count < min_vi_count + enp->en_u.hunt.enu_piobuf_count) {
1596                 /* Not enough extra VIs to map piobufs */
1597                 hunt_nic_free_piobufs(enp);
1598         }
1599
1600         enp->en_u.hunt.enu_pio_write_vi_base =
1601             vi_count - enp->en_u.hunt.enu_piobuf_count;
1602
1603         /* Save UC memory mapping details */
1604         enp->en_u.hunt.enu_uc_mem_map_offset = 0;
1605         if (enp->en_u.hunt.enu_piobuf_count > 0) {
1606                 enp->en_u.hunt.enu_uc_mem_map_size =
1607                     (ER_DZ_TX_PIOBUF_STEP *
1608                     enp->en_u.hunt.enu_pio_write_vi_base);
1609         } else {
1610                 enp->en_u.hunt.enu_uc_mem_map_size =
1611                     (ER_DZ_TX_PIOBUF_STEP *
1612                     enp->en_u.hunt.enu_vi_count);
1613         }
1614
1615         /* Save WC memory mapping details */
1616         enp->en_u.hunt.enu_wc_mem_map_offset =
1617             enp->en_u.hunt.enu_uc_mem_map_offset +
1618             enp->en_u.hunt.enu_uc_mem_map_size;
1619
1620         enp->en_u.hunt.enu_wc_mem_map_size =
1621             (ER_DZ_TX_PIOBUF_STEP *
1622             enp->en_u.hunt.enu_piobuf_count);
1623
1624         /* Link piobufs to extra VIs in WC mapping */
1625         if (enp->en_u.hunt.enu_piobuf_count > 0) {
1626                 for (i = 0; i < enp->en_u.hunt.enu_piobuf_count; i++) {
1627                         rc = efx_mcdi_link_piobuf(enp,
1628                             enp->en_u.hunt.enu_pio_write_vi_base + i,
1629                             enp->en_u.hunt.enu_piobuf_handle[i]);
1630                         if (rc != 0)
1631                                 break;
1632                 }
1633         }
1634
1635         /*
1636          * Allocate a vAdaptor attached to our upstream vPort/pPort.
1637          *
1638          * On a VF, this may fail with MC_CMD_ERR_NO_EVB_PORT (ENOENT) if the PF
1639          * driver has yet to bring up the EVB port. See bug 56147. In this case,
1640          * retry the request several times after waiting a while. The wait time
1641          * between retries starts small (10ms) and exponentially increases.
1642          * Total wait time is a little over two seconds. Retry logic in the
1643          * client driver may mean this whole loop is repeated if it continues to
1644          * fail.
1645          */
1646         retry = 0;
1647         delay_us = 10000;
1648         while ((rc = efx_mcdi_vadaptor_alloc(enp, EVB_PORT_ID_ASSIGNED)) != 0) {
1649                 if (EFX_PCI_FUNCTION_IS_PF(&enp->en_nic_cfg) ||
1650                     (rc != ENOENT)) {
1651                         /*
1652                          * Do not retry alloc for PF, or for other errors on
1653                          * a VF.
1654                          */
1655                         goto fail5;
1656                 }
1657
1658                 /* VF startup before PF is ready. Retry allocation. */
1659                 if (retry > 5) {
1660                         /* Too many attempts */
1661                         rc = EINVAL;
1662                         goto fail6;
1663                 }
1664                 EFSYS_PROBE1(mcdi_no_evb_port_retry, int, retry);
1665                 EFSYS_SLEEP(delay_us);
1666                 retry++;
1667                 if (delay_us < 500000)
1668                         delay_us <<= 2;
1669         }
1670
1671         enp->en_vport_id = EVB_PORT_ID_ASSIGNED;
1672
1673         return (0);
1674
1675 fail6:
1676         EFSYS_PROBE(fail6);
1677 fail5:
1678         EFSYS_PROBE(fail5);
1679 fail4:
1680         EFSYS_PROBE(fail4);
1681 fail3:
1682         EFSYS_PROBE(fail3);
1683 fail2:
1684         EFSYS_PROBE(fail2);
1685
1686         hunt_nic_free_piobufs(enp);
1687
1688 fail1:
1689         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1690
1691         return (rc);
1692 }
1693
1694         __checkReturn   efx_rc_t
1695 hunt_nic_get_vi_pool(
1696         __in            efx_nic_t *enp,
1697         __out           uint32_t *vi_countp)
1698 {
1699         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
1700
1701         /*
1702          * Report VIs that the client driver can use.
1703          * Do not include VIs used for PIO buffer writes.
1704          */
1705         *vi_countp = enp->en_u.hunt.enu_pio_write_vi_base;
1706
1707         return (0);
1708 }
1709
1710         __checkReturn   efx_rc_t
1711 hunt_nic_get_bar_region(
1712         __in            efx_nic_t *enp,
1713         __in            efx_nic_region_t region,
1714         __out           uint32_t *offsetp,
1715         __out           size_t *sizep)
1716 {
1717         efx_rc_t rc;
1718
1719         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_HUNTINGTON);
1720
1721         /*
1722          * TODO: Specify host memory mapping alignment and granularity
1723          * in efx_drv_limits_t so that they can be taken into account
1724          * when allocating extra VIs for PIO writes.
1725          */
1726         switch (region) {
1727         case EFX_REGION_VI:
1728                 /* UC mapped memory BAR region for VI registers */
1729                 *offsetp = enp->en_u.hunt.enu_uc_mem_map_offset;
1730                 *sizep = enp->en_u.hunt.enu_uc_mem_map_size;
1731                 break;
1732
1733         case EFX_REGION_PIO_WRITE_VI:
1734                 /* WC mapped memory BAR region for piobuf writes */
1735                 *offsetp = enp->en_u.hunt.enu_wc_mem_map_offset;
1736                 *sizep = enp->en_u.hunt.enu_wc_mem_map_size;
1737                 break;
1738
1739         default:
1740                 rc = EINVAL;
1741                 goto fail1;
1742         }
1743
1744         return (0);
1745
1746 fail1:
1747         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1748
1749         return (rc);
1750 }
1751
1752                         void
1753 hunt_nic_fini(
1754         __in            efx_nic_t *enp)
1755 {
1756         uint32_t i;
1757         efx_rc_t rc;
1758
1759         (void) efx_mcdi_vadaptor_free(enp, enp->en_vport_id);
1760         enp->en_vport_id = 0;
1761
1762         /* Unlink piobufs from extra VIs in WC mapping */
1763         if (enp->en_u.hunt.enu_piobuf_count > 0) {
1764                 for (i = 0; i < enp->en_u.hunt.enu_piobuf_count; i++) {
1765                         rc = efx_mcdi_unlink_piobuf(enp,
1766                             enp->en_u.hunt.enu_pio_write_vi_base + i);
1767                         if (rc != 0)
1768                                 break;
1769                 }
1770         }
1771
1772         hunt_nic_free_piobufs(enp);
1773
1774         (void) efx_mcdi_free_vis(enp);
1775         enp->en_u.hunt.enu_vi_count = 0;
1776 }
1777
1778                         void
1779 hunt_nic_unprobe(
1780         __in            efx_nic_t *enp)
1781 {
1782 #if EFSYS_OPT_MON_STATS
1783         mcdi_mon_cfg_free(enp);
1784 #endif /* EFSYS_OPT_MON_STATS */
1785         (void) efx_mcdi_drv_attach(enp, B_FALSE);
1786 }
1787
1788 #if EFSYS_OPT_DIAG
1789
1790         __checkReturn   efx_rc_t
1791 hunt_nic_register_test(
1792         __in            efx_nic_t *enp)
1793 {
1794         efx_rc_t rc;
1795
1796         /* FIXME */
1797         _NOTE(ARGUNUSED(enp))
1798         if (B_FALSE) {
1799                 rc = ENOTSUP;
1800                 goto fail1;
1801         }
1802         /* FIXME */
1803
1804         return (0);
1805
1806 fail1:
1807         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1808
1809         return (rc);
1810 }
1811
1812 #endif  /* EFSYS_OPT_DIAG */
1813
1814
1815
1816 #endif  /* EFSYS_OPT_HUNTINGTON */