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 /*
1445  * Table of mapping schemes from port number to external number.
1446  *
1447  * Each port number ultimately corresponds to a connector: either as part of
1448  * a cable assembly attached to a module inserted in an SFP+/QSFP+ cage on
1449  * the board, or fixed to the board (e.g. 10GBASE-T magjack on SFN5121T
1450  * "Salina"). In general:
1451  *
1452  * Port number (0-based)
1453  *     |
1454  *   port mapping (n:1)
1455  *     |
1456  *     v
1457  * External port number (normally 1-based)
1458  *     |
1459  *   fixed (1:1) or cable assembly (1:m)
1460  *     |
1461  *     v
1462  * Connector
1463  *
1464  * The external numbering refers to the cages or magjacks on the board,
1465  * as visibly annotated on the board or back panel. This table describes
1466  * how to determine which external cage/magjack corresponds to the port
1467  * numbers used by the driver.
1468  *
1469  * The count of adjacent port numbers that map to each external number,
1470  * and the offset in the numbering, is determined by the chip family and
1471  * current port mode.
1472  *
1473  * For the Huntington family, the current port mode cannot be discovered,
1474  * but a single mapping is used by all modes for a given chip variant,
1475  * so the mapping used is instead the last match in the table to the full
1476  * set of port modes to which the NIC can be configured. Therefore the
1477  * ordering of entries in the mapping table is significant.
1478  */
1479 static struct ef10_external_port_map_s {
1480         efx_family_t    family;
1481         uint32_t        modes_mask;
1482         int32_t         count;
1483         int32_t         offset;
1484 }       __ef10_external_port_mappings[] = {
1485         /*
1486          * Modes used by Huntington family controllers where each port
1487          * number maps to a separate cage.
1488          * SFN7x22F (Torino):
1489          *      port 0 -> cage 1
1490          *      port 1 -> cage 2
1491          * SFN7xx4F (Pavia):
1492          *      port 0 -> cage 1
1493          *      port 1 -> cage 2
1494          *      port 2 -> cage 3
1495          *      port 3 -> cage 4
1496          */
1497         {
1498                 EFX_FAMILY_HUNTINGTON,
1499                 (1U << TLV_PORT_MODE_10G) |                     /* mode 0 */
1500                 (1U << TLV_PORT_MODE_10G_10G) |                 /* mode 2 */
1501                 (1U << TLV_PORT_MODE_10G_10G_10G_10G),          /* mode 4 */
1502                 1,      /* ports per cage */
1503                 1       /* first cage */
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                 2,      /* ports per cage */
1521                 1       /* first cage */
1522         },
1523         /*
1524          * Modes that on Medford allocate each port number to a separate
1525          * cage.
1526          *      port 0 -> cage 1
1527          *      port 1 -> cage 2
1528          *      port 2 -> cage 3
1529          *      port 3 -> cage 4
1530          */
1531         {
1532                 EFX_FAMILY_MEDFORD,
1533                 (1U << TLV_PORT_MODE_1x1_NA) |                  /* mode 0 */
1534                 (1U << TLV_PORT_MODE_1x1_1x1),                  /* mode 2 */
1535                 1,      /* ports per cage */
1536                 1       /* first cage */
1537         },
1538         /*
1539          * Modes that on Medford allocate 2 adjacent port numbers to each
1540          * cage.
1541          *      port 0 -> cage 1
1542          *      port 1 -> cage 1
1543          *      port 2 -> cage 2
1544          *      port 3 -> cage 2
1545          */
1546         {
1547                 EFX_FAMILY_MEDFORD,
1548                 (1U << TLV_PORT_MODE_1x4_NA) |                  /* mode 1 */
1549                 (1U << TLV_PORT_MODE_1x4_1x4) |                 /* mode 3 */
1550                 (1U << TLV_PORT_MODE_1x4_2x1) |                 /* mode 6 */
1551                 (1U << TLV_PORT_MODE_2x1_1x4) |                 /* mode 7 */
1552                 /* Do not use 10G_10G_10G_10G_Q1_Q2 (see bug63270) */
1553                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q1_Q2),    /* mode 9 */
1554                 2,      /* ports per cage */
1555                 1       /* first cage */
1556         },
1557         /*
1558          * Modes that on Medford allocate 4 adjacent port numbers to each
1559          * connector, starting on cage 1.
1560          *      port 0 -> cage 1
1561          *      port 1 -> cage 1
1562          *      port 2 -> cage 1
1563          *      port 3 -> cage 1
1564          */
1565         {
1566                 EFX_FAMILY_MEDFORD,
1567                 (1U << TLV_PORT_MODE_2x1_2x1) |                 /* mode 5 */
1568                 /* Do not use 10G_10G_10G_10G_Q1 (see bug63270) */
1569                 (1U << TLV_PORT_MODE_4x1_NA),                   /* mode 4 */
1570                 4,      /* ports per cage */
1571                 1       /* first cage */
1572         },
1573         /*
1574          * Modes that on Medford allocate 4 adjacent port numbers to each
1575          * connector, starting on cage 2.
1576          *      port 0 -> cage 2
1577          *      port 1 -> cage 2
1578          *      port 2 -> cage 2
1579          *      port 3 -> cage 2
1580          */
1581         {
1582                 EFX_FAMILY_MEDFORD,
1583                 (1U << TLV_PORT_MODE_NA_4x1),                   /* mode 8 */
1584                 4,      /* ports per cage */
1585                 2       /* first cage */
1586         },
1587         /*
1588          * Modes that on Medford2 allocate each port number to a separate
1589          * cage.
1590          *      port 0 -> cage 1
1591          *      port 1 -> cage 2
1592          *      port 2 -> cage 3
1593          *      port 3 -> cage 4
1594          */
1595         {
1596                 EFX_FAMILY_MEDFORD2,
1597                 (1U << TLV_PORT_MODE_1x1_NA) |                  /* mode 0 */
1598                 (1U << TLV_PORT_MODE_1x4_NA) |                  /* mode 1 */
1599                 (1U << TLV_PORT_MODE_1x1_1x1) |                 /* mode 2 */
1600                 (1U << TLV_PORT_MODE_1x2_NA) |                  /* mode 10 */
1601                 (1U << TLV_PORT_MODE_1x2_1x2) |                 /* mode 12 */
1602                 (1U << TLV_PORT_MODE_1x4_1x2) |                 /* mode 15 */
1603                 (1U << TLV_PORT_MODE_1x2_1x4),                  /* mode 16 */
1604                 1,      /* ports per cage */
1605                 1       /* first cage */
1606         },
1607         /*
1608          * FIXME: Some port modes are not representable in this mapping:
1609          *  - TLV_PORT_MODE_1x2_2x1 (mode 17):
1610          *      port 0 -> cage 1
1611          *      port 1 -> cage 2
1612          *      port 2 -> cage 2
1613          */
1614         /*
1615          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1616          * cage, starting on cage 1.
1617          *      port 0 -> cage 1
1618          *      port 1 -> cage 1
1619          *      port 2 -> cage 2
1620          *      port 3 -> cage 2
1621          */
1622         {
1623                 EFX_FAMILY_MEDFORD2,
1624                 (1U << TLV_PORT_MODE_1x4_1x4) |                 /* mode 3 */
1625                 (1U << TLV_PORT_MODE_2x1_2x1) |                 /* mode 4 */
1626                 (1U << TLV_PORT_MODE_1x4_2x1) |                 /* mode 6 */
1627                 (1U << TLV_PORT_MODE_2x1_1x4) |                 /* mode 7 */
1628                 (1U << TLV_PORT_MODE_2x2_NA) |                  /* mode 13 */
1629                 (1U << TLV_PORT_MODE_2x1_1x2),                  /* mode 18 */
1630                 2,      /* ports per cage */
1631                 1       /* first cage */
1632         },
1633         /*
1634          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1635          * cage, starting on cage 2.
1636          *      port 0 -> cage 2
1637          *      port 1 -> cage 2
1638          */
1639         {
1640                 EFX_FAMILY_MEDFORD2,
1641                 (1U << TLV_PORT_MODE_NA_2x2),                   /* mode 14 */
1642                 2,      /* ports per cage */
1643                 2       /* first cage */
1644         },
1645         /*
1646          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1647          * connector, starting on cage 1.
1648          *      port 0 -> cage 1
1649          *      port 1 -> cage 1
1650          *      port 2 -> cage 1
1651          *      port 3 -> cage 1
1652          */
1653         {
1654                 EFX_FAMILY_MEDFORD2,
1655                 (1U << TLV_PORT_MODE_4x1_NA),                   /* mode 5 */
1656                 4,      /* ports per cage */
1657                 1       /* first cage */
1658         },
1659         /*
1660          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1661          * connector, starting on cage 2.
1662          *      port 0 -> cage 2
1663          *      port 1 -> cage 2
1664          *      port 2 -> cage 2
1665          *      port 3 -> cage 2
1666          */
1667         {
1668                 EFX_FAMILY_MEDFORD2,
1669                 (1U << TLV_PORT_MODE_NA_4x1) |                  /* mode 8 */
1670                 (1U << TLV_PORT_MODE_NA_1x2),                   /* mode 11 */
1671                 4,      /* ports per cage */
1672                 2       /* first cage */
1673         },
1674 };
1675
1676 static  __checkReturn   efx_rc_t
1677 ef10_external_port_mapping(
1678         __in            efx_nic_t *enp,
1679         __in            uint32_t port,
1680         __out           uint8_t *external_portp)
1681 {
1682         efx_rc_t rc;
1683         int i;
1684         uint32_t port_modes;
1685         uint32_t matches;
1686         uint32_t current;
1687         int32_t count = 1; /* Default 1-1 mapping */
1688         int32_t offset = 1; /* Default starting external port number */
1689
1690         if ((rc = efx_mcdi_get_port_modes(enp, &port_modes, &current,
1691                     NULL)) != 0) {
1692                 /*
1693                  * No current port mode information (i.e. Huntington)
1694                  * - infer mapping from available modes
1695                  */
1696                 if ((rc = efx_mcdi_get_port_modes(enp,
1697                             &port_modes, NULL, NULL)) != 0) {
1698                         /*
1699                          * No port mode information available
1700                          * - use default mapping
1701                          */
1702                         goto out;
1703                 }
1704         } else {
1705                 /* Only need to scan the current mode */
1706                 port_modes = 1 << current;
1707         }
1708
1709         /*
1710          * Infer the internal port -> external number mapping from
1711          * the possible port modes for this NIC.
1712          */
1713         for (i = 0; i < EFX_ARRAY_SIZE(__ef10_external_port_mappings); ++i) {
1714                 struct ef10_external_port_map_s *eepmp =
1715                     &__ef10_external_port_mappings[i];
1716                 if (eepmp->family != enp->en_family)
1717                         continue;
1718                 matches = (eepmp->modes_mask & port_modes);
1719                 if (matches != 0) {
1720                         /*
1721                          * Some modes match. For some Huntington boards
1722                          * there will be multiple matches. The mapping on the
1723                          * last match is used.
1724                          */
1725                         count = eepmp->count;
1726                         offset = eepmp->offset;
1727                         port_modes &= ~matches;
1728                 }
1729         }
1730
1731         if (port_modes != 0) {
1732                 /* Some advertised modes are not supported */
1733                 rc = ENOTSUP;
1734                 goto fail1;
1735         }
1736
1737 out:
1738         /*
1739          * Scale as required by last matched mode and then convert to
1740          * correctly offset numbering
1741          */
1742         *external_portp = (uint8_t)((port / count) + offset);
1743         return (0);
1744
1745 fail1:
1746         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1747
1748         return (rc);
1749 }
1750
1751 static  __checkReturn   efx_rc_t
1752 ef10_nic_board_cfg(
1753         __in            efx_nic_t *enp)
1754 {
1755         const efx_nic_ops_t *enop = enp->en_enop;
1756         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
1757         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1758         ef10_link_state_t els;
1759         efx_port_t *epp = &(enp->en_port);
1760         uint32_t board_type = 0;
1761         uint32_t base, nvec;
1762         uint32_t port;
1763         uint32_t mask;
1764         uint32_t pf;
1765         uint32_t vf;
1766         uint8_t mac_addr[6] = { 0 };
1767         efx_rc_t rc;
1768
1769         /* Get the (zero-based) MCDI port number */
1770         if ((rc = efx_mcdi_get_port_assignment(enp, &port)) != 0)
1771                 goto fail1;
1772
1773         /* EFX MCDI interface uses one-based port numbers */
1774         emip->emi_port = port + 1;
1775
1776         if ((rc = ef10_external_port_mapping(enp, port,
1777                     &encp->enc_external_port)) != 0)
1778                 goto fail2;
1779
1780         /*
1781          * Get PCIe function number from firmware (used for
1782          * per-function privilege and dynamic config info).
1783          *  - PCIe PF: pf = PF number, vf = 0xffff.
1784          *  - PCIe VF: pf = parent PF, vf = VF number.
1785          */
1786         if ((rc = efx_mcdi_get_function_info(enp, &pf, &vf)) != 0)
1787                 goto fail3;
1788
1789         encp->enc_pf = pf;
1790         encp->enc_vf = vf;
1791
1792         /* MAC address for this function */
1793         if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1794                 rc = efx_mcdi_get_mac_address_pf(enp, mac_addr);
1795 #if EFSYS_OPT_ALLOW_UNCONFIGURED_NIC
1796                 /*
1797                  * Disable static config checking, ONLY for manufacturing test
1798                  * and setup at the factory, to allow the static config to be
1799                  * installed.
1800                  */
1801 #else /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1802                 if ((rc == 0) && (mac_addr[0] & 0x02)) {
1803                         /*
1804                          * If the static config does not include a global MAC
1805                          * address pool then the board may return a locally
1806                          * administered MAC address (this should only happen on
1807                          * incorrectly programmed boards).
1808                          */
1809                         rc = EINVAL;
1810                 }
1811 #endif /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1812         } else {
1813                 rc = efx_mcdi_get_mac_address_vf(enp, mac_addr);
1814         }
1815         if (rc != 0)
1816                 goto fail4;
1817
1818         EFX_MAC_ADDR_COPY(encp->enc_mac_addr, mac_addr);
1819
1820         /* Board configuration (legacy) */
1821         rc = efx_mcdi_get_board_cfg(enp, &board_type, NULL, NULL);
1822         if (rc != 0) {
1823                 /* Unprivileged functions may not be able to read board cfg */
1824                 if (rc == EACCES)
1825                         board_type = 0;
1826                 else
1827                         goto fail5;
1828         }
1829
1830         encp->enc_board_type = board_type;
1831         encp->enc_clk_mult = 1; /* not used for EF10 */
1832
1833         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
1834         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
1835                 goto fail6;
1836
1837         /*
1838          * Firmware with support for *_FEC capability bits does not
1839          * report that the corresponding *_FEC_REQUESTED bits are supported.
1840          * Add them here so that drivers understand that they are supported.
1841          */
1842         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_BASER_FEC))
1843                 epp->ep_phy_cap_mask |=
1844                     (1u << EFX_PHY_CAP_BASER_FEC_REQUESTED);
1845         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_RS_FEC))
1846                 epp->ep_phy_cap_mask |=
1847                     (1u << EFX_PHY_CAP_RS_FEC_REQUESTED);
1848         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_25G_BASER_FEC))
1849                 epp->ep_phy_cap_mask |=
1850                     (1u << EFX_PHY_CAP_25G_BASER_FEC_REQUESTED);
1851
1852         /* Obtain the default PHY advertised capabilities */
1853         if ((rc = ef10_phy_get_link(enp, &els)) != 0)
1854                 goto fail7;
1855         epp->ep_default_adv_cap_mask = els.epls.epls_adv_cap_mask;
1856         epp->ep_adv_cap_mask = els.epls.epls_adv_cap_mask;
1857
1858         /* Check capabilities of running datapath firmware */
1859         if ((rc = ef10_get_datapath_caps(enp)) != 0)
1860                 goto fail8;
1861
1862         /* Alignment for WPTR updates */
1863         encp->enc_rx_push_align = EF10_RX_WPTR_ALIGN;
1864
1865         encp->enc_tx_dma_desc_size_max = EFX_MASK32(ESF_DZ_RX_KER_BYTE_CNT);
1866         /* No boundary crossing limits */
1867         encp->enc_tx_dma_desc_boundary = 0;
1868
1869         /*
1870          * Maximum number of bytes into the frame the TCP header can start for
1871          * firmware assisted TSO to work.
1872          */
1873         encp->enc_tx_tso_tcp_header_offset_limit = EF10_TCP_HEADER_OFFSET_LIMIT;
1874
1875         /*
1876          * Set resource limits for MC_CMD_ALLOC_VIS. Note that we cannot use
1877          * MC_CMD_GET_RESOURCE_LIMITS here as that reports the available
1878          * resources (allocated to this PCIe function), which is zero until
1879          * after we have allocated VIs.
1880          */
1881         encp->enc_evq_limit = 1024;
1882         encp->enc_rxq_limit = EFX_RXQ_LIMIT_TARGET;
1883         encp->enc_txq_limit = EFX_TXQ_LIMIT_TARGET;
1884
1885         encp->enc_buftbl_limit = 0xFFFFFFFF;
1886
1887         /* Get interrupt vector limits */
1888         if ((rc = efx_mcdi_get_vector_cfg(enp, &base, &nvec, NULL)) != 0) {
1889                 if (EFX_PCI_FUNCTION_IS_PF(encp))
1890                         goto fail9;
1891
1892                 /* Ignore error (cannot query vector limits from a VF). */
1893                 base = 0;
1894                 nvec = 1024;
1895         }
1896         encp->enc_intr_vec_base = base;
1897         encp->enc_intr_limit = nvec;
1898
1899         /*
1900          * Get the current privilege mask. Note that this may be modified
1901          * dynamically, so this value is informational only. DO NOT use
1902          * the privilege mask to check for sufficient privileges, as that
1903          * can result in time-of-check/time-of-use bugs.
1904          */
1905         if ((rc = ef10_get_privilege_mask(enp, &mask)) != 0)
1906                 goto fail10;
1907         encp->enc_privilege_mask = mask;
1908
1909         /* Get remaining controller-specific board config */
1910         if ((rc = enop->eno_board_cfg(enp)) != 0)
1911                 if (rc != EACCES)
1912                         goto fail11;
1913
1914         return (0);
1915
1916 fail11:
1917         EFSYS_PROBE(fail11);
1918 fail10:
1919         EFSYS_PROBE(fail10);
1920 fail9:
1921         EFSYS_PROBE(fail9);
1922 fail8:
1923         EFSYS_PROBE(fail8);
1924 fail7:
1925         EFSYS_PROBE(fail7);
1926 fail6:
1927         EFSYS_PROBE(fail6);
1928 fail5:
1929         EFSYS_PROBE(fail5);
1930 fail4:
1931         EFSYS_PROBE(fail4);
1932 fail3:
1933         EFSYS_PROBE(fail3);
1934 fail2:
1935         EFSYS_PROBE(fail2);
1936 fail1:
1937         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1938
1939         return (rc);
1940 }
1941
1942         __checkReturn   efx_rc_t
1943 ef10_nic_probe(
1944         __in            efx_nic_t *enp)
1945 {
1946         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1947         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1948         efx_rc_t rc;
1949
1950         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
1951             enp->en_family == EFX_FAMILY_MEDFORD ||
1952             enp->en_family == EFX_FAMILY_MEDFORD2);
1953
1954         /* Read and clear any assertion state */
1955         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
1956                 goto fail1;
1957
1958         /* Exit the assertion handler */
1959         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
1960                 if (rc != EACCES)
1961                         goto fail2;
1962
1963         if ((rc = efx_mcdi_drv_attach(enp, B_TRUE)) != 0)
1964                 goto fail3;
1965
1966         if ((rc = ef10_nic_board_cfg(enp)) != 0)
1967                 goto fail4;
1968
1969         /*
1970          * Set default driver config limits (based on board config).
1971          *
1972          * FIXME: For now allocate a fixed number of VIs which is likely to be
1973          * sufficient and small enough to allow multiple functions on the same
1974          * port.
1975          */
1976         edcp->edc_min_vi_count = edcp->edc_max_vi_count =
1977             MIN(128, MAX(encp->enc_rxq_limit, encp->enc_txq_limit));
1978
1979         /* The client driver must configure and enable PIO buffer support */
1980         edcp->edc_max_piobuf_count = 0;
1981         edcp->edc_pio_alloc_size = 0;
1982
1983 #if EFSYS_OPT_MAC_STATS
1984         /* Wipe the MAC statistics */
1985         if ((rc = efx_mcdi_mac_stats_clear(enp)) != 0)
1986                 goto fail5;
1987 #endif
1988
1989 #if EFSYS_OPT_LOOPBACK
1990         if ((rc = efx_mcdi_get_loopback_modes(enp)) != 0)
1991                 goto fail6;
1992 #endif
1993
1994 #if EFSYS_OPT_MON_STATS
1995         if ((rc = mcdi_mon_cfg_build(enp)) != 0) {
1996                 /* Unprivileged functions do not have access to sensors */
1997                 if (rc != EACCES)
1998                         goto fail7;
1999         }
2000 #endif
2001
2002         encp->enc_features = enp->en_features;
2003
2004         return (0);
2005
2006 #if EFSYS_OPT_MON_STATS
2007 fail7:
2008         EFSYS_PROBE(fail7);
2009 #endif
2010 #if EFSYS_OPT_LOOPBACK
2011 fail6:
2012         EFSYS_PROBE(fail6);
2013 #endif
2014 #if EFSYS_OPT_MAC_STATS
2015 fail5:
2016         EFSYS_PROBE(fail5);
2017 #endif
2018 fail4:
2019         EFSYS_PROBE(fail4);
2020 fail3:
2021         EFSYS_PROBE(fail3);
2022 fail2:
2023         EFSYS_PROBE(fail2);
2024 fail1:
2025         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2026
2027         return (rc);
2028 }
2029
2030         __checkReturn   efx_rc_t
2031 ef10_nic_set_drv_limits(
2032         __inout         efx_nic_t *enp,
2033         __in            efx_drv_limits_t *edlp)
2034 {
2035         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
2036         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
2037         uint32_t min_evq_count, max_evq_count;
2038         uint32_t min_rxq_count, max_rxq_count;
2039         uint32_t min_txq_count, max_txq_count;
2040         efx_rc_t rc;
2041
2042         if (edlp == NULL) {
2043                 rc = EINVAL;
2044                 goto fail1;
2045         }
2046
2047         /* Get minimum required and maximum usable VI limits */
2048         min_evq_count = MIN(edlp->edl_min_evq_count, encp->enc_evq_limit);
2049         min_rxq_count = MIN(edlp->edl_min_rxq_count, encp->enc_rxq_limit);
2050         min_txq_count = MIN(edlp->edl_min_txq_count, encp->enc_txq_limit);
2051
2052         edcp->edc_min_vi_count =
2053             MAX(min_evq_count, MAX(min_rxq_count, min_txq_count));
2054
2055         max_evq_count = MIN(edlp->edl_max_evq_count, encp->enc_evq_limit);
2056         max_rxq_count = MIN(edlp->edl_max_rxq_count, encp->enc_rxq_limit);
2057         max_txq_count = MIN(edlp->edl_max_txq_count, encp->enc_txq_limit);
2058
2059         edcp->edc_max_vi_count =
2060             MAX(max_evq_count, MAX(max_rxq_count, max_txq_count));
2061
2062         /*
2063          * Check limits for sub-allocated piobuf blocks.
2064          * PIO is optional, so don't fail if the limits are incorrect.
2065          */
2066         if ((encp->enc_piobuf_size == 0) ||
2067             (encp->enc_piobuf_limit == 0) ||
2068             (edlp->edl_min_pio_alloc_size == 0) ||
2069             (edlp->edl_min_pio_alloc_size > encp->enc_piobuf_size)) {
2070                 /* Disable PIO */
2071                 edcp->edc_max_piobuf_count = 0;
2072                 edcp->edc_pio_alloc_size = 0;
2073         } else {
2074                 uint32_t blk_size, blk_count, blks_per_piobuf;
2075
2076                 blk_size =
2077                     MAX(edlp->edl_min_pio_alloc_size,
2078                             encp->enc_piobuf_min_alloc_size);
2079
2080                 blks_per_piobuf = encp->enc_piobuf_size / blk_size;
2081                 EFSYS_ASSERT3U(blks_per_piobuf, <=, 32);
2082
2083                 blk_count = (encp->enc_piobuf_limit * blks_per_piobuf);
2084
2085                 /* A zero max pio alloc count means unlimited */
2086                 if ((edlp->edl_max_pio_alloc_count > 0) &&
2087                     (edlp->edl_max_pio_alloc_count < blk_count)) {
2088                         blk_count = edlp->edl_max_pio_alloc_count;
2089                 }
2090
2091                 edcp->edc_pio_alloc_size = blk_size;
2092                 edcp->edc_max_piobuf_count =
2093                     (blk_count + (blks_per_piobuf - 1)) / blks_per_piobuf;
2094         }
2095
2096         return (0);
2097
2098 fail1:
2099         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2100
2101         return (rc);
2102 }
2103
2104
2105         __checkReturn   efx_rc_t
2106 ef10_nic_reset(
2107         __in            efx_nic_t *enp)
2108 {
2109         efx_mcdi_req_t req;
2110         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_ENTITY_RESET_IN_LEN,
2111                 MC_CMD_ENTITY_RESET_OUT_LEN);
2112         efx_rc_t rc;
2113
2114         /* ef10_nic_reset() is called to recover from BADASSERT failures. */
2115         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
2116                 goto fail1;
2117         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
2118                 goto fail2;
2119
2120         req.emr_cmd = MC_CMD_ENTITY_RESET;
2121         req.emr_in_buf = payload;
2122         req.emr_in_length = MC_CMD_ENTITY_RESET_IN_LEN;
2123         req.emr_out_buf = payload;
2124         req.emr_out_length = MC_CMD_ENTITY_RESET_OUT_LEN;
2125
2126         MCDI_IN_POPULATE_DWORD_1(req, ENTITY_RESET_IN_FLAG,
2127             ENTITY_RESET_IN_FUNCTION_RESOURCE_RESET, 1);
2128
2129         efx_mcdi_execute(enp, &req);
2130
2131         if (req.emr_rc != 0) {
2132                 rc = req.emr_rc;
2133                 goto fail3;
2134         }
2135
2136         /* Clear RX/TX DMA queue errors */
2137         enp->en_reset_flags &= ~(EFX_RESET_RXQ_ERR | EFX_RESET_TXQ_ERR);
2138
2139         return (0);
2140
2141 fail3:
2142         EFSYS_PROBE(fail3);
2143 fail2:
2144         EFSYS_PROBE(fail2);
2145 fail1:
2146         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2147
2148         return (rc);
2149 }
2150
2151         __checkReturn   efx_rc_t
2152 ef10_nic_init(
2153         __in            efx_nic_t *enp)
2154 {
2155         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
2156         uint32_t min_vi_count, max_vi_count;
2157         uint32_t vi_count, vi_base, vi_shift;
2158         uint32_t i;
2159         uint32_t retry;
2160         uint32_t delay_us;
2161         uint32_t vi_window_size;
2162         efx_rc_t rc;
2163
2164         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2165             enp->en_family == EFX_FAMILY_MEDFORD ||
2166             enp->en_family == EFX_FAMILY_MEDFORD2);
2167
2168         /* Enable reporting of some events (e.g. link change) */
2169         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
2170                 goto fail1;
2171
2172         /* Allocate (optional) on-chip PIO buffers */
2173         ef10_nic_alloc_piobufs(enp, edcp->edc_max_piobuf_count);
2174
2175         /*
2176          * For best performance, PIO writes should use a write-combined
2177          * (WC) memory mapping. Using a separate WC mapping for the PIO
2178          * aperture of each VI would be a burden to drivers (and not
2179          * possible if the host page size is >4Kbyte).
2180          *
2181          * To avoid this we use a single uncached (UC) mapping for VI
2182          * register access, and a single WC mapping for extra VIs used
2183          * for PIO writes.
2184          *
2185          * Each piobuf must be linked to a VI in the WC mapping, and to
2186          * each VI that is using a sub-allocated block from the piobuf.
2187          */
2188         min_vi_count = edcp->edc_min_vi_count;
2189         max_vi_count =
2190             edcp->edc_max_vi_count + enp->en_arch.ef10.ena_piobuf_count;
2191
2192         /* Ensure that the previously attached driver's VIs are freed */
2193         if ((rc = efx_mcdi_free_vis(enp)) != 0)
2194                 goto fail2;
2195
2196         /*
2197          * Reserve VI resources (EVQ+RXQ+TXQ) for this PCIe function. If this
2198          * fails then retrying the request for fewer VI resources may succeed.
2199          */
2200         vi_count = 0;
2201         if ((rc = efx_mcdi_alloc_vis(enp, min_vi_count, max_vi_count,
2202                     &vi_base, &vi_count, &vi_shift)) != 0)
2203                 goto fail3;
2204
2205         EFSYS_PROBE2(vi_alloc, uint32_t, vi_base, uint32_t, vi_count);
2206
2207         if (vi_count < min_vi_count) {
2208                 rc = ENOMEM;
2209                 goto fail4;
2210         }
2211
2212         enp->en_arch.ef10.ena_vi_base = vi_base;
2213         enp->en_arch.ef10.ena_vi_count = vi_count;
2214         enp->en_arch.ef10.ena_vi_shift = vi_shift;
2215
2216         if (vi_count < min_vi_count + enp->en_arch.ef10.ena_piobuf_count) {
2217                 /* Not enough extra VIs to map piobufs */
2218                 ef10_nic_free_piobufs(enp);
2219         }
2220
2221         enp->en_arch.ef10.ena_pio_write_vi_base =
2222             vi_count - enp->en_arch.ef10.ena_piobuf_count;
2223
2224         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, !=,
2225             EFX_VI_WINDOW_SHIFT_INVALID);
2226         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, <=,
2227             EFX_VI_WINDOW_SHIFT_64K);
2228         vi_window_size = 1U << enp->en_nic_cfg.enc_vi_window_shift;
2229
2230         /* Save UC memory mapping details */
2231         enp->en_arch.ef10.ena_uc_mem_map_offset = 0;
2232         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2233                 enp->en_arch.ef10.ena_uc_mem_map_size =
2234                     (vi_window_size *
2235                     enp->en_arch.ef10.ena_pio_write_vi_base);
2236         } else {
2237                 enp->en_arch.ef10.ena_uc_mem_map_size =
2238                     (vi_window_size *
2239                     enp->en_arch.ef10.ena_vi_count);
2240         }
2241
2242         /* Save WC memory mapping details */
2243         enp->en_arch.ef10.ena_wc_mem_map_offset =
2244             enp->en_arch.ef10.ena_uc_mem_map_offset +
2245             enp->en_arch.ef10.ena_uc_mem_map_size;
2246
2247         enp->en_arch.ef10.ena_wc_mem_map_size =
2248             (vi_window_size *
2249             enp->en_arch.ef10.ena_piobuf_count);
2250
2251         /* Link piobufs to extra VIs in WC mapping */
2252         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2253                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2254                         rc = efx_mcdi_link_piobuf(enp,
2255                             enp->en_arch.ef10.ena_pio_write_vi_base + i,
2256                             enp->en_arch.ef10.ena_piobuf_handle[i]);
2257                         if (rc != 0)
2258                                 break;
2259                 }
2260         }
2261
2262         /*
2263          * Allocate a vAdaptor attached to our upstream vPort/pPort.
2264          *
2265          * On a VF, this may fail with MC_CMD_ERR_NO_EVB_PORT (ENOENT) if the PF
2266          * driver has yet to bring up the EVB port. See bug 56147. In this case,
2267          * retry the request several times after waiting a while. The wait time
2268          * between retries starts small (10ms) and exponentially increases.
2269          * Total wait time is a little over two seconds. Retry logic in the
2270          * client driver may mean this whole loop is repeated if it continues to
2271          * fail.
2272          */
2273         retry = 0;
2274         delay_us = 10000;
2275         while ((rc = efx_mcdi_vadaptor_alloc(enp, EVB_PORT_ID_ASSIGNED)) != 0) {
2276                 if (EFX_PCI_FUNCTION_IS_PF(&enp->en_nic_cfg) ||
2277                     (rc != ENOENT)) {
2278                         /*
2279                          * Do not retry alloc for PF, or for other errors on
2280                          * a VF.
2281                          */
2282                         goto fail5;
2283                 }
2284
2285                 /* VF startup before PF is ready. Retry allocation. */
2286                 if (retry > 5) {
2287                         /* Too many attempts */
2288                         rc = EINVAL;
2289                         goto fail6;
2290                 }
2291                 EFSYS_PROBE1(mcdi_no_evb_port_retry, int, retry);
2292                 EFSYS_SLEEP(delay_us);
2293                 retry++;
2294                 if (delay_us < 500000)
2295                         delay_us <<= 2;
2296         }
2297
2298         enp->en_vport_id = EVB_PORT_ID_ASSIGNED;
2299         enp->en_nic_cfg.enc_mcdi_max_payload_length = MCDI_CTL_SDU_LEN_MAX_V2;
2300
2301         return (0);
2302
2303 fail6:
2304         EFSYS_PROBE(fail6);
2305 fail5:
2306         EFSYS_PROBE(fail5);
2307 fail4:
2308         EFSYS_PROBE(fail4);
2309 fail3:
2310         EFSYS_PROBE(fail3);
2311 fail2:
2312         EFSYS_PROBE(fail2);
2313
2314         ef10_nic_free_piobufs(enp);
2315
2316 fail1:
2317         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2318
2319         return (rc);
2320 }
2321
2322         __checkReturn   efx_rc_t
2323 ef10_nic_get_vi_pool(
2324         __in            efx_nic_t *enp,
2325         __out           uint32_t *vi_countp)
2326 {
2327         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2328             enp->en_family == EFX_FAMILY_MEDFORD ||
2329             enp->en_family == EFX_FAMILY_MEDFORD2);
2330
2331         /*
2332          * Report VIs that the client driver can use.
2333          * Do not include VIs used for PIO buffer writes.
2334          */
2335         *vi_countp = enp->en_arch.ef10.ena_pio_write_vi_base;
2336
2337         return (0);
2338 }
2339
2340         __checkReturn   efx_rc_t
2341 ef10_nic_get_bar_region(
2342         __in            efx_nic_t *enp,
2343         __in            efx_nic_region_t region,
2344         __out           uint32_t *offsetp,
2345         __out           size_t *sizep)
2346 {
2347         efx_rc_t rc;
2348
2349         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2350             enp->en_family == EFX_FAMILY_MEDFORD ||
2351             enp->en_family == EFX_FAMILY_MEDFORD2);
2352
2353         /*
2354          * TODO: Specify host memory mapping alignment and granularity
2355          * in efx_drv_limits_t so that they can be taken into account
2356          * when allocating extra VIs for PIO writes.
2357          */
2358         switch (region) {
2359         case EFX_REGION_VI:
2360                 /* UC mapped memory BAR region for VI registers */
2361                 *offsetp = enp->en_arch.ef10.ena_uc_mem_map_offset;
2362                 *sizep = enp->en_arch.ef10.ena_uc_mem_map_size;
2363                 break;
2364
2365         case EFX_REGION_PIO_WRITE_VI:
2366                 /* WC mapped memory BAR region for piobuf writes */
2367                 *offsetp = enp->en_arch.ef10.ena_wc_mem_map_offset;
2368                 *sizep = enp->en_arch.ef10.ena_wc_mem_map_size;
2369                 break;
2370
2371         default:
2372                 rc = EINVAL;
2373                 goto fail1;
2374         }
2375
2376         return (0);
2377
2378 fail1:
2379         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2380
2381         return (rc);
2382 }
2383
2384         __checkReturn   boolean_t
2385 ef10_nic_hw_unavailable(
2386         __in            efx_nic_t *enp)
2387 {
2388         efx_dword_t dword;
2389
2390         if (enp->en_reset_flags & EFX_RESET_HW_UNAVAIL)
2391                 return (B_TRUE);
2392
2393         EFX_BAR_READD(enp, ER_DZ_BIU_MC_SFT_STATUS_REG, &dword, B_FALSE);
2394         if (EFX_DWORD_FIELD(dword, EFX_DWORD_0) == 0xffffffff)
2395                 goto unavail;
2396
2397         return (B_FALSE);
2398
2399 unavail:
2400         ef10_nic_set_hw_unavailable(enp);
2401
2402         return (B_TRUE);
2403 }
2404
2405                         void
2406 ef10_nic_set_hw_unavailable(
2407         __in            efx_nic_t *enp)
2408 {
2409         EFSYS_PROBE(hw_unavail);
2410         enp->en_reset_flags |= EFX_RESET_HW_UNAVAIL;
2411 }
2412
2413
2414                         void
2415 ef10_nic_fini(
2416         __in            efx_nic_t *enp)
2417 {
2418         uint32_t i;
2419         efx_rc_t rc;
2420
2421         (void) efx_mcdi_vadaptor_free(enp, enp->en_vport_id);
2422         enp->en_vport_id = 0;
2423
2424         /* Unlink piobufs from extra VIs in WC mapping */
2425         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2426                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2427                         rc = efx_mcdi_unlink_piobuf(enp,
2428                             enp->en_arch.ef10.ena_pio_write_vi_base + i);
2429                         if (rc != 0)
2430                                 break;
2431                 }
2432         }
2433
2434         ef10_nic_free_piobufs(enp);
2435
2436         (void) efx_mcdi_free_vis(enp);
2437         enp->en_arch.ef10.ena_vi_count = 0;
2438 }
2439
2440                         void
2441 ef10_nic_unprobe(
2442         __in            efx_nic_t *enp)
2443 {
2444 #if EFSYS_OPT_MON_STATS
2445         mcdi_mon_cfg_free(enp);
2446 #endif /* EFSYS_OPT_MON_STATS */
2447         (void) efx_mcdi_drv_attach(enp, B_FALSE);
2448 }
2449
2450 #if EFSYS_OPT_DIAG
2451
2452         __checkReturn   efx_rc_t
2453 ef10_nic_register_test(
2454         __in            efx_nic_t *enp)
2455 {
2456         efx_rc_t rc;
2457
2458         /* FIXME */
2459         _NOTE(ARGUNUSED(enp))
2460         _NOTE(CONSTANTCONDITION)
2461         if (B_FALSE) {
2462                 rc = ENOTSUP;
2463                 goto fail1;
2464         }
2465         /* FIXME */
2466
2467         return (0);
2468
2469 fail1:
2470         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2471
2472         return (rc);
2473 }
2474
2475 #endif  /* EFSYS_OPT_DIAG */
2476
2477 #if EFSYS_OPT_FW_SUBVARIANT_AWARE
2478
2479         __checkReturn   efx_rc_t
2480 efx_mcdi_get_nic_global(
2481         __in            efx_nic_t *enp,
2482         __in            uint32_t key,
2483         __out           uint32_t *valuep)
2484 {
2485         efx_mcdi_req_t req;
2486         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_NIC_GLOBAL_IN_LEN,
2487                 MC_CMD_GET_NIC_GLOBAL_OUT_LEN);
2488         efx_rc_t rc;
2489
2490         req.emr_cmd = MC_CMD_GET_NIC_GLOBAL;
2491         req.emr_in_buf = payload;
2492         req.emr_in_length = MC_CMD_GET_NIC_GLOBAL_IN_LEN;
2493         req.emr_out_buf = payload;
2494         req.emr_out_length = MC_CMD_GET_NIC_GLOBAL_OUT_LEN;
2495
2496         MCDI_IN_SET_DWORD(req, GET_NIC_GLOBAL_IN_KEY, key);
2497
2498         efx_mcdi_execute(enp, &req);
2499
2500         if (req.emr_rc != 0) {
2501                 rc = req.emr_rc;
2502                 goto fail1;
2503         }
2504
2505         if (req.emr_out_length_used != MC_CMD_GET_NIC_GLOBAL_OUT_LEN) {
2506                 rc = EMSGSIZE;
2507                 goto fail2;
2508         }
2509
2510         *valuep = MCDI_OUT_DWORD(req, GET_NIC_GLOBAL_OUT_VALUE);
2511
2512         return (0);
2513
2514 fail2:
2515         EFSYS_PROBE(fail2);
2516 fail1:
2517         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2518
2519         return (rc);
2520 }
2521
2522         __checkReturn   efx_rc_t
2523 efx_mcdi_set_nic_global(
2524         __in            efx_nic_t *enp,
2525         __in            uint32_t key,
2526         __in            uint32_t value)
2527 {
2528         efx_mcdi_req_t req;
2529         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_NIC_GLOBAL_IN_LEN, 0);
2530         efx_rc_t rc;
2531
2532         req.emr_cmd = MC_CMD_SET_NIC_GLOBAL;
2533         req.emr_in_buf = payload;
2534         req.emr_in_length = MC_CMD_SET_NIC_GLOBAL_IN_LEN;
2535         req.emr_out_buf = NULL;
2536         req.emr_out_length = 0;
2537
2538         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_KEY, key);
2539         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_VALUE, value);
2540
2541         efx_mcdi_execute(enp, &req);
2542
2543         if (req.emr_rc != 0) {
2544                 rc = req.emr_rc;
2545                 goto fail1;
2546         }
2547
2548         return (0);
2549
2550 fail1:
2551         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2552
2553         return (rc);
2554 }
2555
2556 #endif  /* EFSYS_OPT_FW_SUBVARIANT_AWARE */
2557
2558 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */