drivers/net/sfc/base/ef10_nic.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2012-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9 #if EFSYS_OPT_MON_MCDI
  10 #include "mcdi_mon.h"
  11 #endif
  12
  13 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
  14
  15 #include "ef10_tlv_layout.h"
  16
  17         __checkReturn   efx_rc_t
  18 efx_mcdi_get_port_assignment(
  19         __in            efx_nic_t *enp,
  20         __out           uint32_t *portp)
  21 {
  22         efx_mcdi_req_t req;
  23         uint8_t payload[MAX(MC_CMD_GET_PORT_ASSIGNMENT_IN_LEN,
  24                             MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN)];
  25         efx_rc_t rc;
  26
  27         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
  28             enp->en_family == EFX_FAMILY_MEDFORD ||
  29             enp->en_family == EFX_FAMILY_MEDFORD2);
  30
  31         (void) memset(payload, 0, sizeof (payload));
  32         req.emr_cmd = MC_CMD_GET_PORT_ASSIGNMENT;
  33         req.emr_in_buf = payload;
  34         req.emr_in_length = MC_CMD_GET_PORT_ASSIGNMENT_IN_LEN;
  35         req.emr_out_buf = payload;
  36         req.emr_out_length = MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN;
  37
  38         efx_mcdi_execute(enp, &req);
  39
  40         if (req.emr_rc != 0) {
  41                 rc = req.emr_rc;
  42                 goto fail1;
  43         }
  44
  45         if (req.emr_out_length_used < MC_CMD_GET_PORT_ASSIGNMENT_OUT_LEN) {
  46                 rc = EMSGSIZE;
  47                 goto fail2;
  48         }
  49
  50         *portp = MCDI_OUT_DWORD(req, GET_PORT_ASSIGNMENT_OUT_PORT);
  51
  52         return (0);
  53
  54 fail2:
  55         EFSYS_PROBE(fail2);
  56 fail1:
  57         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  58
  59         return (rc);
  60 }
  61
  62         __checkReturn   efx_rc_t
  63 efx_mcdi_get_port_modes(
  64         __in            efx_nic_t *enp,
  65         __out           uint32_t *modesp,
  66         __out_opt       uint32_t *current_modep)
  67 {
  68         efx_mcdi_req_t req;
  69         uint8_t payload[MAX(MC_CMD_GET_PORT_MODES_IN_LEN,
  70                             MC_CMD_GET_PORT_MODES_OUT_LEN)];
  71         efx_rc_t rc;
  72
  73         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
  74             enp->en_family == EFX_FAMILY_MEDFORD ||
  75             enp->en_family == EFX_FAMILY_MEDFORD2);
  76
  77         (void) memset(payload, 0, sizeof (payload));
  78         req.emr_cmd = MC_CMD_GET_PORT_MODES;
  79         req.emr_in_buf = payload;
  80         req.emr_in_length = MC_CMD_GET_PORT_MODES_IN_LEN;
  81         req.emr_out_buf = payload;
  82         req.emr_out_length = MC_CMD_GET_PORT_MODES_OUT_LEN;
  83
  84         efx_mcdi_execute(enp, &req);
  85
  86         if (req.emr_rc != 0) {
  87                 rc = req.emr_rc;
  88                 goto fail1;
  89         }
  90
  91         /*
  92          * Require only Modes and DefaultMode fields, unless the current mode
  93          * was requested (CurrentMode field was added for Medford).
  94          */
  95         if (req.emr_out_length_used <
  96             MC_CMD_GET_PORT_MODES_OUT_CURRENT_MODE_OFST) {
  97                 rc = EMSGSIZE;
  98                 goto fail2;
  99         }
 100         if ((current_modep != NULL) && (req.emr_out_length_used <
 101             MC_CMD_GET_PORT_MODES_OUT_CURRENT_MODE_OFST + 4)) {
 102                 rc = EMSGSIZE;
 103                 goto fail3;
 104         }
 105
 106         *modesp = MCDI_OUT_DWORD(req, GET_PORT_MODES_OUT_MODES);
 107
 108         if (current_modep != NULL) {
 109                 *current_modep = MCDI_OUT_DWORD(req,
 110                                             GET_PORT_MODES_OUT_CURRENT_MODE);
 111         }
 112
 113         return (0);
 114
 115 fail3:
 116         EFSYS_PROBE(fail3);
 117 fail2:
 118         EFSYS_PROBE(fail2);
 119 fail1:
 120         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 121
 122         return (rc);
 123 }
 124
 125         __checkReturn   efx_rc_t
 126 ef10_nic_get_port_mode_bandwidth(
 127         __in            uint32_t port_mode,
 128         __out           uint32_t *bandwidth_mbpsp)
 129 {
 130         uint32_t bandwidth;
 131         efx_rc_t rc;
 132
 133         switch (port_mode) {
 134         case TLV_PORT_MODE_10G:
 135                 bandwidth = 10000;
 136                 break;
 137         case TLV_PORT_MODE_10G_10G:
 138                 bandwidth = 10000 * 2;
 139                 break;
 140         case TLV_PORT_MODE_10G_10G_10G_10G:
 141         case TLV_PORT_MODE_10G_10G_10G_10G_Q:
 142         case TLV_PORT_MODE_10G_10G_10G_10G_Q1_Q2:
 143         case TLV_PORT_MODE_10G_10G_10G_10G_Q2:
 144                 bandwidth = 10000 * 4;
 145                 break;
 146         case TLV_PORT_MODE_40G:
 147                 bandwidth = 40000;
 148                 break;
 149         case TLV_PORT_MODE_40G_40G:
 150                 bandwidth = 40000 * 2;
 151                 break;
 152         case TLV_PORT_MODE_40G_10G_10G:
 153         case TLV_PORT_MODE_10G_10G_40G:
 154                 bandwidth = 40000 + (10000 * 2);
 155                 break;
 156         default:
 157                 rc = EINVAL;
 158                 goto fail1;
 159         }
 160
 161         *bandwidth_mbpsp = bandwidth;
 162
 163         return (0);
 164
 165 fail1:
 166         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 167
 168         return (rc);
 169 }
 170
 171 static  __checkReturn           efx_rc_t
 172 efx_mcdi_vadaptor_alloc(
 173         __in                    efx_nic_t *enp,
 174         __in                    uint32_t port_id)
 175 {
 176         efx_mcdi_req_t req;
 177         uint8_t payload[MAX(MC_CMD_VADAPTOR_ALLOC_IN_LEN,
 178                             MC_CMD_VADAPTOR_ALLOC_OUT_LEN)];
 179         efx_rc_t rc;
 180
 181         EFSYS_ASSERT3U(enp->en_vport_id, ==, EVB_PORT_ID_NULL);
 182
 183         (void) memset(payload, 0, sizeof (payload));
 184         req.emr_cmd = MC_CMD_VADAPTOR_ALLOC;
 185         req.emr_in_buf = payload;
 186         req.emr_in_length = MC_CMD_VADAPTOR_ALLOC_IN_LEN;
 187         req.emr_out_buf = payload;
 188         req.emr_out_length = MC_CMD_VADAPTOR_ALLOC_OUT_LEN;
 189
 190         MCDI_IN_SET_DWORD(req, VADAPTOR_ALLOC_IN_UPSTREAM_PORT_ID, port_id);
 191         MCDI_IN_POPULATE_DWORD_1(req, VADAPTOR_ALLOC_IN_FLAGS,
 192             VADAPTOR_ALLOC_IN_FLAG_PERMIT_SET_MAC_WHEN_FILTERS_INSTALLED,
 193             enp->en_nic_cfg.enc_allow_set_mac_with_installed_filters ? 1 : 0);
 194
 195         efx_mcdi_execute(enp, &req);
 196
 197         if (req.emr_rc != 0) {
 198                 rc = req.emr_rc;
 199                 goto fail1;
 200         }
 201
 202         return (0);
 203
 204 fail1:
 205         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 206
 207         return (rc);
 208 }
 209
 210 static  __checkReturn           efx_rc_t
 211 efx_mcdi_vadaptor_free(
 212         __in                    efx_nic_t *enp,
 213         __in                    uint32_t port_id)
 214 {
 215         efx_mcdi_req_t req;
 216         uint8_t payload[MAX(MC_CMD_VADAPTOR_FREE_IN_LEN,
 217                             MC_CMD_VADAPTOR_FREE_OUT_LEN)];
 218         efx_rc_t rc;
 219
 220         (void) memset(payload, 0, sizeof (payload));
 221         req.emr_cmd = MC_CMD_VADAPTOR_FREE;
 222         req.emr_in_buf = payload;
 223         req.emr_in_length = MC_CMD_VADAPTOR_FREE_IN_LEN;
 224         req.emr_out_buf = payload;
 225         req.emr_out_length = MC_CMD_VADAPTOR_FREE_OUT_LEN;
 226
 227         MCDI_IN_SET_DWORD(req, VADAPTOR_FREE_IN_UPSTREAM_PORT_ID, port_id);
 228
 229         efx_mcdi_execute(enp, &req);
 230
 231         if (req.emr_rc != 0) {
 232                 rc = req.emr_rc;
 233                 goto fail1;
 234         }
 235
 236         return (0);
 237
 238 fail1:
 239         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 240
 241         return (rc);
 242 }
 243
 244         __checkReturn   efx_rc_t
 245 efx_mcdi_get_mac_address_pf(
 246         __in                    efx_nic_t *enp,
 247         __out_ecount_opt(6)     uint8_t mac_addrp[6])
 248 {
 249         efx_mcdi_req_t req;
 250         uint8_t payload[MAX(MC_CMD_GET_MAC_ADDRESSES_IN_LEN,
 251                             MC_CMD_GET_MAC_ADDRESSES_OUT_LEN)];
 252         efx_rc_t rc;
 253
 254         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 255             enp->en_family == EFX_FAMILY_MEDFORD ||
 256             enp->en_family == EFX_FAMILY_MEDFORD2);
 257
 258         (void) memset(payload, 0, sizeof (payload));
 259         req.emr_cmd = MC_CMD_GET_MAC_ADDRESSES;
 260         req.emr_in_buf = payload;
 261         req.emr_in_length = MC_CMD_GET_MAC_ADDRESSES_IN_LEN;
 262         req.emr_out_buf = payload;
 263         req.emr_out_length = MC_CMD_GET_MAC_ADDRESSES_OUT_LEN;
 264
 265         efx_mcdi_execute(enp, &req);
 266
 267         if (req.emr_rc != 0) {
 268                 rc = req.emr_rc;
 269                 goto fail1;
 270         }
 271
 272         if (req.emr_out_length_used < MC_CMD_GET_MAC_ADDRESSES_OUT_LEN) {
 273                 rc = EMSGSIZE;
 274                 goto fail2;
 275         }
 276
 277         if (MCDI_OUT_DWORD(req, GET_MAC_ADDRESSES_OUT_MAC_COUNT) < 1) {
 278                 rc = ENOENT;
 279                 goto fail3;
 280         }
 281
 282         if (mac_addrp != NULL) {
 283                 uint8_t *addrp;
 284
 285                 addrp = MCDI_OUT2(req, uint8_t,
 286                     GET_MAC_ADDRESSES_OUT_MAC_ADDR_BASE);
 287
 288                 EFX_MAC_ADDR_COPY(mac_addrp, addrp);
 289         }
 290
 291         return (0);
 292
 293 fail3:
 294         EFSYS_PROBE(fail3);
 295 fail2:
 296         EFSYS_PROBE(fail2);
 297 fail1:
 298         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 299
 300         return (rc);
 301 }
 302
 303         __checkReturn   efx_rc_t
 304 efx_mcdi_get_mac_address_vf(
 305         __in                    efx_nic_t *enp,
 306         __out_ecount_opt(6)     uint8_t mac_addrp[6])
 307 {
 308         efx_mcdi_req_t req;
 309         uint8_t payload[MAX(MC_CMD_VPORT_GET_MAC_ADDRESSES_IN_LEN,
 310                             MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMAX)];
 311         efx_rc_t rc;
 312
 313         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 314             enp->en_family == EFX_FAMILY_MEDFORD ||
 315             enp->en_family == EFX_FAMILY_MEDFORD2);
 316
 317         (void) memset(payload, 0, sizeof (payload));
 318         req.emr_cmd = MC_CMD_VPORT_GET_MAC_ADDRESSES;
 319         req.emr_in_buf = payload;
 320         req.emr_in_length = MC_CMD_VPORT_GET_MAC_ADDRESSES_IN_LEN;
 321         req.emr_out_buf = payload;
 322         req.emr_out_length = MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMAX;
 323
 324         MCDI_IN_SET_DWORD(req, VPORT_GET_MAC_ADDRESSES_IN_VPORT_ID,
 325             EVB_PORT_ID_ASSIGNED);
 326
 327         efx_mcdi_execute(enp, &req);
 328
 329         if (req.emr_rc != 0) {
 330                 rc = req.emr_rc;
 331                 goto fail1;
 332         }
 333
 334         if (req.emr_out_length_used <
 335             MC_CMD_VPORT_GET_MAC_ADDRESSES_OUT_LENMIN) {
 336                 rc = EMSGSIZE;
 337                 goto fail2;
 338         }
 339
 340         if (MCDI_OUT_DWORD(req,
 341                 VPORT_GET_MAC_ADDRESSES_OUT_MACADDR_COUNT) < 1) {
 342                 rc = ENOENT;
 343                 goto fail3;
 344         }
 345
 346         if (mac_addrp != NULL) {
 347                 uint8_t *addrp;
 348
 349                 addrp = MCDI_OUT2(req, uint8_t,
 350                     VPORT_GET_MAC_ADDRESSES_OUT_MACADDR);
 351
 352                 EFX_MAC_ADDR_COPY(mac_addrp, addrp);
 353         }
 354
 355         return (0);
 356
 357 fail3:
 358         EFSYS_PROBE(fail3);
 359 fail2:
 360         EFSYS_PROBE(fail2);
 361 fail1:
 362         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 363
 364         return (rc);
 365 }
 366
 367         __checkReturn   efx_rc_t
 368 efx_mcdi_get_clock(
 369         __in            efx_nic_t *enp,
 370         __out           uint32_t *sys_freqp,
 371         __out           uint32_t *dpcpu_freqp)
 372 {
 373         efx_mcdi_req_t req;
 374         uint8_t payload[MAX(MC_CMD_GET_CLOCK_IN_LEN,
 375                             MC_CMD_GET_CLOCK_OUT_LEN)];
 376         efx_rc_t rc;
 377
 378         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 379             enp->en_family == EFX_FAMILY_MEDFORD ||
 380             enp->en_family == EFX_FAMILY_MEDFORD2);
 381
 382         (void) memset(payload, 0, sizeof (payload));
 383         req.emr_cmd = MC_CMD_GET_CLOCK;
 384         req.emr_in_buf = payload;
 385         req.emr_in_length = MC_CMD_GET_CLOCK_IN_LEN;
 386         req.emr_out_buf = payload;
 387         req.emr_out_length = MC_CMD_GET_CLOCK_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_CLOCK_OUT_LEN) {
 397                 rc = EMSGSIZE;
 398                 goto fail2;
 399         }
 400
 401         *sys_freqp = MCDI_OUT_DWORD(req, GET_CLOCK_OUT_SYS_FREQ);
 402         if (*sys_freqp == 0) {
 403                 rc = EINVAL;
 404                 goto fail3;
 405         }
 406         *dpcpu_freqp = MCDI_OUT_DWORD(req, GET_CLOCK_OUT_DPCPU_FREQ);
 407         if (*dpcpu_freqp == 0) {
 408                 rc = EINVAL;
 409                 goto fail4;
 410         }
 411
 412         return (0);
 413
 414 fail4:
 415         EFSYS_PROBE(fail4);
 416 fail3:
 417         EFSYS_PROBE(fail3);
 418 fail2:
 419         EFSYS_PROBE(fail2);
 420 fail1:
 421         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 422
 423         return (rc);
 424 }
 425
 426         __checkReturn   efx_rc_t
 427 efx_mcdi_get_rxdp_config(
 428         __in            efx_nic_t *enp,
 429         __out           uint32_t *end_paddingp)
 430 {
 431         efx_mcdi_req_t req;
 432         uint8_t payload[MAX(MC_CMD_GET_RXDP_CONFIG_IN_LEN,
 433                             MC_CMD_GET_RXDP_CONFIG_OUT_LEN)];
 434         uint32_t end_padding;
 435         efx_rc_t rc;
 436
 437         memset(payload, 0, sizeof (payload));
 438         req.emr_cmd = MC_CMD_GET_RXDP_CONFIG;
 439         req.emr_in_buf = payload;
 440         req.emr_in_length = MC_CMD_GET_RXDP_CONFIG_IN_LEN;
 441         req.emr_out_buf = payload;
 442         req.emr_out_length = MC_CMD_GET_RXDP_CONFIG_OUT_LEN;
 443
 444         efx_mcdi_execute(enp, &req);
 445         if (req.emr_rc != 0) {
 446                 rc = req.emr_rc;
 447                 goto fail1;
 448         }
 449
 450         if (MCDI_OUT_DWORD_FIELD(req, GET_RXDP_CONFIG_OUT_DATA,
 451                                     GET_RXDP_CONFIG_OUT_PAD_HOST_DMA) == 0) {
 452                 /* RX DMA end padding is disabled */
 453                 end_padding = 0;
 454         } else {
 455                 switch (MCDI_OUT_DWORD_FIELD(req, GET_RXDP_CONFIG_OUT_DATA,
 456                                             GET_RXDP_CONFIG_OUT_PAD_HOST_LEN)) {
 457                 case MC_CMD_SET_RXDP_CONFIG_IN_PAD_HOST_64:
 458                         end_padding = 64;
 459                         break;
 460                 case MC_CMD_SET_RXDP_CONFIG_IN_PAD_HOST_128:
 461                         end_padding = 128;
 462                         break;
 463                 case MC_CMD_SET_RXDP_CONFIG_IN_PAD_HOST_256:
 464                         end_padding = 256;
 465                         break;
 466                 default:
 467                         rc = ENOTSUP;
 468                         goto fail2;
 469                 }
 470         }
 471
 472         *end_paddingp = end_padding;
 473
 474         return (0);
 475
 476 fail2:
 477         EFSYS_PROBE(fail2);
 478 fail1:
 479         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 480
 481         return (rc);
 482 }
 483
 484         __checkReturn   efx_rc_t
 485 efx_mcdi_get_vector_cfg(
 486         __in            efx_nic_t *enp,
 487         __out_opt       uint32_t *vec_basep,
 488         __out_opt       uint32_t *pf_nvecp,
 489         __out_opt       uint32_t *vf_nvecp)
 490 {
 491         efx_mcdi_req_t req;
 492         uint8_t payload[MAX(MC_CMD_GET_VECTOR_CFG_IN_LEN,
 493                             MC_CMD_GET_VECTOR_CFG_OUT_LEN)];
 494         efx_rc_t rc;
 495
 496         (void) memset(payload, 0, sizeof (payload));
 497         req.emr_cmd = MC_CMD_GET_VECTOR_CFG;
 498         req.emr_in_buf = payload;
 499         req.emr_in_length = MC_CMD_GET_VECTOR_CFG_IN_LEN;
 500         req.emr_out_buf = payload;
 501         req.emr_out_length = MC_CMD_GET_VECTOR_CFG_OUT_LEN;
 502
 503         efx_mcdi_execute(enp, &req);
 504
 505         if (req.emr_rc != 0) {
 506                 rc = req.emr_rc;
 507                 goto fail1;
 508         }
 509
 510         if (req.emr_out_length_used < MC_CMD_GET_VECTOR_CFG_OUT_LEN) {
 511                 rc = EMSGSIZE;
 512                 goto fail2;
 513         }
 514
 515         if (vec_basep != NULL)
 516                 *vec_basep = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VEC_BASE);
 517         if (pf_nvecp != NULL)
 518                 *pf_nvecp = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VECS_PER_PF);
 519         if (vf_nvecp != NULL)
 520                 *vf_nvecp = MCDI_OUT_DWORD(req, GET_VECTOR_CFG_OUT_VECS_PER_VF);
 521
 522         return (0);
 523
 524 fail2:
 525         EFSYS_PROBE(fail2);
 526 fail1:
 527         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 528
 529         return (rc);
 530 }
 531
 532 static  __checkReturn   efx_rc_t
 533 efx_mcdi_alloc_vis(
 534         __in            efx_nic_t *enp,
 535         __in            uint32_t min_vi_count,
 536         __in            uint32_t max_vi_count,
 537         __out           uint32_t *vi_basep,
 538         __out           uint32_t *vi_countp,
 539         __out           uint32_t *vi_shiftp)
 540 {
 541         efx_mcdi_req_t req;
 542         uint8_t payload[MAX(MC_CMD_ALLOC_VIS_IN_LEN,
 543                             MC_CMD_ALLOC_VIS_EXT_OUT_LEN)];
 544         efx_rc_t rc;
 545
 546         if (vi_countp == NULL) {
 547                 rc = EINVAL;
 548                 goto fail1;
 549         }
 550
 551         (void) memset(payload, 0, sizeof (payload));
 552         req.emr_cmd = MC_CMD_ALLOC_VIS;
 553         req.emr_in_buf = payload;
 554         req.emr_in_length = MC_CMD_ALLOC_VIS_IN_LEN;
 555         req.emr_out_buf = payload;
 556         req.emr_out_length = MC_CMD_ALLOC_VIS_EXT_OUT_LEN;
 557
 558         MCDI_IN_SET_DWORD(req, ALLOC_VIS_IN_MIN_VI_COUNT, min_vi_count);
 559         MCDI_IN_SET_DWORD(req, ALLOC_VIS_IN_MAX_VI_COUNT, max_vi_count);
 560
 561         efx_mcdi_execute(enp, &req);
 562
 563         if (req.emr_rc != 0) {
 564                 rc = req.emr_rc;
 565                 goto fail2;
 566         }
 567
 568         if (req.emr_out_length_used < MC_CMD_ALLOC_VIS_OUT_LEN) {
 569                 rc = EMSGSIZE;
 570                 goto fail3;
 571         }
 572
 573         *vi_basep = MCDI_OUT_DWORD(req, ALLOC_VIS_OUT_VI_BASE);
 574         *vi_countp = MCDI_OUT_DWORD(req, ALLOC_VIS_OUT_VI_COUNT);
 575
 576         /* Report VI_SHIFT if available (always zero for Huntington) */
 577         if (req.emr_out_length_used < MC_CMD_ALLOC_VIS_EXT_OUT_LEN)
 578                 *vi_shiftp = 0;
 579         else
 580                 *vi_shiftp = MCDI_OUT_DWORD(req, ALLOC_VIS_EXT_OUT_VI_SHIFT);
 581
 582         return (0);
 583
 584 fail3:
 585         EFSYS_PROBE(fail3);
 586 fail2:
 587         EFSYS_PROBE(fail2);
 588 fail1:
 589         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 590
 591         return (rc);
 592 }
 593
 594
 595 static  __checkReturn   efx_rc_t
 596 efx_mcdi_free_vis(
 597         __in            efx_nic_t *enp)
 598 {
 599         efx_mcdi_req_t req;
 600         efx_rc_t rc;
 601
 602         EFX_STATIC_ASSERT(MC_CMD_FREE_VIS_IN_LEN == 0);
 603         EFX_STATIC_ASSERT(MC_CMD_FREE_VIS_OUT_LEN == 0);
 604
 605         req.emr_cmd = MC_CMD_FREE_VIS;
 606         req.emr_in_buf = NULL;
 607         req.emr_in_length = 0;
 608         req.emr_out_buf = NULL;
 609         req.emr_out_length = 0;
 610
 611         efx_mcdi_execute_quiet(enp, &req);
 612
 613         /* Ignore ELREADY (no allocated VIs, so nothing to free) */
 614         if ((req.emr_rc != 0) && (req.emr_rc != EALREADY)) {
 615                 rc = req.emr_rc;
 616                 goto fail1;
 617         }
 618
 619         return (0);
 620
 621 fail1:
 622         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 623
 624         return (rc);
 625 }
 626
 627
 628 static  __checkReturn   efx_rc_t
 629 efx_mcdi_alloc_piobuf(
 630         __in            efx_nic_t *enp,
 631         __out           efx_piobuf_handle_t *handlep)
 632 {
 633         efx_mcdi_req_t req;
 634         uint8_t payload[MAX(MC_CMD_ALLOC_PIOBUF_IN_LEN,
 635                             MC_CMD_ALLOC_PIOBUF_OUT_LEN)];
 636         efx_rc_t rc;
 637
 638         if (handlep == NULL) {
 639                 rc = EINVAL;
 640                 goto fail1;
 641         }
 642
 643         (void) memset(payload, 0, sizeof (payload));
 644         req.emr_cmd = MC_CMD_ALLOC_PIOBUF;
 645         req.emr_in_buf = payload;
 646         req.emr_in_length = MC_CMD_ALLOC_PIOBUF_IN_LEN;
 647         req.emr_out_buf = payload;
 648         req.emr_out_length = MC_CMD_ALLOC_PIOBUF_OUT_LEN;
 649
 650         efx_mcdi_execute_quiet(enp, &req);
 651
 652         if (req.emr_rc != 0) {
 653                 rc = req.emr_rc;
 654                 goto fail2;
 655         }
 656
 657         if (req.emr_out_length_used < MC_CMD_ALLOC_PIOBUF_OUT_LEN) {
 658                 rc = EMSGSIZE;
 659                 goto fail3;
 660         }
 661
 662         *handlep = MCDI_OUT_DWORD(req, ALLOC_PIOBUF_OUT_PIOBUF_HANDLE);
 663
 664         return (0);
 665
 666 fail3:
 667         EFSYS_PROBE(fail3);
 668 fail2:
 669         EFSYS_PROBE(fail2);
 670 fail1:
 671         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 672
 673         return (rc);
 674 }
 675
 676 static  __checkReturn   efx_rc_t
 677 efx_mcdi_free_piobuf(
 678         __in            efx_nic_t *enp,
 679         __in            efx_piobuf_handle_t handle)
 680 {
 681         efx_mcdi_req_t req;
 682         uint8_t payload[MAX(MC_CMD_FREE_PIOBUF_IN_LEN,
 683                             MC_CMD_FREE_PIOBUF_OUT_LEN)];
 684         efx_rc_t rc;
 685
 686         (void) memset(payload, 0, sizeof (payload));
 687         req.emr_cmd = MC_CMD_FREE_PIOBUF;
 688         req.emr_in_buf = payload;
 689         req.emr_in_length = MC_CMD_FREE_PIOBUF_IN_LEN;
 690         req.emr_out_buf = payload;
 691         req.emr_out_length = MC_CMD_FREE_PIOBUF_OUT_LEN;
 692
 693         MCDI_IN_SET_DWORD(req, FREE_PIOBUF_IN_PIOBUF_HANDLE, handle);
 694
 695         efx_mcdi_execute_quiet(enp, &req);
 696
 697         if (req.emr_rc != 0) {
 698                 rc = req.emr_rc;
 699                 goto fail1;
 700         }
 701
 702         return (0);
 703
 704 fail1:
 705         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 706
 707         return (rc);
 708 }
 709
 710 static  __checkReturn   efx_rc_t
 711 efx_mcdi_link_piobuf(
 712         __in            efx_nic_t *enp,
 713         __in            uint32_t vi_index,
 714         __in            efx_piobuf_handle_t handle)
 715 {
 716         efx_mcdi_req_t req;
 717         uint8_t payload[MAX(MC_CMD_LINK_PIOBUF_IN_LEN,
 718                             MC_CMD_LINK_PIOBUF_OUT_LEN)];
 719         efx_rc_t rc;
 720
 721         (void) memset(payload, 0, sizeof (payload));
 722         req.emr_cmd = MC_CMD_LINK_PIOBUF;
 723         req.emr_in_buf = payload;
 724         req.emr_in_length = MC_CMD_LINK_PIOBUF_IN_LEN;
 725         req.emr_out_buf = payload;
 726         req.emr_out_length = MC_CMD_LINK_PIOBUF_OUT_LEN;
 727
 728         MCDI_IN_SET_DWORD(req, LINK_PIOBUF_IN_PIOBUF_HANDLE, handle);
 729         MCDI_IN_SET_DWORD(req, LINK_PIOBUF_IN_TXQ_INSTANCE, vi_index);
 730
 731         efx_mcdi_execute(enp, &req);
 732
 733         if (req.emr_rc != 0) {
 734                 rc = req.emr_rc;
 735                 goto fail1;
 736         }
 737
 738         return (0);
 739
 740 fail1:
 741         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 742
 743         return (rc);
 744 }
 745
 746 static  __checkReturn   efx_rc_t
 747 efx_mcdi_unlink_piobuf(
 748         __in            efx_nic_t *enp,
 749         __in            uint32_t vi_index)
 750 {
 751         efx_mcdi_req_t req;
 752         uint8_t payload[MAX(MC_CMD_UNLINK_PIOBUF_IN_LEN,
 753                             MC_CMD_UNLINK_PIOBUF_OUT_LEN)];
 754         efx_rc_t rc;
 755
 756         (void) memset(payload, 0, sizeof (payload));
 757         req.emr_cmd = MC_CMD_UNLINK_PIOBUF;
 758         req.emr_in_buf = payload;
 759         req.emr_in_length = MC_CMD_UNLINK_PIOBUF_IN_LEN;
 760         req.emr_out_buf = payload;
 761         req.emr_out_length = MC_CMD_UNLINK_PIOBUF_OUT_LEN;
 762
 763         MCDI_IN_SET_DWORD(req, UNLINK_PIOBUF_IN_TXQ_INSTANCE, vi_index);
 764
 765         efx_mcdi_execute_quiet(enp, &req);
 766
 767         if (req.emr_rc != 0) {
 768                 rc = req.emr_rc;
 769                 goto fail1;
 770         }
 771
 772         return (0);
 773
 774 fail1:
 775         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 776
 777         return (rc);
 778 }
 779
 780 static                  void
 781 ef10_nic_alloc_piobufs(
 782         __in            efx_nic_t *enp,
 783         __in            uint32_t max_piobuf_count)
 784 {
 785         efx_piobuf_handle_t *handlep;
 786         unsigned int i;
 787
 788         EFSYS_ASSERT3U(max_piobuf_count, <=,
 789             EFX_ARRAY_SIZE(enp->en_arch.ef10.ena_piobuf_handle));
 790
 791         enp->en_arch.ef10.ena_piobuf_count = 0;
 792
 793         for (i = 0; i < max_piobuf_count; i++) {
 794                 handlep = &enp->en_arch.ef10.ena_piobuf_handle[i];
 795
 796                 if (efx_mcdi_alloc_piobuf(enp, handlep) != 0)
 797                         goto fail1;
 798
 799                 enp->en_arch.ef10.ena_pio_alloc_map[i] = 0;
 800                 enp->en_arch.ef10.ena_piobuf_count++;
 801         }
 802
 803         return;
 804
 805 fail1:
 806         for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
 807                 handlep = &enp->en_arch.ef10.ena_piobuf_handle[i];
 808
 809                 efx_mcdi_free_piobuf(enp, *handlep);
 810                 *handlep = EFX_PIOBUF_HANDLE_INVALID;
 811         }
 812         enp->en_arch.ef10.ena_piobuf_count = 0;
 813 }
 814
 815
 816 static                  void
 817 ef10_nic_free_piobufs(
 818         __in            efx_nic_t *enp)
 819 {
 820         efx_piobuf_handle_t *handlep;
 821         unsigned int i;
 822
 823         for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
 824                 handlep = &enp->en_arch.ef10.ena_piobuf_handle[i];
 825
 826                 efx_mcdi_free_piobuf(enp, *handlep);
 827                 *handlep = EFX_PIOBUF_HANDLE_INVALID;
 828         }
 829         enp->en_arch.ef10.ena_piobuf_count = 0;
 830 }
 831
 832 /* Sub-allocate a block from a piobuf */
 833         __checkReturn   efx_rc_t
 834 ef10_nic_pio_alloc(
 835         __inout         efx_nic_t *enp,
 836         __out           uint32_t *bufnump,
 837         __out           efx_piobuf_handle_t *handlep,
 838         __out           uint32_t *blknump,
 839         __out           uint32_t *offsetp,
 840         __out           size_t *sizep)
 841 {
 842         efx_nic_cfg_t *encp = &enp->en_nic_cfg;
 843         efx_drv_cfg_t *edcp = &enp->en_drv_cfg;
 844         uint32_t blk_per_buf;
 845         uint32_t buf, blk;
 846         efx_rc_t rc;
 847
 848         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 849             enp->en_family == EFX_FAMILY_MEDFORD ||
 850             enp->en_family == EFX_FAMILY_MEDFORD2);
 851         EFSYS_ASSERT(bufnump);
 852         EFSYS_ASSERT(handlep);
 853         EFSYS_ASSERT(blknump);
 854         EFSYS_ASSERT(offsetp);
 855         EFSYS_ASSERT(sizep);
 856
 857         if ((edcp->edc_pio_alloc_size == 0) ||
 858             (enp->en_arch.ef10.ena_piobuf_count == 0)) {
 859                 rc = ENOMEM;
 860                 goto fail1;
 861         }
 862         blk_per_buf = encp->enc_piobuf_size / edcp->edc_pio_alloc_size;
 863
 864         for (buf = 0; buf < enp->en_arch.ef10.ena_piobuf_count; buf++) {
 865                 uint32_t *map = &enp->en_arch.ef10.ena_pio_alloc_map[buf];
 866
 867                 if (~(*map) == 0)
 868                         continue;
 869
 870                 EFSYS_ASSERT3U(blk_per_buf, <=, (8 * sizeof (*map)));
 871                 for (blk = 0; blk < blk_per_buf; blk++) {
 872                         if ((*map & (1u << blk)) == 0) {
 873                                 *map |= (1u << blk);
 874                                 goto done;
 875                         }
 876                 }
 877         }
 878         rc = ENOMEM;
 879         goto fail2;
 880
 881 done:
 882         *handlep = enp->en_arch.ef10.ena_piobuf_handle[buf];
 883         *bufnump = buf;
 884         *blknump = blk;
 885         *sizep = edcp->edc_pio_alloc_size;
 886         *offsetp = blk * (*sizep);
 887
 888         return (0);
 889
 890 fail2:
 891         EFSYS_PROBE(fail2);
 892 fail1:
 893         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 894
 895         return (rc);
 896 }
 897
 898 /* Free a piobuf sub-allocated block */
 899         __checkReturn   efx_rc_t
 900 ef10_nic_pio_free(
 901         __inout         efx_nic_t *enp,
 902         __in            uint32_t bufnum,
 903         __in            uint32_t blknum)
 904 {
 905         uint32_t *map;
 906         efx_rc_t rc;
 907
 908         if ((bufnum >= enp->en_arch.ef10.ena_piobuf_count) ||
 909             (blknum >= (8 * sizeof (*map)))) {
 910                 rc = EINVAL;
 911                 goto fail1;
 912         }
 913
 914         map = &enp->en_arch.ef10.ena_pio_alloc_map[bufnum];
 915         if ((*map & (1u << blknum)) == 0) {
 916                 rc = ENOENT;
 917                 goto fail2;
 918         }
 919         *map &= ~(1u << blknum);
 920
 921         return (0);
 922
 923 fail2:
 924         EFSYS_PROBE(fail2);
 925 fail1:
 926         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 927
 928         return (rc);
 929 }
 930
 931         __checkReturn   efx_rc_t
 932 ef10_nic_pio_link(
 933         __inout         efx_nic_t *enp,
 934         __in            uint32_t vi_index,
 935         __in            efx_piobuf_handle_t handle)
 936 {
 937         return (efx_mcdi_link_piobuf(enp, vi_index, handle));
 938 }
 939
 940         __checkReturn   efx_rc_t
 941 ef10_nic_pio_unlink(
 942         __inout         efx_nic_t *enp,
 943         __in            uint32_t vi_index)
 944 {
 945         return (efx_mcdi_unlink_piobuf(enp, vi_index));
 946 }
 947
 948 static  __checkReturn   efx_rc_t
 949 ef10_mcdi_get_pf_count(
 950         __in            efx_nic_t *enp,
 951         __out           uint32_t *pf_countp)
 952 {
 953         efx_mcdi_req_t req;
 954         uint8_t payload[MAX(MC_CMD_GET_PF_COUNT_IN_LEN,
 955                             MC_CMD_GET_PF_COUNT_OUT_LEN)];
 956         efx_rc_t rc;
 957
 958         (void) memset(payload, 0, sizeof (payload));
 959         req.emr_cmd = MC_CMD_GET_PF_COUNT;
 960         req.emr_in_buf = payload;
 961         req.emr_in_length = MC_CMD_GET_PF_COUNT_IN_LEN;
 962         req.emr_out_buf = payload;
 963         req.emr_out_length = MC_CMD_GET_PF_COUNT_OUT_LEN;
 964
 965         efx_mcdi_execute(enp, &req);
 966
 967         if (req.emr_rc != 0) {
 968                 rc = req.emr_rc;
 969                 goto fail1;
 970         }
 971
 972         if (req.emr_out_length_used < MC_CMD_GET_PF_COUNT_OUT_LEN) {
 973                 rc = EMSGSIZE;
 974                 goto fail2;
 975         }
 976
 977         *pf_countp = *MCDI_OUT(req, uint8_t,
 978                                 MC_CMD_GET_PF_COUNT_OUT_PF_COUNT_OFST);
 979
 980         EFSYS_ASSERT(*pf_countp != 0);
 981
 982         return (0);
 983
 984 fail2:
 985         EFSYS_PROBE(fail2);
 986 fail1:
 987         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 988
 989         return (rc);
 990 }
 991
 992 static  __checkReturn   efx_rc_t
 993 ef10_get_datapath_caps(
 994         __in            efx_nic_t *enp)
 995 {
 996         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 997         efx_mcdi_req_t req;
 998         uint8_t payload[MAX(MC_CMD_GET_CAPABILITIES_IN_LEN,
 999                             MC_CMD_GET_CAPABILITIES_V5_OUT_LEN)];
1000         efx_rc_t rc;
1001
1002         if ((rc = ef10_mcdi_get_pf_count(enp, &encp->enc_hw_pf_count)) != 0)
1003                 goto fail1;
1004
1005
1006         (void) memset(payload, 0, sizeof (payload));
1007         req.emr_cmd = MC_CMD_GET_CAPABILITIES;
1008         req.emr_in_buf = payload;
1009         req.emr_in_length = MC_CMD_GET_CAPABILITIES_IN_LEN;
1010         req.emr_out_buf = payload;
1011         req.emr_out_length = MC_CMD_GET_CAPABILITIES_V5_OUT_LEN;
1012
1013         efx_mcdi_execute_quiet(enp, &req);
1014
1015         if (req.emr_rc != 0) {
1016                 rc = req.emr_rc;
1017                 goto fail2;
1018         }
1019
1020         if (req.emr_out_length_used < MC_CMD_GET_CAPABILITIES_OUT_LEN) {
1021                 rc = EMSGSIZE;
1022                 goto fail3;
1023         }
1024
1025 #define CAP_FLAGS1(_req, _flag)                                         \
1026         (MCDI_OUT_DWORD((_req), GET_CAPABILITIES_OUT_FLAGS1) &          \
1027         (1u << (MC_CMD_GET_CAPABILITIES_V2_OUT_ ## _flag ## _LBN)))
1028
1029 #define CAP_FLAGS2(_req, _flag)                                         \
1030         (((_req).emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V2_OUT_LEN) && \
1031             (MCDI_OUT_DWORD((_req), GET_CAPABILITIES_V2_OUT_FLAGS2) &   \
1032             (1u << (MC_CMD_GET_CAPABILITIES_V2_OUT_ ## _flag ## _LBN))))
1033
1034         /*
1035          * Huntington RXDP firmware inserts a 0 or 14 byte prefix.
1036          * We only support the 14 byte prefix here.
1037          */
1038         if (CAP_FLAGS1(req, RX_PREFIX_LEN_14) == 0) {
1039                 rc = ENOTSUP;
1040                 goto fail4;
1041         }
1042         encp->enc_rx_prefix_size = 14;
1043
1044         /* Check if the firmware supports additional RSS modes */
1045         if (CAP_FLAGS1(req, ADDITIONAL_RSS_MODES))
1046                 encp->enc_rx_scale_additional_modes_supported = B_TRUE;
1047         else
1048                 encp->enc_rx_scale_additional_modes_supported = B_FALSE;
1049
1050         /* Check if the firmware supports TSO */
1051         if (CAP_FLAGS1(req, TX_TSO))
1052                 encp->enc_fw_assisted_tso_enabled = B_TRUE;
1053         else
1054                 encp->enc_fw_assisted_tso_enabled = B_FALSE;
1055
1056         /* Check if the firmware supports FATSOv2 */
1057         if (CAP_FLAGS2(req, TX_TSO_V2)) {
1058                 encp->enc_fw_assisted_tso_v2_enabled = B_TRUE;
1059                 encp->enc_fw_assisted_tso_v2_n_contexts = MCDI_OUT_WORD(req,
1060                     GET_CAPABILITIES_V2_OUT_TX_TSO_V2_N_CONTEXTS);
1061         } else {
1062                 encp->enc_fw_assisted_tso_v2_enabled = B_FALSE;
1063                 encp->enc_fw_assisted_tso_v2_n_contexts = 0;
1064         }
1065
1066         /* Check if the firmware supports FATSOv2 encap */
1067         if (CAP_FLAGS2(req, TX_TSO_V2_ENCAP))
1068                 encp->enc_fw_assisted_tso_v2_encap_enabled = B_TRUE;
1069         else
1070                 encp->enc_fw_assisted_tso_v2_encap_enabled = B_FALSE;
1071
1072         /* Check if the firmware has vadapter/vport/vswitch support */
1073         if (CAP_FLAGS1(req, EVB))
1074                 encp->enc_datapath_cap_evb = B_TRUE;
1075         else
1076                 encp->enc_datapath_cap_evb = B_FALSE;
1077
1078         /* Check if the firmware supports VLAN insertion */
1079         if (CAP_FLAGS1(req, TX_VLAN_INSERTION))
1080                 encp->enc_hw_tx_insert_vlan_enabled = B_TRUE;
1081         else
1082                 encp->enc_hw_tx_insert_vlan_enabled = B_FALSE;
1083
1084         /* Check if the firmware supports RX event batching */
1085         if (CAP_FLAGS1(req, RX_BATCHING))
1086                 encp->enc_rx_batching_enabled = B_TRUE;
1087         else
1088                 encp->enc_rx_batching_enabled = B_FALSE;
1089
1090         /*
1091          * Even if batching isn't reported as supported, we may still get
1092          * batched events (see bug61153).
1093          */
1094         encp->enc_rx_batch_max = 16;
1095
1096         /* Check if the firmware supports disabling scatter on RXQs */
1097         if (CAP_FLAGS1(req, RX_DISABLE_SCATTER))
1098                 encp->enc_rx_disable_scatter_supported = B_TRUE;
1099         else
1100                 encp->enc_rx_disable_scatter_supported = B_FALSE;
1101
1102         /* Check if the firmware supports packed stream mode */
1103         if (CAP_FLAGS1(req, RX_PACKED_STREAM))
1104                 encp->enc_rx_packed_stream_supported = B_TRUE;
1105         else
1106                 encp->enc_rx_packed_stream_supported = B_FALSE;
1107
1108         /*
1109          * Check if the firmware supports configurable buffer sizes
1110          * for packed stream mode (otherwise buffer size is 1Mbyte)
1111          */
1112         if (CAP_FLAGS1(req, RX_PACKED_STREAM_VAR_BUFFERS))
1113                 encp->enc_rx_var_packed_stream_supported = B_TRUE;
1114         else
1115                 encp->enc_rx_var_packed_stream_supported = B_FALSE;
1116
1117         /* Check if the firmware supports equal stride super-buffer mode */
1118         if (CAP_FLAGS2(req, EQUAL_STRIDE_SUPER_BUFFER))
1119                 encp->enc_rx_es_super_buffer_supported = B_TRUE;
1120         else
1121                 encp->enc_rx_es_super_buffer_supported = B_FALSE;
1122
1123         /* Check if the firmware supports FW subvariant w/o Tx checksumming */
1124         if (CAP_FLAGS2(req, FW_SUBVARIANT_NO_TX_CSUM))
1125                 encp->enc_fw_subvariant_no_tx_csum_supported = B_TRUE;
1126         else
1127                 encp->enc_fw_subvariant_no_tx_csum_supported = B_FALSE;
1128
1129         /* Check if the firmware supports set mac with running filters */
1130         if (CAP_FLAGS1(req, VADAPTOR_PERMIT_SET_MAC_WHEN_FILTERS_INSTALLED))
1131                 encp->enc_allow_set_mac_with_installed_filters = B_TRUE;
1132         else
1133                 encp->enc_allow_set_mac_with_installed_filters = B_FALSE;
1134
1135         /*
1136          * Check if firmware supports the extended MC_CMD_SET_MAC, which allows
1137          * specifying which parameters to configure.
1138          */
1139         if (CAP_FLAGS1(req, SET_MAC_ENHANCED))
1140                 encp->enc_enhanced_set_mac_supported = B_TRUE;
1141         else
1142                 encp->enc_enhanced_set_mac_supported = B_FALSE;
1143
1144         /*
1145          * Check if firmware supports version 2 of MC_CMD_INIT_EVQ, which allows
1146          * us to let the firmware choose the settings to use on an EVQ.
1147          */
1148         if (CAP_FLAGS2(req, INIT_EVQ_V2))
1149                 encp->enc_init_evq_v2_supported = B_TRUE;
1150         else
1151                 encp->enc_init_evq_v2_supported = B_FALSE;
1152
1153         /*
1154          * Check if firmware-verified NVRAM updates must be used.
1155          *
1156          * The firmware trusted installer requires all NVRAM updates to use
1157          * version 2 of MC_CMD_NVRAM_UPDATE_START (to enable verified update)
1158          * and version 2 of MC_CMD_NVRAM_UPDATE_FINISH (to verify the updated
1159          * partition and report the result).
1160          */
1161         if (CAP_FLAGS2(req, NVRAM_UPDATE_REPORT_VERIFY_RESULT))
1162                 encp->enc_nvram_update_verify_result_supported = B_TRUE;
1163         else
1164                 encp->enc_nvram_update_verify_result_supported = B_FALSE;
1165
1166         /*
1167          * Check if firmware provides packet memory and Rx datapath
1168          * counters.
1169          */
1170         if (CAP_FLAGS1(req, PM_AND_RXDP_COUNTERS))
1171                 encp->enc_pm_and_rxdp_counters = B_TRUE;
1172         else
1173                 encp->enc_pm_and_rxdp_counters = B_FALSE;
1174
1175         /*
1176          * Check if the 40G MAC hardware is capable of reporting
1177          * statistics for Tx size bins.
1178          */
1179         if (CAP_FLAGS2(req, MAC_STATS_40G_TX_SIZE_BINS))
1180                 encp->enc_mac_stats_40g_tx_size_bins = B_TRUE;
1181         else
1182                 encp->enc_mac_stats_40g_tx_size_bins = B_FALSE;
1183
1184         /*
1185          * Check if firmware supports VXLAN and NVGRE tunnels.
1186          * The capability indicates Geneve protocol support as well.
1187          */
1188         if (CAP_FLAGS1(req, VXLAN_NVGRE)) {
1189                 encp->enc_tunnel_encapsulations_supported =
1190                     (1u << EFX_TUNNEL_PROTOCOL_VXLAN) |
1191                     (1u << EFX_TUNNEL_PROTOCOL_GENEVE) |
1192                     (1u << EFX_TUNNEL_PROTOCOL_NVGRE);
1193
1194                 EFX_STATIC_ASSERT(EFX_TUNNEL_MAXNENTRIES ==
1195                     MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES_MAXNUM);
1196                 encp->enc_tunnel_config_udp_entries_max =
1197                     EFX_TUNNEL_MAXNENTRIES;
1198         } else {
1199                 encp->enc_tunnel_config_udp_entries_max = 0;
1200         }
1201
1202         /*
1203          * Check if firmware reports the VI window mode.
1204          * Medford2 has a variable VI window size (8K, 16K or 64K).
1205          * Medford and Huntington have a fixed 8K VI window size.
1206          */
1207         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V3_OUT_LEN) {
1208                 uint8_t mode =
1209                     MCDI_OUT_BYTE(req, GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE);
1210
1211                 switch (mode) {
1212                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_8K:
1213                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_8K;
1214                         break;
1215                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_16K:
1216                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_16K;
1217                         break;
1218                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_64K:
1219                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_64K;
1220                         break;
1221                 default:
1222                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_INVALID;
1223                         break;
1224                 }
1225         } else if ((enp->en_family == EFX_FAMILY_HUNTINGTON) ||
1226                     (enp->en_family == EFX_FAMILY_MEDFORD)) {
1227                 /* Huntington and Medford have fixed 8K window size */
1228                 encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_8K;
1229         } else {
1230                 encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_INVALID;
1231         }
1232
1233         /* Check if firmware supports extended MAC stats. */
1234         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V4_OUT_LEN) {
1235                 /* Extended stats buffer supported */
1236                 encp->enc_mac_stats_nstats = MCDI_OUT_WORD(req,
1237                     GET_CAPABILITIES_V4_OUT_MAC_STATS_NUM_STATS);
1238         } else {
1239                 /* Use Siena-compatible legacy MAC stats */
1240                 encp->enc_mac_stats_nstats = MC_CMD_MAC_NSTATS;
1241         }
1242
1243         if (encp->enc_mac_stats_nstats >= MC_CMD_MAC_NSTATS_V2)
1244                 encp->enc_fec_counters = B_TRUE;
1245         else
1246                 encp->enc_fec_counters = B_FALSE;
1247
1248         /* Check if the firmware provides head-of-line blocking counters */
1249         if (CAP_FLAGS2(req, RXDP_HLB_IDLE))
1250                 encp->enc_hlb_counters = B_TRUE;
1251         else
1252                 encp->enc_hlb_counters = B_FALSE;
1253
1254         if (CAP_FLAGS1(req, RX_RSS_LIMITED)) {
1255                 /* Only one exclusive RSS context is available per port. */
1256                 encp->enc_rx_scale_max_exclusive_contexts = 1;
1257
1258                 switch (enp->en_family) {
1259                 case EFX_FAMILY_MEDFORD2:
1260                         encp->enc_rx_scale_hash_alg_mask =
1261                             (1U << EFX_RX_HASHALG_TOEPLITZ);
1262                         break;
1263
1264                 case EFX_FAMILY_MEDFORD:
1265                 case EFX_FAMILY_HUNTINGTON:
1266                         /*
1267                          * Packed stream firmware variant maintains a
1268                          * non-standard algorithm for hash computation.
1269                          * It implies explicit XORing together
1270                          * source + destination IP addresses (or last
1271                          * four bytes in the case of IPv6) and using the
1272                          * resulting value as the input to a Toeplitz hash.
1273                          */
1274                         encp->enc_rx_scale_hash_alg_mask =
1275                             (1U << EFX_RX_HASHALG_PACKED_STREAM);
1276                         break;
1277
1278                 default:
1279                         rc = EINVAL;
1280                         goto fail5;
1281                 }
1282
1283                 /* Port numbers cannot contribute to the hash value */
1284                 encp->enc_rx_scale_l4_hash_supported = B_FALSE;
1285         } else {
1286                 /*
1287                  * Maximum number of exclusive RSS contexts.
1288                  * EF10 hardware supports 64 in total, but 6 are reserved
1289                  * for shared contexts. They are a global resource so
1290                  * not all may be available.
1291                  */
1292                 encp->enc_rx_scale_max_exclusive_contexts = 64 - 6;
1293
1294                 encp->enc_rx_scale_hash_alg_mask =
1295                     (1U << EFX_RX_HASHALG_TOEPLITZ);
1296
1297                 /*
1298                  * It is possible to use port numbers as
1299                  * the input data for hash computation.
1300                  */
1301                 encp->enc_rx_scale_l4_hash_supported = B_TRUE;
1302         }
1303         /* Check if the firmware supports "FLAG" and "MARK" filter actions */
1304         if (CAP_FLAGS2(req, FILTER_ACTION_FLAG))
1305                 encp->enc_filter_action_flag_supported = B_TRUE;
1306         else
1307                 encp->enc_filter_action_flag_supported = B_FALSE;
1308
1309         if (CAP_FLAGS2(req, FILTER_ACTION_MARK))
1310                 encp->enc_filter_action_mark_supported = B_TRUE;
1311         else
1312                 encp->enc_filter_action_mark_supported = B_FALSE;
1313
1314         /* Get maximum supported value for "MARK" filter action */
1315         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V5_OUT_LEN)
1316                 encp->enc_filter_action_mark_max = MCDI_OUT_DWORD(req,
1317                     GET_CAPABILITIES_V5_OUT_FILTER_ACTION_MARK_MAX);
1318         else
1319                 encp->enc_filter_action_mark_max = 0;
1320
1321 #undef CAP_FLAGS1
1322 #undef CAP_FLAGS2
1323
1324         return (0);
1325
1326 fail5:
1327         EFSYS_PROBE(fail5);
1328 fail4:
1329         EFSYS_PROBE(fail4);
1330 fail3:
1331         EFSYS_PROBE(fail3);
1332 fail2:
1333         EFSYS_PROBE(fail2);
1334 fail1:
1335         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1336
1337         return (rc);
1338 }
1339
1340
1341 #define EF10_LEGACY_PF_PRIVILEGE_MASK                                   \
1342         (MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN                     |       \
1343         MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK                       |       \
1344         MC_CMD_PRIVILEGE_MASK_IN_GRP_ONLOAD                     |       \
1345         MC_CMD_PRIVILEGE_MASK_IN_GRP_PTP                        |       \
1346         MC_CMD_PRIVILEGE_MASK_IN_GRP_INSECURE_FILTERS           |       \
1347         MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING               |       \
1348         MC_CMD_PRIVILEGE_MASK_IN_GRP_UNICAST                    |       \
1349         MC_CMD_PRIVILEGE_MASK_IN_GRP_MULTICAST                  |       \
1350         MC_CMD_PRIVILEGE_MASK_IN_GRP_BROADCAST                  |       \
1351         MC_CMD_PRIVILEGE_MASK_IN_GRP_ALL_MULTICAST              |       \
1352         MC_CMD_PRIVILEGE_MASK_IN_GRP_PROMISCUOUS)
1353
1354 #define EF10_LEGACY_VF_PRIVILEGE_MASK   0
1355
1356
1357         __checkReturn           efx_rc_t
1358 ef10_get_privilege_mask(
1359         __in                    efx_nic_t *enp,
1360         __out                   uint32_t *maskp)
1361 {
1362         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1363         uint32_t mask;
1364         efx_rc_t rc;
1365
1366         if ((rc = efx_mcdi_privilege_mask(enp, encp->enc_pf, encp->enc_vf,
1367                                             &mask)) != 0) {
1368                 if (rc != ENOTSUP)
1369                         goto fail1;
1370
1371                 /* Fallback for old firmware without privilege mask support */
1372                 if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1373                         /* Assume PF has admin privilege */
1374                         mask = EF10_LEGACY_PF_PRIVILEGE_MASK;
1375                 } else {
1376                         /* VF is always unprivileged by default */
1377                         mask = EF10_LEGACY_VF_PRIVILEGE_MASK;
1378                 }
1379         }
1380
1381         *maskp = mask;
1382
1383         return (0);
1384
1385 fail1:
1386         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1387
1388         return (rc);
1389 }
1390
1391
1392 /*
1393  * Table of mapping schemes from port number to external number.
1394  *
1395  * Each port number ultimately corresponds to a connector: either as part of
1396  * a cable assembly attached to a module inserted in an SFP+/QSFP+ cage on
1397  * the board, or fixed to the board (e.g. 10GBASE-T magjack on SFN5121T
1398  * "Salina"). In general:
1399  *
1400  * Port number (0-based)
1401  *     |
1402  *   port mapping (n:1)
1403  *     |
1404  *     v
1405  * External port number (normally 1-based)
1406  *     |
1407  *   fixed (1:1) or cable assembly (1:m)
1408  *     |
1409  *     v
1410  * Connector
1411  *
1412  * The external numbering refers to the cages or magjacks on the board,
1413  * as visibly annotated on the board or back panel. This table describes
1414  * how to determine which external cage/magjack corresponds to the port
1415  * numbers used by the driver.
1416  *
1417  * The count of adjacent port numbers that map to each external number,
1418  * and the offset in the numbering, is determined by the chip family and
1419  * current port mode.
1420  *
1421  * For the Huntington family, the current port mode cannot be discovered,
1422  * but a single mapping is used by all modes for a given chip variant,
1423  * so the mapping used is instead the last match in the table to the full
1424  * set of port modes to which the NIC can be configured. Therefore the
1425  * ordering of entries in the mapping table is significant.
1426  */
1427 static struct ef10_external_port_map_s {
1428         efx_family_t    family;
1429         uint32_t        modes_mask;
1430         int32_t         count;
1431         int32_t         offset;
1432 }       __ef10_external_port_mappings[] = {
1433         /*
1434          * Modes used by Huntington family controllers where each port
1435          * number maps to a separate cage.
1436          * SFN7x22F (Torino):
1437          *      port 0 -> cage 1
1438          *      port 1 -> cage 2
1439          * SFN7xx4F (Pavia):
1440          *      port 0 -> cage 1
1441          *      port 1 -> cage 2
1442          *      port 2 -> cage 3
1443          *      port 3 -> cage 4
1444          */
1445         {
1446                 EFX_FAMILY_HUNTINGTON,
1447                 (1U << TLV_PORT_MODE_10G) |                     /* mode 0 */
1448                 (1U << TLV_PORT_MODE_10G_10G) |                 /* mode 2 */
1449                 (1U << TLV_PORT_MODE_10G_10G_10G_10G),          /* mode 4 */
1450                 1,      /* ports per cage */
1451                 1       /* first cage */
1452         },
1453         /*
1454          * Modes which for Huntington identify a chip variant where 2
1455          * adjacent port numbers map to each cage.
1456          * SFN7x42Q (Monza):
1457          *      port 0 -> cage 1
1458          *      port 1 -> cage 1
1459          *      port 2 -> cage 2
1460          *      port 3 -> cage 2
1461          */
1462         {
1463                 EFX_FAMILY_HUNTINGTON,
1464                 (1U << TLV_PORT_MODE_40G) |                     /* mode 1 */
1465                 (1U << TLV_PORT_MODE_40G_40G) |                 /* mode 3 */
1466                 (1U << TLV_PORT_MODE_40G_10G_10G) |             /* mode 6 */
1467                 (1U << TLV_PORT_MODE_10G_10G_40G),              /* mode 7 */
1468                 2,      /* ports per cage */
1469                 1       /* first cage */
1470         },
1471         /*
1472          * Modes that on Medford allocate each port number to a separate
1473          * cage.
1474          *      port 0 -> cage 1
1475          *      port 1 -> cage 2
1476          *      port 2 -> cage 3
1477          *      port 3 -> cage 4
1478          */
1479         {
1480                 EFX_FAMILY_MEDFORD,
1481                 (1U << TLV_PORT_MODE_10G) |                     /* mode 0 */
1482                 (1U << TLV_PORT_MODE_10G_10G),                  /* mode 2 */
1483                 1,      /* ports per cage */
1484                 1       /* first cage */
1485         },
1486         /*
1487          * Modes that on Medford allocate 2 adjacent port numbers to each
1488          * cage.
1489          *      port 0 -> cage 1
1490          *      port 1 -> cage 1
1491          *      port 2 -> cage 2
1492          *      port 3 -> cage 2
1493          */
1494         {
1495                 EFX_FAMILY_MEDFORD,
1496                 (1U << TLV_PORT_MODE_40G) |                     /* mode 1 */
1497                 (1U << TLV_PORT_MODE_40G_40G) |                 /* mode 3 */
1498                 (1U << TLV_PORT_MODE_40G_10G_10G) |             /* mode 6 */
1499                 (1U << TLV_PORT_MODE_10G_10G_40G) |             /* mode 7 */
1500                 /* Do not use 10G_10G_10G_10G_Q1_Q2 (see bug63270) */
1501                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q1_Q2),    /* mode 9 */
1502                 2,      /* ports per cage */
1503                 1       /* first cage */
1504         },
1505         /*
1506          * Modes that on Medford allocate 4 adjacent port numbers to each
1507          * connector, starting on cage 1.
1508          *      port 0 -> cage 1
1509          *      port 1 -> cage 1
1510          *      port 2 -> cage 1
1511          *      port 3 -> cage 1
1512          */
1513         {
1514                 EFX_FAMILY_MEDFORD,
1515                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q) |       /* mode 5 */
1516                 /* Do not use 10G_10G_10G_10G_Q1 (see bug63270) */
1517                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q1),       /* mode 4 */
1518                 4,      /* ports per cage */
1519                 1       /* first cage */
1520         },
1521         /*
1522          * Modes that on Medford allocate 4 adjacent port numbers to each
1523          * connector, starting on cage 2.
1524          *      port 0 -> cage 2
1525          *      port 1 -> cage 2
1526          *      port 2 -> cage 2
1527          *      port 3 -> cage 2
1528          */
1529         {
1530                 EFX_FAMILY_MEDFORD,
1531                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q2),       /* mode 8 */
1532                 4,      /* ports per cage */
1533                 2       /* first cage */
1534         },
1535         /*
1536          * Modes that on Medford2 allocate each port number to a separate
1537          * cage.
1538          *      port 0 -> cage 1
1539          *      port 1 -> cage 2
1540          *      port 2 -> cage 3
1541          *      port 3 -> cage 4
1542          */
1543         {
1544                 EFX_FAMILY_MEDFORD2,
1545                 (1U << TLV_PORT_MODE_1x1_NA) |                  /* mode 0 */
1546                 (1U << TLV_PORT_MODE_1x4_NA) |                  /* mode 1 */
1547                 (1U << TLV_PORT_MODE_1x1_1x1) |                 /* mode 2 */
1548                 (1U << TLV_PORT_MODE_1x2_NA) |                  /* mode 10 */
1549                 (1U << TLV_PORT_MODE_1x2_1x2) |                 /* mode 12 */
1550                 (1U << TLV_PORT_MODE_1x4_1x2) |                 /* mode 15 */
1551                 (1U << TLV_PORT_MODE_1x2_1x4),                  /* mode 16 */
1552                 1,      /* ports per cage */
1553                 1       /* first cage */
1554         },
1555         /*
1556          * FIXME: Some port modes are not representable in this mapping:
1557          *  - TLV_PORT_MODE_1x2_2x1 (mode 17):
1558          *      port 0 -> cage 1
1559          *      port 1 -> cage 2
1560          *      port 2 -> cage 2
1561          */
1562         /*
1563          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1564          * cage, starting on cage 1.
1565          *      port 0 -> cage 1
1566          *      port 1 -> cage 1
1567          *      port 2 -> cage 2
1568          *      port 3 -> cage 2
1569          */
1570         {
1571                 EFX_FAMILY_MEDFORD2,
1572                 (1U << TLV_PORT_MODE_1x4_1x4) |                 /* mode 3 */
1573                 (1U << TLV_PORT_MODE_2x1_2x1) |                 /* mode 4 */
1574                 (1U << TLV_PORT_MODE_1x4_2x1) |                 /* mode 6 */
1575                 (1U << TLV_PORT_MODE_2x1_1x4) |                 /* mode 7 */
1576                 (1U << TLV_PORT_MODE_2x2_NA) |                  /* mode 13 */
1577                 (1U << TLV_PORT_MODE_2x1_1x2),                  /* mode 18 */
1578                 2,      /* ports per cage */
1579                 1       /* first cage */
1580         },
1581         /*
1582          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1583          * cage, starting on cage 2.
1584          *      port 0 -> cage 2
1585          *      port 1 -> cage 2
1586          */
1587         {
1588                 EFX_FAMILY_MEDFORD2,
1589                 (1U << TLV_PORT_MODE_NA_2x2),                   /* mode 14 */
1590                 2,      /* ports per cage */
1591                 2       /* first cage */
1592         },
1593         /*
1594          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1595          * connector, starting on cage 1.
1596          *      port 0 -> cage 1
1597          *      port 1 -> cage 1
1598          *      port 2 -> cage 1
1599          *      port 3 -> cage 1
1600          */
1601         {
1602                 EFX_FAMILY_MEDFORD2,
1603                 (1U << TLV_PORT_MODE_4x1_NA),                   /* mode 5 */
1604                 4,      /* ports per cage */
1605                 1       /* first cage */
1606         },
1607         /*
1608          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1609          * connector, starting on cage 2.
1610          *      port 0 -> cage 2
1611          *      port 1 -> cage 2
1612          *      port 2 -> cage 2
1613          *      port 3 -> cage 2
1614          */
1615         {
1616                 EFX_FAMILY_MEDFORD2,
1617                 (1U << TLV_PORT_MODE_NA_4x1) |                  /* mode 8 */
1618                 (1U << TLV_PORT_MODE_NA_1x2),                   /* mode 11 */
1619                 4,      /* ports per cage */
1620                 2       /* first cage */
1621         },
1622 };
1623
1624 static  __checkReturn   efx_rc_t
1625 ef10_external_port_mapping(
1626         __in            efx_nic_t *enp,
1627         __in            uint32_t port,
1628         __out           uint8_t *external_portp)
1629 {
1630         efx_rc_t rc;
1631         int i;
1632         uint32_t port_modes;
1633         uint32_t matches;
1634         uint32_t current;
1635         int32_t count = 1; /* Default 1-1 mapping */
1636         int32_t offset = 1; /* Default starting external port number */
1637
1638         if ((rc = efx_mcdi_get_port_modes(enp, &port_modes, &current)) != 0) {
1639                 /*
1640                  * No current port mode information (i.e. Huntington)
1641                  * - infer mapping from available modes
1642                  */
1643                 if ((rc = efx_mcdi_get_port_modes(enp,
1644                             &port_modes, NULL)) != 0) {
1645                         /*
1646                          * No port mode information available
1647                          * - use default mapping
1648                          */
1649                         goto out;
1650                 }
1651         } else {
1652                 /* Only need to scan the current mode */
1653                 port_modes = 1 << current;
1654         }
1655
1656         /*
1657          * Infer the internal port -> external number mapping from
1658          * the possible port modes for this NIC.
1659          */
1660         for (i = 0; i < EFX_ARRAY_SIZE(__ef10_external_port_mappings); ++i) {
1661                 struct ef10_external_port_map_s *eepmp =
1662                     &__ef10_external_port_mappings[i];
1663                 if (eepmp->family != enp->en_family)
1664                         continue;
1665                 matches = (eepmp->modes_mask & port_modes);
1666                 if (matches != 0) {
1667                         /*
1668                          * Some modes match. For some Huntington boards
1669                          * there will be multiple matches. The mapping on the
1670                          * last match is used.
1671                          */
1672                         count = eepmp->count;
1673                         offset = eepmp->offset;
1674                         port_modes &= ~matches;
1675                 }
1676         }
1677
1678         if (port_modes != 0) {
1679                 /* Some advertised modes are not supported */
1680                 rc = ENOTSUP;
1681                 goto fail1;
1682         }
1683
1684 out:
1685         /*
1686          * Scale as required by last matched mode and then convert to
1687          * correctly offset numbering
1688          */
1689         *external_portp = (uint8_t)((port / count) + offset);
1690         return (0);
1691
1692 fail1:
1693         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1694
1695         return (rc);
1696 }
1697
1698 static  __checkReturn   efx_rc_t
1699 ef10_nic_board_cfg(
1700         __in            efx_nic_t *enp)
1701 {
1702         const efx_nic_ops_t *enop = enp->en_enop;
1703         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
1704         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1705         ef10_link_state_t els;
1706         efx_port_t *epp = &(enp->en_port);
1707         uint32_t board_type = 0;
1708         uint32_t base, nvec;
1709         uint32_t port;
1710         uint32_t mask;
1711         uint32_t pf;
1712         uint32_t vf;
1713         uint8_t mac_addr[6] = { 0 };
1714         efx_rc_t rc;
1715
1716         /* Get the (zero-based) MCDI port number */
1717         if ((rc = efx_mcdi_get_port_assignment(enp, &port)) != 0)
1718                 goto fail1;
1719
1720         /* EFX MCDI interface uses one-based port numbers */
1721         emip->emi_port = port + 1;
1722
1723         if ((rc = ef10_external_port_mapping(enp, port,
1724                     &encp->enc_external_port)) != 0)
1725                 goto fail2;
1726
1727         /*
1728          * Get PCIe function number from firmware (used for
1729          * per-function privilege and dynamic config info).
1730          *  - PCIe PF: pf = PF number, vf = 0xffff.
1731          *  - PCIe VF: pf = parent PF, vf = VF number.
1732          */
1733         if ((rc = efx_mcdi_get_function_info(enp, &pf, &vf)) != 0)
1734                 goto fail3;
1735
1736         encp->enc_pf = pf;
1737         encp->enc_vf = vf;
1738
1739         /* MAC address for this function */
1740         if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1741                 rc = efx_mcdi_get_mac_address_pf(enp, mac_addr);
1742 #if EFSYS_OPT_ALLOW_UNCONFIGURED_NIC
1743                 /*
1744                  * Disable static config checking, ONLY for manufacturing test
1745                  * and setup at the factory, to allow the static config to be
1746                  * installed.
1747                  */
1748 #else /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1749                 if ((rc == 0) && (mac_addr[0] & 0x02)) {
1750                         /*
1751                          * If the static config does not include a global MAC
1752                          * address pool then the board may return a locally
1753                          * administered MAC address (this should only happen on
1754                          * incorrectly programmed boards).
1755                          */
1756                         rc = EINVAL;
1757                 }
1758 #endif /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1759         } else {
1760                 rc = efx_mcdi_get_mac_address_vf(enp, mac_addr);
1761         }
1762         if (rc != 0)
1763                 goto fail4;
1764
1765         EFX_MAC_ADDR_COPY(encp->enc_mac_addr, mac_addr);
1766
1767         /* Board configuration (legacy) */
1768         rc = efx_mcdi_get_board_cfg(enp, &board_type, NULL, NULL);
1769         if (rc != 0) {
1770                 /* Unprivileged functions may not be able to read board cfg */
1771                 if (rc == EACCES)
1772                         board_type = 0;
1773                 else
1774                         goto fail5;
1775         }
1776
1777         encp->enc_board_type = board_type;
1778         encp->enc_clk_mult = 1; /* not used for EF10 */
1779
1780         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
1781         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
1782                 goto fail6;
1783
1784         /* Obtain the default PHY advertised capabilities */
1785         if ((rc = ef10_phy_get_link(enp, &els)) != 0)
1786                 goto fail7;
1787         epp->ep_default_adv_cap_mask = els.els_adv_cap_mask;
1788         epp->ep_adv_cap_mask = els.els_adv_cap_mask;
1789
1790         /* Check capabilities of running datapath firmware */
1791         if ((rc = ef10_get_datapath_caps(enp)) != 0)
1792                 goto fail8;
1793
1794         /* Alignment for WPTR updates */
1795         encp->enc_rx_push_align = EF10_RX_WPTR_ALIGN;
1796
1797         encp->enc_tx_dma_desc_size_max = EFX_MASK32(ESF_DZ_RX_KER_BYTE_CNT);
1798         /* No boundary crossing limits */
1799         encp->enc_tx_dma_desc_boundary = 0;
1800
1801         /*
1802          * Maximum number of bytes into the frame the TCP header can start for
1803          * firmware assisted TSO to work.
1804          */
1805         encp->enc_tx_tso_tcp_header_offset_limit = EF10_TCP_HEADER_OFFSET_LIMIT;
1806
1807         /*
1808          * Set resource limits for MC_CMD_ALLOC_VIS. Note that we cannot use
1809          * MC_CMD_GET_RESOURCE_LIMITS here as that reports the available
1810          * resources (allocated to this PCIe function), which is zero until
1811          * after we have allocated VIs.
1812          */
1813         encp->enc_evq_limit = 1024;
1814         encp->enc_rxq_limit = EFX_RXQ_LIMIT_TARGET;
1815         encp->enc_txq_limit = EFX_TXQ_LIMIT_TARGET;
1816
1817         encp->enc_buftbl_limit = 0xFFFFFFFF;
1818
1819         /* Get interrupt vector limits */
1820         if ((rc = efx_mcdi_get_vector_cfg(enp, &base, &nvec, NULL)) != 0) {
1821                 if (EFX_PCI_FUNCTION_IS_PF(encp))
1822                         goto fail9;
1823
1824                 /* Ignore error (cannot query vector limits from a VF). */
1825                 base = 0;
1826                 nvec = 1024;
1827         }
1828         encp->enc_intr_vec_base = base;
1829         encp->enc_intr_limit = nvec;
1830
1831         /*
1832          * Get the current privilege mask. Note that this may be modified
1833          * dynamically, so this value is informational only. DO NOT use
1834          * the privilege mask to check for sufficient privileges, as that
1835          * can result in time-of-check/time-of-use bugs.
1836          */
1837         if ((rc = ef10_get_privilege_mask(enp, &mask)) != 0)
1838                 goto fail10;
1839         encp->enc_privilege_mask = mask;
1840
1841         /* Get remaining controller-specific board config */
1842         if ((rc = enop->eno_board_cfg(enp)) != 0)
1843                 if (rc != EACCES)
1844                         goto fail11;
1845
1846         return (0);
1847
1848 fail11:
1849         EFSYS_PROBE(fail11);
1850 fail10:
1851         EFSYS_PROBE(fail10);
1852 fail9:
1853         EFSYS_PROBE(fail9);
1854 fail8:
1855         EFSYS_PROBE(fail8);
1856 fail7:
1857         EFSYS_PROBE(fail7);
1858 fail6:
1859         EFSYS_PROBE(fail6);
1860 fail5:
1861         EFSYS_PROBE(fail5);
1862 fail4:
1863         EFSYS_PROBE(fail4);
1864 fail3:
1865         EFSYS_PROBE(fail3);
1866 fail2:
1867         EFSYS_PROBE(fail2);
1868 fail1:
1869         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1870
1871         return (rc);
1872 }
1873
1874         __checkReturn   efx_rc_t
1875 ef10_nic_probe(
1876         __in            efx_nic_t *enp)
1877 {
1878         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1879         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1880         efx_rc_t rc;
1881
1882         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
1883             enp->en_family == EFX_FAMILY_MEDFORD ||
1884             enp->en_family == EFX_FAMILY_MEDFORD2);
1885
1886         /* Read and clear any assertion state */
1887         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
1888                 goto fail1;
1889
1890         /* Exit the assertion handler */
1891         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
1892                 if (rc != EACCES)
1893                         goto fail2;
1894
1895         if ((rc = efx_mcdi_drv_attach(enp, B_TRUE)) != 0)
1896                 goto fail3;
1897
1898         if ((rc = ef10_nic_board_cfg(enp)) != 0)
1899                 goto fail4;
1900
1901         /*
1902          * Set default driver config limits (based on board config).
1903          *
1904          * FIXME: For now allocate a fixed number of VIs which is likely to be
1905          * sufficient and small enough to allow multiple functions on the same
1906          * port.
1907          */
1908         edcp->edc_min_vi_count = edcp->edc_max_vi_count =
1909             MIN(128, MAX(encp->enc_rxq_limit, encp->enc_txq_limit));
1910
1911         /* The client driver must configure and enable PIO buffer support */
1912         edcp->edc_max_piobuf_count = 0;
1913         edcp->edc_pio_alloc_size = 0;
1914
1915 #if EFSYS_OPT_MAC_STATS
1916         /* Wipe the MAC statistics */
1917         if ((rc = efx_mcdi_mac_stats_clear(enp)) != 0)
1918                 goto fail5;
1919 #endif
1920
1921 #if EFSYS_OPT_LOOPBACK
1922         if ((rc = efx_mcdi_get_loopback_modes(enp)) != 0)
1923                 goto fail6;
1924 #endif
1925
1926 #if EFSYS_OPT_MON_STATS
1927         if ((rc = mcdi_mon_cfg_build(enp)) != 0) {
1928                 /* Unprivileged functions do not have access to sensors */
1929                 if (rc != EACCES)
1930                         goto fail7;
1931         }
1932 #endif
1933
1934         encp->enc_features = enp->en_features;
1935
1936         return (0);
1937
1938 #if EFSYS_OPT_MON_STATS
1939 fail7:
1940         EFSYS_PROBE(fail7);
1941 #endif
1942 #if EFSYS_OPT_LOOPBACK
1943 fail6:
1944         EFSYS_PROBE(fail6);
1945 #endif
1946 #if EFSYS_OPT_MAC_STATS
1947 fail5:
1948         EFSYS_PROBE(fail5);
1949 #endif
1950 fail4:
1951         EFSYS_PROBE(fail4);
1952 fail3:
1953         EFSYS_PROBE(fail3);
1954 fail2:
1955         EFSYS_PROBE(fail2);
1956 fail1:
1957         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1958
1959         return (rc);
1960 }
1961
1962         __checkReturn   efx_rc_t
1963 ef10_nic_set_drv_limits(
1964         __inout         efx_nic_t *enp,
1965         __in            efx_drv_limits_t *edlp)
1966 {
1967         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1968         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1969         uint32_t min_evq_count, max_evq_count;
1970         uint32_t min_rxq_count, max_rxq_count;
1971         uint32_t min_txq_count, max_txq_count;
1972         efx_rc_t rc;
1973
1974         if (edlp == NULL) {
1975                 rc = EINVAL;
1976                 goto fail1;
1977         }
1978
1979         /* Get minimum required and maximum usable VI limits */
1980         min_evq_count = MIN(edlp->edl_min_evq_count, encp->enc_evq_limit);
1981         min_rxq_count = MIN(edlp->edl_min_rxq_count, encp->enc_rxq_limit);
1982         min_txq_count = MIN(edlp->edl_min_txq_count, encp->enc_txq_limit);
1983
1984         edcp->edc_min_vi_count =
1985             MAX(min_evq_count, MAX(min_rxq_count, min_txq_count));
1986
1987         max_evq_count = MIN(edlp->edl_max_evq_count, encp->enc_evq_limit);
1988         max_rxq_count = MIN(edlp->edl_max_rxq_count, encp->enc_rxq_limit);
1989         max_txq_count = MIN(edlp->edl_max_txq_count, encp->enc_txq_limit);
1990
1991         edcp->edc_max_vi_count =
1992             MAX(max_evq_count, MAX(max_rxq_count, max_txq_count));
1993
1994         /*
1995          * Check limits for sub-allocated piobuf blocks.
1996          * PIO is optional, so don't fail if the limits are incorrect.
1997          */
1998         if ((encp->enc_piobuf_size == 0) ||
1999             (encp->enc_piobuf_limit == 0) ||
2000             (edlp->edl_min_pio_alloc_size == 0) ||
2001             (edlp->edl_min_pio_alloc_size > encp->enc_piobuf_size)) {
2002                 /* Disable PIO */
2003                 edcp->edc_max_piobuf_count = 0;
2004                 edcp->edc_pio_alloc_size = 0;
2005         } else {
2006                 uint32_t blk_size, blk_count, blks_per_piobuf;
2007
2008                 blk_size =
2009                     MAX(edlp->edl_min_pio_alloc_size,
2010                             encp->enc_piobuf_min_alloc_size);
2011
2012                 blks_per_piobuf = encp->enc_piobuf_size / blk_size;
2013                 EFSYS_ASSERT3U(blks_per_piobuf, <=, 32);
2014
2015                 blk_count = (encp->enc_piobuf_limit * blks_per_piobuf);
2016
2017                 /* A zero max pio alloc count means unlimited */
2018                 if ((edlp->edl_max_pio_alloc_count > 0) &&
2019                     (edlp->edl_max_pio_alloc_count < blk_count)) {
2020                         blk_count = edlp->edl_max_pio_alloc_count;
2021                 }
2022
2023                 edcp->edc_pio_alloc_size = blk_size;
2024                 edcp->edc_max_piobuf_count =
2025                     (blk_count + (blks_per_piobuf - 1)) / blks_per_piobuf;
2026         }
2027
2028         return (0);
2029
2030 fail1:
2031         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2032
2033         return (rc);
2034 }
2035
2036
2037         __checkReturn   efx_rc_t
2038 ef10_nic_reset(
2039         __in            efx_nic_t *enp)
2040 {
2041         efx_mcdi_req_t req;
2042         uint8_t payload[MAX(MC_CMD_ENTITY_RESET_IN_LEN,
2043                             MC_CMD_ENTITY_RESET_OUT_LEN)];
2044         efx_rc_t rc;
2045
2046         /* ef10_nic_reset() is called to recover from BADASSERT failures. */
2047         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
2048                 goto fail1;
2049         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
2050                 goto fail2;
2051
2052         (void) memset(payload, 0, sizeof (payload));
2053         req.emr_cmd = MC_CMD_ENTITY_RESET;
2054         req.emr_in_buf = payload;
2055         req.emr_in_length = MC_CMD_ENTITY_RESET_IN_LEN;
2056         req.emr_out_buf = payload;
2057         req.emr_out_length = MC_CMD_ENTITY_RESET_OUT_LEN;
2058
2059         MCDI_IN_POPULATE_DWORD_1(req, ENTITY_RESET_IN_FLAG,
2060             ENTITY_RESET_IN_FUNCTION_RESOURCE_RESET, 1);
2061
2062         efx_mcdi_execute(enp, &req);
2063
2064         if (req.emr_rc != 0) {
2065                 rc = req.emr_rc;
2066                 goto fail3;
2067         }
2068
2069         /* Clear RX/TX DMA queue errors */
2070         enp->en_reset_flags &= ~(EFX_RESET_RXQ_ERR | EFX_RESET_TXQ_ERR);
2071
2072         return (0);
2073
2074 fail3:
2075         EFSYS_PROBE(fail3);
2076 fail2:
2077         EFSYS_PROBE(fail2);
2078 fail1:
2079         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2080
2081         return (rc);
2082 }
2083
2084         __checkReturn   efx_rc_t
2085 ef10_nic_init(
2086         __in            efx_nic_t *enp)
2087 {
2088         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
2089         uint32_t min_vi_count, max_vi_count;
2090         uint32_t vi_count, vi_base, vi_shift;
2091         uint32_t i;
2092         uint32_t retry;
2093         uint32_t delay_us;
2094         uint32_t vi_window_size;
2095         efx_rc_t rc;
2096
2097         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2098             enp->en_family == EFX_FAMILY_MEDFORD ||
2099             enp->en_family == EFX_FAMILY_MEDFORD2);
2100
2101         /* Enable reporting of some events (e.g. link change) */
2102         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
2103                 goto fail1;
2104
2105         /* Allocate (optional) on-chip PIO buffers */
2106         ef10_nic_alloc_piobufs(enp, edcp->edc_max_piobuf_count);
2107
2108         /*
2109          * For best performance, PIO writes should use a write-combined
2110          * (WC) memory mapping. Using a separate WC mapping for the PIO
2111          * aperture of each VI would be a burden to drivers (and not
2112          * possible if the host page size is >4Kbyte).
2113          *
2114          * To avoid this we use a single uncached (UC) mapping for VI
2115          * register access, and a single WC mapping for extra VIs used
2116          * for PIO writes.
2117          *
2118          * Each piobuf must be linked to a VI in the WC mapping, and to
2119          * each VI that is using a sub-allocated block from the piobuf.
2120          */
2121         min_vi_count = edcp->edc_min_vi_count;
2122         max_vi_count =
2123             edcp->edc_max_vi_count + enp->en_arch.ef10.ena_piobuf_count;
2124
2125         /* Ensure that the previously attached driver's VIs are freed */
2126         if ((rc = efx_mcdi_free_vis(enp)) != 0)
2127                 goto fail2;
2128
2129         /*
2130          * Reserve VI resources (EVQ+RXQ+TXQ) for this PCIe function. If this
2131          * fails then retrying the request for fewer VI resources may succeed.
2132          */
2133         vi_count = 0;
2134         if ((rc = efx_mcdi_alloc_vis(enp, min_vi_count, max_vi_count,
2135                     &vi_base, &vi_count, &vi_shift)) != 0)
2136                 goto fail3;
2137
2138         EFSYS_PROBE2(vi_alloc, uint32_t, vi_base, uint32_t, vi_count);
2139
2140         if (vi_count < min_vi_count) {
2141                 rc = ENOMEM;
2142                 goto fail4;
2143         }
2144
2145         enp->en_arch.ef10.ena_vi_base = vi_base;
2146         enp->en_arch.ef10.ena_vi_count = vi_count;
2147         enp->en_arch.ef10.ena_vi_shift = vi_shift;
2148
2149         if (vi_count < min_vi_count + enp->en_arch.ef10.ena_piobuf_count) {
2150                 /* Not enough extra VIs to map piobufs */
2151                 ef10_nic_free_piobufs(enp);
2152         }
2153
2154         enp->en_arch.ef10.ena_pio_write_vi_base =
2155             vi_count - enp->en_arch.ef10.ena_piobuf_count;
2156
2157         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, !=,
2158             EFX_VI_WINDOW_SHIFT_INVALID);
2159         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, <=,
2160             EFX_VI_WINDOW_SHIFT_64K);
2161         vi_window_size = 1U << enp->en_nic_cfg.enc_vi_window_shift;
2162
2163         /* Save UC memory mapping details */
2164         enp->en_arch.ef10.ena_uc_mem_map_offset = 0;
2165         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2166                 enp->en_arch.ef10.ena_uc_mem_map_size =
2167                     (vi_window_size *
2168                     enp->en_arch.ef10.ena_pio_write_vi_base);
2169         } else {
2170                 enp->en_arch.ef10.ena_uc_mem_map_size =
2171                     (vi_window_size *
2172                     enp->en_arch.ef10.ena_vi_count);
2173         }
2174
2175         /* Save WC memory mapping details */
2176         enp->en_arch.ef10.ena_wc_mem_map_offset =
2177             enp->en_arch.ef10.ena_uc_mem_map_offset +
2178             enp->en_arch.ef10.ena_uc_mem_map_size;
2179
2180         enp->en_arch.ef10.ena_wc_mem_map_size =
2181             (vi_window_size *
2182             enp->en_arch.ef10.ena_piobuf_count);
2183
2184         /* Link piobufs to extra VIs in WC mapping */
2185         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2186                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2187                         rc = efx_mcdi_link_piobuf(enp,
2188                             enp->en_arch.ef10.ena_pio_write_vi_base + i,
2189                             enp->en_arch.ef10.ena_piobuf_handle[i]);
2190                         if (rc != 0)
2191                                 break;
2192                 }
2193         }
2194
2195         /*
2196          * Allocate a vAdaptor attached to our upstream vPort/pPort.
2197          *
2198          * On a VF, this may fail with MC_CMD_ERR_NO_EVB_PORT (ENOENT) if the PF
2199          * driver has yet to bring up the EVB port. See bug 56147. In this case,
2200          * retry the request several times after waiting a while. The wait time
2201          * between retries starts small (10ms) and exponentially increases.
2202          * Total wait time is a little over two seconds. Retry logic in the
2203          * client driver may mean this whole loop is repeated if it continues to
2204          * fail.
2205          */
2206         retry = 0;
2207         delay_us = 10000;
2208         while ((rc = efx_mcdi_vadaptor_alloc(enp, EVB_PORT_ID_ASSIGNED)) != 0) {
2209                 if (EFX_PCI_FUNCTION_IS_PF(&enp->en_nic_cfg) ||
2210                     (rc != ENOENT)) {
2211                         /*
2212                          * Do not retry alloc for PF, or for other errors on
2213                          * a VF.
2214                          */
2215                         goto fail5;
2216                 }
2217
2218                 /* VF startup before PF is ready. Retry allocation. */
2219                 if (retry > 5) {
2220                         /* Too many attempts */
2221                         rc = EINVAL;
2222                         goto fail6;
2223                 }
2224                 EFSYS_PROBE1(mcdi_no_evb_port_retry, int, retry);
2225                 EFSYS_SLEEP(delay_us);
2226                 retry++;
2227                 if (delay_us < 500000)
2228                         delay_us <<= 2;
2229         }
2230
2231         enp->en_vport_id = EVB_PORT_ID_ASSIGNED;
2232         enp->en_nic_cfg.enc_mcdi_max_payload_length = MCDI_CTL_SDU_LEN_MAX_V2;
2233
2234         return (0);
2235
2236 fail6:
2237         EFSYS_PROBE(fail6);
2238 fail5:
2239         EFSYS_PROBE(fail5);
2240 fail4:
2241         EFSYS_PROBE(fail4);
2242 fail3:
2243         EFSYS_PROBE(fail3);
2244 fail2:
2245         EFSYS_PROBE(fail2);
2246
2247         ef10_nic_free_piobufs(enp);
2248
2249 fail1:
2250         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2251
2252         return (rc);
2253 }
2254
2255         __checkReturn   efx_rc_t
2256 ef10_nic_get_vi_pool(
2257         __in            efx_nic_t *enp,
2258         __out           uint32_t *vi_countp)
2259 {
2260         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2261             enp->en_family == EFX_FAMILY_MEDFORD ||
2262             enp->en_family == EFX_FAMILY_MEDFORD2);
2263
2264         /*
2265          * Report VIs that the client driver can use.
2266          * Do not include VIs used for PIO buffer writes.
2267          */
2268         *vi_countp = enp->en_arch.ef10.ena_pio_write_vi_base;
2269
2270         return (0);
2271 }
2272
2273         __checkReturn   efx_rc_t
2274 ef10_nic_get_bar_region(
2275         __in            efx_nic_t *enp,
2276         __in            efx_nic_region_t region,
2277         __out           uint32_t *offsetp,
2278         __out           size_t *sizep)
2279 {
2280         efx_rc_t rc;
2281
2282         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2283             enp->en_family == EFX_FAMILY_MEDFORD ||
2284             enp->en_family == EFX_FAMILY_MEDFORD2);
2285
2286         /*
2287          * TODO: Specify host memory mapping alignment and granularity
2288          * in efx_drv_limits_t so that they can be taken into account
2289          * when allocating extra VIs for PIO writes.
2290          */
2291         switch (region) {
2292         case EFX_REGION_VI:
2293                 /* UC mapped memory BAR region for VI registers */
2294                 *offsetp = enp->en_arch.ef10.ena_uc_mem_map_offset;
2295                 *sizep = enp->en_arch.ef10.ena_uc_mem_map_size;
2296                 break;
2297
2298         case EFX_REGION_PIO_WRITE_VI:
2299                 /* WC mapped memory BAR region for piobuf writes */
2300                 *offsetp = enp->en_arch.ef10.ena_wc_mem_map_offset;
2301                 *sizep = enp->en_arch.ef10.ena_wc_mem_map_size;
2302                 break;
2303
2304         default:
2305                 rc = EINVAL;
2306                 goto fail1;
2307         }
2308
2309         return (0);
2310
2311 fail1:
2312         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2313
2314         return (rc);
2315 }
2316
2317                         void
2318 ef10_nic_fini(
2319         __in            efx_nic_t *enp)
2320 {
2321         uint32_t i;
2322         efx_rc_t rc;
2323
2324         (void) efx_mcdi_vadaptor_free(enp, enp->en_vport_id);
2325         enp->en_vport_id = 0;
2326
2327         /* Unlink piobufs from extra VIs in WC mapping */
2328         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2329                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2330                         rc = efx_mcdi_unlink_piobuf(enp,
2331                             enp->en_arch.ef10.ena_pio_write_vi_base + i);
2332                         if (rc != 0)
2333                                 break;
2334                 }
2335         }
2336
2337         ef10_nic_free_piobufs(enp);
2338
2339         (void) efx_mcdi_free_vis(enp);
2340         enp->en_arch.ef10.ena_vi_count = 0;
2341 }
2342
2343                         void
2344 ef10_nic_unprobe(
2345         __in            efx_nic_t *enp)
2346 {
2347 #if EFSYS_OPT_MON_STATS
2348         mcdi_mon_cfg_free(enp);
2349 #endif /* EFSYS_OPT_MON_STATS */
2350         (void) efx_mcdi_drv_attach(enp, B_FALSE);
2351 }
2352
2353 #if EFSYS_OPT_DIAG
2354
2355         __checkReturn   efx_rc_t
2356 ef10_nic_register_test(
2357         __in            efx_nic_t *enp)
2358 {
2359         efx_rc_t rc;
2360
2361         /* FIXME */
2362         _NOTE(ARGUNUSED(enp))
2363         _NOTE(CONSTANTCONDITION)
2364         if (B_FALSE) {
2365                 rc = ENOTSUP;
2366                 goto fail1;
2367         }
2368         /* FIXME */
2369
2370         return (0);
2371
2372 fail1:
2373         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2374
2375         return (rc);
2376 }
2377
2378 #endif  /* EFSYS_OPT_DIAG */
2379
2380 #if EFSYS_OPT_FW_SUBVARIANT_AWARE
2381
2382         __checkReturn   efx_rc_t
2383 efx_mcdi_get_nic_global(
2384         __in            efx_nic_t *enp,
2385         __in            uint32_t key,
2386         __out           uint32_t *valuep)
2387 {
2388         efx_mcdi_req_t req;
2389         uint8_t payload[MAX(MC_CMD_GET_NIC_GLOBAL_IN_LEN,
2390                             MC_CMD_GET_NIC_GLOBAL_OUT_LEN)];
2391         efx_rc_t rc;
2392
2393         (void) memset(payload, 0, sizeof (payload));
2394         req.emr_cmd = MC_CMD_GET_NIC_GLOBAL;
2395         req.emr_in_buf = payload;
2396         req.emr_in_length = MC_CMD_GET_NIC_GLOBAL_IN_LEN;
2397         req.emr_out_buf = payload;
2398         req.emr_out_length = MC_CMD_GET_NIC_GLOBAL_OUT_LEN;
2399
2400         MCDI_IN_SET_DWORD(req, GET_NIC_GLOBAL_IN_KEY, key);
2401
2402         efx_mcdi_execute(enp, &req);
2403
2404         if (req.emr_rc != 0) {
2405                 rc = req.emr_rc;
2406                 goto fail1;
2407         }
2408
2409         if (req.emr_out_length_used != MC_CMD_GET_NIC_GLOBAL_OUT_LEN) {
2410                 rc = EMSGSIZE;
2411                 goto fail2;
2412         }
2413
2414         *valuep = MCDI_OUT_DWORD(req, GET_NIC_GLOBAL_OUT_VALUE);
2415
2416         return (0);
2417
2418 fail2:
2419         EFSYS_PROBE(fail2);
2420 fail1:
2421         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2422
2423         return (rc);
2424 }
2425
2426         __checkReturn   efx_rc_t
2427 efx_mcdi_set_nic_global(
2428         __in            efx_nic_t *enp,
2429         __in            uint32_t key,
2430         __in            uint32_t value)
2431 {
2432         efx_mcdi_req_t req;
2433         uint8_t payload[MC_CMD_SET_NIC_GLOBAL_IN_LEN];
2434         efx_rc_t rc;
2435
2436         (void) memset(payload, 0, sizeof (payload));
2437         req.emr_cmd = MC_CMD_SET_NIC_GLOBAL;
2438         req.emr_in_buf = payload;
2439         req.emr_in_length = MC_CMD_SET_NIC_GLOBAL_IN_LEN;
2440         req.emr_out_buf = NULL;
2441         req.emr_out_length = 0;
2442
2443         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_KEY, key);
2444         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_VALUE, value);
2445
2446         efx_mcdi_execute(enp, &req);
2447
2448         if (req.emr_rc != 0) {
2449                 rc = req.emr_rc;
2450                 goto fail1;
2451         }
2452
2453         return (0);
2454
2455 fail1:
2456         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2457
2458         return (rc);
2459 }
2460
2461 #endif  /* EFSYS_OPT_FW_SUBVARIANT_AWARE */
2462
2463 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */