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