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         /* Check if the firmware supports additional RSS modes */
1090         if (CAP_FLAGS1(req, ADDITIONAL_RSS_MODES))
1091                 encp->enc_rx_scale_additional_modes_supported = B_TRUE;
1092         else
1093                 encp->enc_rx_scale_additional_modes_supported = B_FALSE;
1094
1095         /* Check if the firmware supports TSO */
1096         if (CAP_FLAGS1(req, TX_TSO))
1097                 encp->enc_fw_assisted_tso_enabled = B_TRUE;
1098         else
1099                 encp->enc_fw_assisted_tso_enabled = B_FALSE;
1100
1101         /* Check if the firmware supports FATSOv2 */
1102         if (CAP_FLAGS2(req, TX_TSO_V2)) {
1103                 encp->enc_fw_assisted_tso_v2_enabled = B_TRUE;
1104                 encp->enc_fw_assisted_tso_v2_n_contexts = MCDI_OUT_WORD(req,
1105                     GET_CAPABILITIES_V2_OUT_TX_TSO_V2_N_CONTEXTS);
1106         } else {
1107                 encp->enc_fw_assisted_tso_v2_enabled = B_FALSE;
1108                 encp->enc_fw_assisted_tso_v2_n_contexts = 0;
1109         }
1110
1111         /* Check if the firmware supports FATSOv2 encap */
1112         if (CAP_FLAGS2(req, TX_TSO_V2_ENCAP))
1113                 encp->enc_fw_assisted_tso_v2_encap_enabled = B_TRUE;
1114         else
1115                 encp->enc_fw_assisted_tso_v2_encap_enabled = B_FALSE;
1116
1117         /* Check if the firmware has vadapter/vport/vswitch support */
1118         if (CAP_FLAGS1(req, EVB))
1119                 encp->enc_datapath_cap_evb = B_TRUE;
1120         else
1121                 encp->enc_datapath_cap_evb = B_FALSE;
1122
1123         /* Check if the firmware supports VLAN insertion */
1124         if (CAP_FLAGS1(req, TX_VLAN_INSERTION))
1125                 encp->enc_hw_tx_insert_vlan_enabled = B_TRUE;
1126         else
1127                 encp->enc_hw_tx_insert_vlan_enabled = B_FALSE;
1128
1129         /* Check if the firmware supports RX event batching */
1130         if (CAP_FLAGS1(req, RX_BATCHING))
1131                 encp->enc_rx_batching_enabled = B_TRUE;
1132         else
1133                 encp->enc_rx_batching_enabled = B_FALSE;
1134
1135         /*
1136          * Even if batching isn't reported as supported, we may still get
1137          * batched events (see bug61153).
1138          */
1139         encp->enc_rx_batch_max = 16;
1140
1141         /* Check if the firmware supports disabling scatter on RXQs */
1142         if (CAP_FLAGS1(req, RX_DISABLE_SCATTER))
1143                 encp->enc_rx_disable_scatter_supported = B_TRUE;
1144         else
1145                 encp->enc_rx_disable_scatter_supported = B_FALSE;
1146
1147         /* Check if the firmware supports packed stream mode */
1148         if (CAP_FLAGS1(req, RX_PACKED_STREAM))
1149                 encp->enc_rx_packed_stream_supported = B_TRUE;
1150         else
1151                 encp->enc_rx_packed_stream_supported = B_FALSE;
1152
1153         /*
1154          * Check if the firmware supports configurable buffer sizes
1155          * for packed stream mode (otherwise buffer size is 1Mbyte)
1156          */
1157         if (CAP_FLAGS1(req, RX_PACKED_STREAM_VAR_BUFFERS))
1158                 encp->enc_rx_var_packed_stream_supported = B_TRUE;
1159         else
1160                 encp->enc_rx_var_packed_stream_supported = B_FALSE;
1161
1162         /* Check if the firmware supports equal stride super-buffer mode */
1163         if (CAP_FLAGS2(req, EQUAL_STRIDE_SUPER_BUFFER))
1164                 encp->enc_rx_es_super_buffer_supported = B_TRUE;
1165         else
1166                 encp->enc_rx_es_super_buffer_supported = B_FALSE;
1167
1168         /* Check if the firmware supports FW subvariant w/o Tx checksumming */
1169         if (CAP_FLAGS2(req, FW_SUBVARIANT_NO_TX_CSUM))
1170                 encp->enc_fw_subvariant_no_tx_csum_supported = B_TRUE;
1171         else
1172                 encp->enc_fw_subvariant_no_tx_csum_supported = B_FALSE;
1173
1174         /* Check if the firmware supports set mac with running filters */
1175         if (CAP_FLAGS1(req, VADAPTOR_PERMIT_SET_MAC_WHEN_FILTERS_INSTALLED))
1176                 encp->enc_allow_set_mac_with_installed_filters = B_TRUE;
1177         else
1178                 encp->enc_allow_set_mac_with_installed_filters = B_FALSE;
1179
1180         /*
1181          * Check if firmware supports the extended MC_CMD_SET_MAC, which allows
1182          * specifying which parameters to configure.
1183          */
1184         if (CAP_FLAGS1(req, SET_MAC_ENHANCED))
1185                 encp->enc_enhanced_set_mac_supported = B_TRUE;
1186         else
1187                 encp->enc_enhanced_set_mac_supported = B_FALSE;
1188
1189         /*
1190          * Check if firmware supports version 2 of MC_CMD_INIT_EVQ, which allows
1191          * us to let the firmware choose the settings to use on an EVQ.
1192          */
1193         if (CAP_FLAGS2(req, INIT_EVQ_V2))
1194                 encp->enc_init_evq_v2_supported = B_TRUE;
1195         else
1196                 encp->enc_init_evq_v2_supported = B_FALSE;
1197
1198         /*
1199          * Check if firmware-verified NVRAM updates must be used.
1200          *
1201          * The firmware trusted installer requires all NVRAM updates to use
1202          * version 2 of MC_CMD_NVRAM_UPDATE_START (to enable verified update)
1203          * and version 2 of MC_CMD_NVRAM_UPDATE_FINISH (to verify the updated
1204          * partition and report the result).
1205          */
1206         if (CAP_FLAGS2(req, NVRAM_UPDATE_REPORT_VERIFY_RESULT))
1207                 encp->enc_nvram_update_verify_result_supported = B_TRUE;
1208         else
1209                 encp->enc_nvram_update_verify_result_supported = B_FALSE;
1210
1211         /*
1212          * Check if firmware provides packet memory and Rx datapath
1213          * counters.
1214          */
1215         if (CAP_FLAGS1(req, PM_AND_RXDP_COUNTERS))
1216                 encp->enc_pm_and_rxdp_counters = B_TRUE;
1217         else
1218                 encp->enc_pm_and_rxdp_counters = B_FALSE;
1219
1220         /*
1221          * Check if the 40G MAC hardware is capable of reporting
1222          * statistics for Tx size bins.
1223          */
1224         if (CAP_FLAGS2(req, MAC_STATS_40G_TX_SIZE_BINS))
1225                 encp->enc_mac_stats_40g_tx_size_bins = B_TRUE;
1226         else
1227                 encp->enc_mac_stats_40g_tx_size_bins = B_FALSE;
1228
1229         /*
1230          * Check if firmware supports VXLAN and NVGRE tunnels.
1231          * The capability indicates Geneve protocol support as well.
1232          */
1233         if (CAP_FLAGS1(req, VXLAN_NVGRE)) {
1234                 encp->enc_tunnel_encapsulations_supported =
1235                     (1u << EFX_TUNNEL_PROTOCOL_VXLAN) |
1236                     (1u << EFX_TUNNEL_PROTOCOL_GENEVE) |
1237                     (1u << EFX_TUNNEL_PROTOCOL_NVGRE);
1238
1239                 EFX_STATIC_ASSERT(EFX_TUNNEL_MAXNENTRIES ==
1240                     MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES_MAXNUM);
1241                 encp->enc_tunnel_config_udp_entries_max =
1242                     EFX_TUNNEL_MAXNENTRIES;
1243         } else {
1244                 encp->enc_tunnel_config_udp_entries_max = 0;
1245         }
1246
1247         /*
1248          * Check if firmware reports the VI window mode.
1249          * Medford2 has a variable VI window size (8K, 16K or 64K).
1250          * Medford and Huntington have a fixed 8K VI window size.
1251          */
1252         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V3_OUT_LEN) {
1253                 uint8_t mode =
1254                     MCDI_OUT_BYTE(req, GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE);
1255
1256                 switch (mode) {
1257                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_8K:
1258                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_8K;
1259                         break;
1260                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_16K:
1261                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_16K;
1262                         break;
1263                 case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_64K:
1264                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_64K;
1265                         break;
1266                 default:
1267                         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_INVALID;
1268                         break;
1269                 }
1270         } else if ((enp->en_family == EFX_FAMILY_HUNTINGTON) ||
1271                     (enp->en_family == EFX_FAMILY_MEDFORD)) {
1272                 /* Huntington and Medford have fixed 8K window size */
1273                 encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_8K;
1274         } else {
1275                 encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_INVALID;
1276         }
1277
1278         /* Check if firmware supports extended MAC stats. */
1279         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V4_OUT_LEN) {
1280                 /* Extended stats buffer supported */
1281                 encp->enc_mac_stats_nstats = MCDI_OUT_WORD(req,
1282                     GET_CAPABILITIES_V4_OUT_MAC_STATS_NUM_STATS);
1283         } else {
1284                 /* Use Siena-compatible legacy MAC stats */
1285                 encp->enc_mac_stats_nstats = MC_CMD_MAC_NSTATS;
1286         }
1287
1288         if (encp->enc_mac_stats_nstats >= MC_CMD_MAC_NSTATS_V2)
1289                 encp->enc_fec_counters = B_TRUE;
1290         else
1291                 encp->enc_fec_counters = B_FALSE;
1292
1293         /* Check if the firmware provides head-of-line blocking counters */
1294         if (CAP_FLAGS2(req, RXDP_HLB_IDLE))
1295                 encp->enc_hlb_counters = B_TRUE;
1296         else
1297                 encp->enc_hlb_counters = B_FALSE;
1298
1299         if (CAP_FLAGS1(req, RX_RSS_LIMITED)) {
1300                 /* Only one exclusive RSS context is available per port. */
1301                 encp->enc_rx_scale_max_exclusive_contexts = 1;
1302
1303                 switch (enp->en_family) {
1304                 case EFX_FAMILY_MEDFORD2:
1305                         encp->enc_rx_scale_hash_alg_mask =
1306                             (1U << EFX_RX_HASHALG_TOEPLITZ);
1307                         break;
1308
1309                 case EFX_FAMILY_MEDFORD:
1310                 case EFX_FAMILY_HUNTINGTON:
1311                         /*
1312                          * Packed stream firmware variant maintains a
1313                          * non-standard algorithm for hash computation.
1314                          * It implies explicit XORing together
1315                          * source + destination IP addresses (or last
1316                          * four bytes in the case of IPv6) and using the
1317                          * resulting value as the input to a Toeplitz hash.
1318                          */
1319                         encp->enc_rx_scale_hash_alg_mask =
1320                             (1U << EFX_RX_HASHALG_PACKED_STREAM);
1321                         break;
1322
1323                 default:
1324                         rc = EINVAL;
1325                         goto fail5;
1326                 }
1327
1328                 /* Port numbers cannot contribute to the hash value */
1329                 encp->enc_rx_scale_l4_hash_supported = B_FALSE;
1330         } else {
1331                 /*
1332                  * Maximum number of exclusive RSS contexts.
1333                  * EF10 hardware supports 64 in total, but 6 are reserved
1334                  * for shared contexts. They are a global resource so
1335                  * not all may be available.
1336                  */
1337                 encp->enc_rx_scale_max_exclusive_contexts = 64 - 6;
1338
1339                 encp->enc_rx_scale_hash_alg_mask =
1340                     (1U << EFX_RX_HASHALG_TOEPLITZ);
1341
1342                 /*
1343                  * It is possible to use port numbers as
1344                  * the input data for hash computation.
1345                  */
1346                 encp->enc_rx_scale_l4_hash_supported = B_TRUE;
1347         }
1348         /* Check if the firmware supports "FLAG" and "MARK" filter actions */
1349         if (CAP_FLAGS2(req, FILTER_ACTION_FLAG))
1350                 encp->enc_filter_action_flag_supported = B_TRUE;
1351         else
1352                 encp->enc_filter_action_flag_supported = B_FALSE;
1353
1354         if (CAP_FLAGS2(req, FILTER_ACTION_MARK))
1355                 encp->enc_filter_action_mark_supported = B_TRUE;
1356         else
1357                 encp->enc_filter_action_mark_supported = B_FALSE;
1358
1359         /* Get maximum supported value for "MARK" filter action */
1360         if (req.emr_out_length_used >= MC_CMD_GET_CAPABILITIES_V5_OUT_LEN)
1361                 encp->enc_filter_action_mark_max = MCDI_OUT_DWORD(req,
1362                     GET_CAPABILITIES_V5_OUT_FILTER_ACTION_MARK_MAX);
1363         else
1364                 encp->enc_filter_action_mark_max = 0;
1365
1366 #undef CAP_FLAGS1
1367 #undef CAP_FLAGS2
1368
1369         return (0);
1370
1371 fail5:
1372         EFSYS_PROBE(fail5);
1373 fail4:
1374         EFSYS_PROBE(fail4);
1375 fail3:
1376         EFSYS_PROBE(fail3);
1377 fail2:
1378         EFSYS_PROBE(fail2);
1379 fail1:
1380         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1381
1382         return (rc);
1383 }
1384
1385
1386 #define EF10_LEGACY_PF_PRIVILEGE_MASK                                   \
1387         (MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN                     |       \
1388         MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK                       |       \
1389         MC_CMD_PRIVILEGE_MASK_IN_GRP_ONLOAD                     |       \
1390         MC_CMD_PRIVILEGE_MASK_IN_GRP_PTP                        |       \
1391         MC_CMD_PRIVILEGE_MASK_IN_GRP_INSECURE_FILTERS           |       \
1392         MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING               |       \
1393         MC_CMD_PRIVILEGE_MASK_IN_GRP_UNICAST                    |       \
1394         MC_CMD_PRIVILEGE_MASK_IN_GRP_MULTICAST                  |       \
1395         MC_CMD_PRIVILEGE_MASK_IN_GRP_BROADCAST                  |       \
1396         MC_CMD_PRIVILEGE_MASK_IN_GRP_ALL_MULTICAST              |       \
1397         MC_CMD_PRIVILEGE_MASK_IN_GRP_PROMISCUOUS)
1398
1399 #define EF10_LEGACY_VF_PRIVILEGE_MASK   0
1400
1401
1402         __checkReturn           efx_rc_t
1403 ef10_get_privilege_mask(
1404         __in                    efx_nic_t *enp,
1405         __out                   uint32_t *maskp)
1406 {
1407         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1408         uint32_t mask;
1409         efx_rc_t rc;
1410
1411         if ((rc = efx_mcdi_privilege_mask(enp, encp->enc_pf, encp->enc_vf,
1412                                             &mask)) != 0) {
1413                 if (rc != ENOTSUP)
1414                         goto fail1;
1415
1416                 /* Fallback for old firmware without privilege mask support */
1417                 if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1418                         /* Assume PF has admin privilege */
1419                         mask = EF10_LEGACY_PF_PRIVILEGE_MASK;
1420                 } else {
1421                         /* VF is always unprivileged by default */
1422                         mask = EF10_LEGACY_VF_PRIVILEGE_MASK;
1423                 }
1424         }
1425
1426         *maskp = mask;
1427
1428         return (0);
1429
1430 fail1:
1431         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1432
1433         return (rc);
1434 }
1435
1436
1437 /*
1438  * Table of mapping schemes from port number to external number.
1439  *
1440  * Each port number ultimately corresponds to a connector: either as part of
1441  * a cable assembly attached to a module inserted in an SFP+/QSFP+ cage on
1442  * the board, or fixed to the board (e.g. 10GBASE-T magjack on SFN5121T
1443  * "Salina"). In general:
1444  *
1445  * Port number (0-based)
1446  *     |
1447  *   port mapping (n:1)
1448  *     |
1449  *     v
1450  * External port number (normally 1-based)
1451  *     |
1452  *   fixed (1:1) or cable assembly (1:m)
1453  *     |
1454  *     v
1455  * Connector
1456  *
1457  * The external numbering refers to the cages or magjacks on the board,
1458  * as visibly annotated on the board or back panel. This table describes
1459  * how to determine which external cage/magjack corresponds to the port
1460  * numbers used by the driver.
1461  *
1462  * The count of adjacent port numbers that map to each external number,
1463  * and the offset in the numbering, is determined by the chip family and
1464  * current port mode.
1465  *
1466  * For the Huntington family, the current port mode cannot be discovered,
1467  * but a single mapping is used by all modes for a given chip variant,
1468  * so the mapping used is instead the last match in the table to the full
1469  * set of port modes to which the NIC can be configured. Therefore the
1470  * ordering of entries in the mapping table is significant.
1471  */
1472 static struct ef10_external_port_map_s {
1473         efx_family_t    family;
1474         uint32_t        modes_mask;
1475         int32_t         count;
1476         int32_t         offset;
1477 }       __ef10_external_port_mappings[] = {
1478         /*
1479          * Modes used by Huntington family controllers where each port
1480          * number maps to a separate cage.
1481          * SFN7x22F (Torino):
1482          *      port 0 -> cage 1
1483          *      port 1 -> cage 2
1484          * SFN7xx4F (Pavia):
1485          *      port 0 -> cage 1
1486          *      port 1 -> cage 2
1487          *      port 2 -> cage 3
1488          *      port 3 -> cage 4
1489          */
1490         {
1491                 EFX_FAMILY_HUNTINGTON,
1492                 (1U << TLV_PORT_MODE_10G) |                     /* mode 0 */
1493                 (1U << TLV_PORT_MODE_10G_10G) |                 /* mode 2 */
1494                 (1U << TLV_PORT_MODE_10G_10G_10G_10G),          /* mode 4 */
1495                 1,      /* ports per cage */
1496                 1       /* first cage */
1497         },
1498         /*
1499          * Modes which for Huntington identify a chip variant where 2
1500          * adjacent port numbers map to each cage.
1501          * SFN7x42Q (Monza):
1502          *      port 0 -> cage 1
1503          *      port 1 -> cage 1
1504          *      port 2 -> cage 2
1505          *      port 3 -> cage 2
1506          */
1507         {
1508                 EFX_FAMILY_HUNTINGTON,
1509                 (1U << TLV_PORT_MODE_40G) |                     /* mode 1 */
1510                 (1U << TLV_PORT_MODE_40G_40G) |                 /* mode 3 */
1511                 (1U << TLV_PORT_MODE_40G_10G_10G) |             /* mode 6 */
1512                 (1U << TLV_PORT_MODE_10G_10G_40G),              /* mode 7 */
1513                 2,      /* ports per cage */
1514                 1       /* first cage */
1515         },
1516         /*
1517          * Modes that on Medford allocate each port number to a separate
1518          * cage.
1519          *      port 0 -> cage 1
1520          *      port 1 -> cage 2
1521          *      port 2 -> cage 3
1522          *      port 3 -> cage 4
1523          */
1524         {
1525                 EFX_FAMILY_MEDFORD,
1526                 (1U << TLV_PORT_MODE_1x1_NA) |                  /* mode 0 */
1527                 (1U << TLV_PORT_MODE_1x1_1x1),                  /* mode 2 */
1528                 1,      /* ports per cage */
1529                 1       /* first cage */
1530         },
1531         /*
1532          * Modes that on Medford allocate 2 adjacent port numbers to each
1533          * cage.
1534          *      port 0 -> cage 1
1535          *      port 1 -> cage 1
1536          *      port 2 -> cage 2
1537          *      port 3 -> cage 2
1538          */
1539         {
1540                 EFX_FAMILY_MEDFORD,
1541                 (1U << TLV_PORT_MODE_1x4_NA) |                  /* mode 1 */
1542                 (1U << TLV_PORT_MODE_1x4_1x4) |                 /* mode 3 */
1543                 (1U << TLV_PORT_MODE_1x4_2x1) |                 /* mode 6 */
1544                 (1U << TLV_PORT_MODE_2x1_1x4) |                 /* mode 7 */
1545                 /* Do not use 10G_10G_10G_10G_Q1_Q2 (see bug63270) */
1546                 (1U << TLV_PORT_MODE_10G_10G_10G_10G_Q1_Q2),    /* mode 9 */
1547                 2,      /* ports per cage */
1548                 1       /* first cage */
1549         },
1550         /*
1551          * Modes that on Medford allocate 4 adjacent port numbers to each
1552          * connector, starting on cage 1.
1553          *      port 0 -> cage 1
1554          *      port 1 -> cage 1
1555          *      port 2 -> cage 1
1556          *      port 3 -> cage 1
1557          */
1558         {
1559                 EFX_FAMILY_MEDFORD,
1560                 (1U << TLV_PORT_MODE_2x1_2x1) |                 /* mode 5 */
1561                 /* Do not use 10G_10G_10G_10G_Q1 (see bug63270) */
1562                 (1U << TLV_PORT_MODE_4x1_NA),                   /* mode 4 */
1563                 4,      /* ports per cage */
1564                 1       /* first cage */
1565         },
1566         /*
1567          * Modes that on Medford allocate 4 adjacent port numbers to each
1568          * connector, starting on cage 2.
1569          *      port 0 -> cage 2
1570          *      port 1 -> cage 2
1571          *      port 2 -> cage 2
1572          *      port 3 -> cage 2
1573          */
1574         {
1575                 EFX_FAMILY_MEDFORD,
1576                 (1U << TLV_PORT_MODE_NA_4x1),                   /* mode 8 */
1577                 4,      /* ports per cage */
1578                 2       /* first cage */
1579         },
1580         /*
1581          * Modes that on Medford2 allocate each port number to a separate
1582          * cage.
1583          *      port 0 -> cage 1
1584          *      port 1 -> cage 2
1585          *      port 2 -> cage 3
1586          *      port 3 -> cage 4
1587          */
1588         {
1589                 EFX_FAMILY_MEDFORD2,
1590                 (1U << TLV_PORT_MODE_1x1_NA) |                  /* mode 0 */
1591                 (1U << TLV_PORT_MODE_1x4_NA) |                  /* mode 1 */
1592                 (1U << TLV_PORT_MODE_1x1_1x1) |                 /* mode 2 */
1593                 (1U << TLV_PORT_MODE_1x2_NA) |                  /* mode 10 */
1594                 (1U << TLV_PORT_MODE_1x2_1x2) |                 /* mode 12 */
1595                 (1U << TLV_PORT_MODE_1x4_1x2) |                 /* mode 15 */
1596                 (1U << TLV_PORT_MODE_1x2_1x4),                  /* mode 16 */
1597                 1,      /* ports per cage */
1598                 1       /* first cage */
1599         },
1600         /*
1601          * FIXME: Some port modes are not representable in this mapping:
1602          *  - TLV_PORT_MODE_1x2_2x1 (mode 17):
1603          *      port 0 -> cage 1
1604          *      port 1 -> cage 2
1605          *      port 2 -> cage 2
1606          */
1607         /*
1608          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1609          * cage, starting on cage 1.
1610          *      port 0 -> cage 1
1611          *      port 1 -> cage 1
1612          *      port 2 -> cage 2
1613          *      port 3 -> cage 2
1614          */
1615         {
1616                 EFX_FAMILY_MEDFORD2,
1617                 (1U << TLV_PORT_MODE_1x4_1x4) |                 /* mode 3 */
1618                 (1U << TLV_PORT_MODE_2x1_2x1) |                 /* mode 4 */
1619                 (1U << TLV_PORT_MODE_1x4_2x1) |                 /* mode 6 */
1620                 (1U << TLV_PORT_MODE_2x1_1x4) |                 /* mode 7 */
1621                 (1U << TLV_PORT_MODE_2x2_NA) |                  /* mode 13 */
1622                 (1U << TLV_PORT_MODE_2x1_1x2),                  /* mode 18 */
1623                 2,      /* ports per cage */
1624                 1       /* first cage */
1625         },
1626         /*
1627          * Modes that on Medford2 allocate 2 adjacent port numbers to each
1628          * cage, starting on cage 2.
1629          *      port 0 -> cage 2
1630          *      port 1 -> cage 2
1631          */
1632         {
1633                 EFX_FAMILY_MEDFORD2,
1634                 (1U << TLV_PORT_MODE_NA_2x2),                   /* mode 14 */
1635                 2,      /* ports per cage */
1636                 2       /* first cage */
1637         },
1638         /*
1639          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1640          * connector, starting on cage 1.
1641          *      port 0 -> cage 1
1642          *      port 1 -> cage 1
1643          *      port 2 -> cage 1
1644          *      port 3 -> cage 1
1645          */
1646         {
1647                 EFX_FAMILY_MEDFORD2,
1648                 (1U << TLV_PORT_MODE_4x1_NA),                   /* mode 5 */
1649                 4,      /* ports per cage */
1650                 1       /* first cage */
1651         },
1652         /*
1653          * Modes that on Medford2 allocate 4 adjacent port numbers to each
1654          * connector, starting on cage 2.
1655          *      port 0 -> cage 2
1656          *      port 1 -> cage 2
1657          *      port 2 -> cage 2
1658          *      port 3 -> cage 2
1659          */
1660         {
1661                 EFX_FAMILY_MEDFORD2,
1662                 (1U << TLV_PORT_MODE_NA_4x1) |                  /* mode 8 */
1663                 (1U << TLV_PORT_MODE_NA_1x2),                   /* mode 11 */
1664                 4,      /* ports per cage */
1665                 2       /* first cage */
1666         },
1667 };
1668
1669 static  __checkReturn   efx_rc_t
1670 ef10_external_port_mapping(
1671         __in            efx_nic_t *enp,
1672         __in            uint32_t port,
1673         __out           uint8_t *external_portp)
1674 {
1675         efx_rc_t rc;
1676         int i;
1677         uint32_t port_modes;
1678         uint32_t matches;
1679         uint32_t current;
1680         int32_t count = 1; /* Default 1-1 mapping */
1681         int32_t offset = 1; /* Default starting external port number */
1682
1683         if ((rc = efx_mcdi_get_port_modes(enp, &port_modes, &current,
1684                     NULL)) != 0) {
1685                 /*
1686                  * No current port mode information (i.e. Huntington)
1687                  * - infer mapping from available modes
1688                  */
1689                 if ((rc = efx_mcdi_get_port_modes(enp,
1690                             &port_modes, NULL, NULL)) != 0) {
1691                         /*
1692                          * No port mode information available
1693                          * - use default mapping
1694                          */
1695                         goto out;
1696                 }
1697         } else {
1698                 /* Only need to scan the current mode */
1699                 port_modes = 1 << current;
1700         }
1701
1702         /*
1703          * Infer the internal port -> external number mapping from
1704          * the possible port modes for this NIC.
1705          */
1706         for (i = 0; i < EFX_ARRAY_SIZE(__ef10_external_port_mappings); ++i) {
1707                 struct ef10_external_port_map_s *eepmp =
1708                     &__ef10_external_port_mappings[i];
1709                 if (eepmp->family != enp->en_family)
1710                         continue;
1711                 matches = (eepmp->modes_mask & port_modes);
1712                 if (matches != 0) {
1713                         /*
1714                          * Some modes match. For some Huntington boards
1715                          * there will be multiple matches. The mapping on the
1716                          * last match is used.
1717                          */
1718                         count = eepmp->count;
1719                         offset = eepmp->offset;
1720                         port_modes &= ~matches;
1721                 }
1722         }
1723
1724         if (port_modes != 0) {
1725                 /* Some advertised modes are not supported */
1726                 rc = ENOTSUP;
1727                 goto fail1;
1728         }
1729
1730 out:
1731         /*
1732          * Scale as required by last matched mode and then convert to
1733          * correctly offset numbering
1734          */
1735         *external_portp = (uint8_t)((port / count) + offset);
1736         return (0);
1737
1738 fail1:
1739         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1740
1741         return (rc);
1742 }
1743
1744 static  __checkReturn   efx_rc_t
1745 ef10_nic_board_cfg(
1746         __in            efx_nic_t *enp)
1747 {
1748         const efx_nic_ops_t *enop = enp->en_enop;
1749         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
1750         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1751         ef10_link_state_t els;
1752         efx_port_t *epp = &(enp->en_port);
1753         uint32_t board_type = 0;
1754         uint32_t base, nvec;
1755         uint32_t port;
1756         uint32_t mask;
1757         uint32_t pf;
1758         uint32_t vf;
1759         uint8_t mac_addr[6] = { 0 };
1760         efx_rc_t rc;
1761
1762         /* Get the (zero-based) MCDI port number */
1763         if ((rc = efx_mcdi_get_port_assignment(enp, &port)) != 0)
1764                 goto fail1;
1765
1766         /* EFX MCDI interface uses one-based port numbers */
1767         emip->emi_port = port + 1;
1768
1769         if ((rc = ef10_external_port_mapping(enp, port,
1770                     &encp->enc_external_port)) != 0)
1771                 goto fail2;
1772
1773         /*
1774          * Get PCIe function number from firmware (used for
1775          * per-function privilege and dynamic config info).
1776          *  - PCIe PF: pf = PF number, vf = 0xffff.
1777          *  - PCIe VF: pf = parent PF, vf = VF number.
1778          */
1779         if ((rc = efx_mcdi_get_function_info(enp, &pf, &vf)) != 0)
1780                 goto fail3;
1781
1782         encp->enc_pf = pf;
1783         encp->enc_vf = vf;
1784
1785         /* MAC address for this function */
1786         if (EFX_PCI_FUNCTION_IS_PF(encp)) {
1787                 rc = efx_mcdi_get_mac_address_pf(enp, mac_addr);
1788 #if EFSYS_OPT_ALLOW_UNCONFIGURED_NIC
1789                 /*
1790                  * Disable static config checking, ONLY for manufacturing test
1791                  * and setup at the factory, to allow the static config to be
1792                  * installed.
1793                  */
1794 #else /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1795                 if ((rc == 0) && (mac_addr[0] & 0x02)) {
1796                         /*
1797                          * If the static config does not include a global MAC
1798                          * address pool then the board may return a locally
1799                          * administered MAC address (this should only happen on
1800                          * incorrectly programmed boards).
1801                          */
1802                         rc = EINVAL;
1803                 }
1804 #endif /* EFSYS_OPT_ALLOW_UNCONFIGURED_NIC */
1805         } else {
1806                 rc = efx_mcdi_get_mac_address_vf(enp, mac_addr);
1807         }
1808         if (rc != 0)
1809                 goto fail4;
1810
1811         EFX_MAC_ADDR_COPY(encp->enc_mac_addr, mac_addr);
1812
1813         /* Board configuration (legacy) */
1814         rc = efx_mcdi_get_board_cfg(enp, &board_type, NULL, NULL);
1815         if (rc != 0) {
1816                 /* Unprivileged functions may not be able to read board cfg */
1817                 if (rc == EACCES)
1818                         board_type = 0;
1819                 else
1820                         goto fail5;
1821         }
1822
1823         encp->enc_board_type = board_type;
1824         encp->enc_clk_mult = 1; /* not used for EF10 */
1825
1826         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
1827         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
1828                 goto fail6;
1829
1830         /*
1831          * Firmware with support for *_FEC capability bits does not
1832          * report that the corresponding *_FEC_REQUESTED bits are supported.
1833          * Add them here so that drivers understand that they are supported.
1834          */
1835         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_BASER_FEC))
1836                 epp->ep_phy_cap_mask |=
1837                     (1u << EFX_PHY_CAP_BASER_FEC_REQUESTED);
1838         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_RS_FEC))
1839                 epp->ep_phy_cap_mask |=
1840                     (1u << EFX_PHY_CAP_RS_FEC_REQUESTED);
1841         if (epp->ep_phy_cap_mask & (1u << EFX_PHY_CAP_25G_BASER_FEC))
1842                 epp->ep_phy_cap_mask |=
1843                     (1u << EFX_PHY_CAP_25G_BASER_FEC_REQUESTED);
1844
1845         /* Obtain the default PHY advertised capabilities */
1846         if ((rc = ef10_phy_get_link(enp, &els)) != 0)
1847                 goto fail7;
1848         epp->ep_default_adv_cap_mask = els.els_adv_cap_mask;
1849         epp->ep_adv_cap_mask = els.els_adv_cap_mask;
1850
1851         /* Check capabilities of running datapath firmware */
1852         if ((rc = ef10_get_datapath_caps(enp)) != 0)
1853                 goto fail8;
1854
1855         /* Alignment for WPTR updates */
1856         encp->enc_rx_push_align = EF10_RX_WPTR_ALIGN;
1857
1858         encp->enc_tx_dma_desc_size_max = EFX_MASK32(ESF_DZ_RX_KER_BYTE_CNT);
1859         /* No boundary crossing limits */
1860         encp->enc_tx_dma_desc_boundary = 0;
1861
1862         /*
1863          * Maximum number of bytes into the frame the TCP header can start for
1864          * firmware assisted TSO to work.
1865          */
1866         encp->enc_tx_tso_tcp_header_offset_limit = EF10_TCP_HEADER_OFFSET_LIMIT;
1867
1868         /*
1869          * Set resource limits for MC_CMD_ALLOC_VIS. Note that we cannot use
1870          * MC_CMD_GET_RESOURCE_LIMITS here as that reports the available
1871          * resources (allocated to this PCIe function), which is zero until
1872          * after we have allocated VIs.
1873          */
1874         encp->enc_evq_limit = 1024;
1875         encp->enc_rxq_limit = EFX_RXQ_LIMIT_TARGET;
1876         encp->enc_txq_limit = EFX_TXQ_LIMIT_TARGET;
1877
1878         encp->enc_buftbl_limit = 0xFFFFFFFF;
1879
1880         /* Get interrupt vector limits */
1881         if ((rc = efx_mcdi_get_vector_cfg(enp, &base, &nvec, NULL)) != 0) {
1882                 if (EFX_PCI_FUNCTION_IS_PF(encp))
1883                         goto fail9;
1884
1885                 /* Ignore error (cannot query vector limits from a VF). */
1886                 base = 0;
1887                 nvec = 1024;
1888         }
1889         encp->enc_intr_vec_base = base;
1890         encp->enc_intr_limit = nvec;
1891
1892         /*
1893          * Get the current privilege mask. Note that this may be modified
1894          * dynamically, so this value is informational only. DO NOT use
1895          * the privilege mask to check for sufficient privileges, as that
1896          * can result in time-of-check/time-of-use bugs.
1897          */
1898         if ((rc = ef10_get_privilege_mask(enp, &mask)) != 0)
1899                 goto fail10;
1900         encp->enc_privilege_mask = mask;
1901
1902         /* Get remaining controller-specific board config */
1903         if ((rc = enop->eno_board_cfg(enp)) != 0)
1904                 if (rc != EACCES)
1905                         goto fail11;
1906
1907         return (0);
1908
1909 fail11:
1910         EFSYS_PROBE(fail11);
1911 fail10:
1912         EFSYS_PROBE(fail10);
1913 fail9:
1914         EFSYS_PROBE(fail9);
1915 fail8:
1916         EFSYS_PROBE(fail8);
1917 fail7:
1918         EFSYS_PROBE(fail7);
1919 fail6:
1920         EFSYS_PROBE(fail6);
1921 fail5:
1922         EFSYS_PROBE(fail5);
1923 fail4:
1924         EFSYS_PROBE(fail4);
1925 fail3:
1926         EFSYS_PROBE(fail3);
1927 fail2:
1928         EFSYS_PROBE(fail2);
1929 fail1:
1930         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1931
1932         return (rc);
1933 }
1934
1935         __checkReturn   efx_rc_t
1936 ef10_nic_probe(
1937         __in            efx_nic_t *enp)
1938 {
1939         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1940         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
1941         efx_rc_t rc;
1942
1943         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
1944             enp->en_family == EFX_FAMILY_MEDFORD ||
1945             enp->en_family == EFX_FAMILY_MEDFORD2);
1946
1947         /* Read and clear any assertion state */
1948         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
1949                 goto fail1;
1950
1951         /* Exit the assertion handler */
1952         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
1953                 if (rc != EACCES)
1954                         goto fail2;
1955
1956         if ((rc = efx_mcdi_drv_attach(enp, B_TRUE)) != 0)
1957                 goto fail3;
1958
1959         if ((rc = ef10_nic_board_cfg(enp)) != 0)
1960                 goto fail4;
1961
1962         /*
1963          * Set default driver config limits (based on board config).
1964          *
1965          * FIXME: For now allocate a fixed number of VIs which is likely to be
1966          * sufficient and small enough to allow multiple functions on the same
1967          * port.
1968          */
1969         edcp->edc_min_vi_count = edcp->edc_max_vi_count =
1970             MIN(128, MAX(encp->enc_rxq_limit, encp->enc_txq_limit));
1971
1972         /* The client driver must configure and enable PIO buffer support */
1973         edcp->edc_max_piobuf_count = 0;
1974         edcp->edc_pio_alloc_size = 0;
1975
1976 #if EFSYS_OPT_MAC_STATS
1977         /* Wipe the MAC statistics */
1978         if ((rc = efx_mcdi_mac_stats_clear(enp)) != 0)
1979                 goto fail5;
1980 #endif
1981
1982 #if EFSYS_OPT_LOOPBACK
1983         if ((rc = efx_mcdi_get_loopback_modes(enp)) != 0)
1984                 goto fail6;
1985 #endif
1986
1987 #if EFSYS_OPT_MON_STATS
1988         if ((rc = mcdi_mon_cfg_build(enp)) != 0) {
1989                 /* Unprivileged functions do not have access to sensors */
1990                 if (rc != EACCES)
1991                         goto fail7;
1992         }
1993 #endif
1994
1995         encp->enc_features = enp->en_features;
1996
1997         return (0);
1998
1999 #if EFSYS_OPT_MON_STATS
2000 fail7:
2001         EFSYS_PROBE(fail7);
2002 #endif
2003 #if EFSYS_OPT_LOOPBACK
2004 fail6:
2005         EFSYS_PROBE(fail6);
2006 #endif
2007 #if EFSYS_OPT_MAC_STATS
2008 fail5:
2009         EFSYS_PROBE(fail5);
2010 #endif
2011 fail4:
2012         EFSYS_PROBE(fail4);
2013 fail3:
2014         EFSYS_PROBE(fail3);
2015 fail2:
2016         EFSYS_PROBE(fail2);
2017 fail1:
2018         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2019
2020         return (rc);
2021 }
2022
2023         __checkReturn   efx_rc_t
2024 ef10_nic_set_drv_limits(
2025         __inout         efx_nic_t *enp,
2026         __in            efx_drv_limits_t *edlp)
2027 {
2028         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
2029         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
2030         uint32_t min_evq_count, max_evq_count;
2031         uint32_t min_rxq_count, max_rxq_count;
2032         uint32_t min_txq_count, max_txq_count;
2033         efx_rc_t rc;
2034
2035         if (edlp == NULL) {
2036                 rc = EINVAL;
2037                 goto fail1;
2038         }
2039
2040         /* Get minimum required and maximum usable VI limits */
2041         min_evq_count = MIN(edlp->edl_min_evq_count, encp->enc_evq_limit);
2042         min_rxq_count = MIN(edlp->edl_min_rxq_count, encp->enc_rxq_limit);
2043         min_txq_count = MIN(edlp->edl_min_txq_count, encp->enc_txq_limit);
2044
2045         edcp->edc_min_vi_count =
2046             MAX(min_evq_count, MAX(min_rxq_count, min_txq_count));
2047
2048         max_evq_count = MIN(edlp->edl_max_evq_count, encp->enc_evq_limit);
2049         max_rxq_count = MIN(edlp->edl_max_rxq_count, encp->enc_rxq_limit);
2050         max_txq_count = MIN(edlp->edl_max_txq_count, encp->enc_txq_limit);
2051
2052         edcp->edc_max_vi_count =
2053             MAX(max_evq_count, MAX(max_rxq_count, max_txq_count));
2054
2055         /*
2056          * Check limits for sub-allocated piobuf blocks.
2057          * PIO is optional, so don't fail if the limits are incorrect.
2058          */
2059         if ((encp->enc_piobuf_size == 0) ||
2060             (encp->enc_piobuf_limit == 0) ||
2061             (edlp->edl_min_pio_alloc_size == 0) ||
2062             (edlp->edl_min_pio_alloc_size > encp->enc_piobuf_size)) {
2063                 /* Disable PIO */
2064                 edcp->edc_max_piobuf_count = 0;
2065                 edcp->edc_pio_alloc_size = 0;
2066         } else {
2067                 uint32_t blk_size, blk_count, blks_per_piobuf;
2068
2069                 blk_size =
2070                     MAX(edlp->edl_min_pio_alloc_size,
2071                             encp->enc_piobuf_min_alloc_size);
2072
2073                 blks_per_piobuf = encp->enc_piobuf_size / blk_size;
2074                 EFSYS_ASSERT3U(blks_per_piobuf, <=, 32);
2075
2076                 blk_count = (encp->enc_piobuf_limit * blks_per_piobuf);
2077
2078                 /* A zero max pio alloc count means unlimited */
2079                 if ((edlp->edl_max_pio_alloc_count > 0) &&
2080                     (edlp->edl_max_pio_alloc_count < blk_count)) {
2081                         blk_count = edlp->edl_max_pio_alloc_count;
2082                 }
2083
2084                 edcp->edc_pio_alloc_size = blk_size;
2085                 edcp->edc_max_piobuf_count =
2086                     (blk_count + (blks_per_piobuf - 1)) / blks_per_piobuf;
2087         }
2088
2089         return (0);
2090
2091 fail1:
2092         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2093
2094         return (rc);
2095 }
2096
2097
2098         __checkReturn   efx_rc_t
2099 ef10_nic_reset(
2100         __in            efx_nic_t *enp)
2101 {
2102         efx_mcdi_req_t req;
2103         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_ENTITY_RESET_IN_LEN,
2104                 MC_CMD_ENTITY_RESET_OUT_LEN);
2105         efx_rc_t rc;
2106
2107         /* ef10_nic_reset() is called to recover from BADASSERT failures. */
2108         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
2109                 goto fail1;
2110         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
2111                 goto fail2;
2112
2113         req.emr_cmd = MC_CMD_ENTITY_RESET;
2114         req.emr_in_buf = payload;
2115         req.emr_in_length = MC_CMD_ENTITY_RESET_IN_LEN;
2116         req.emr_out_buf = payload;
2117         req.emr_out_length = MC_CMD_ENTITY_RESET_OUT_LEN;
2118
2119         MCDI_IN_POPULATE_DWORD_1(req, ENTITY_RESET_IN_FLAG,
2120             ENTITY_RESET_IN_FUNCTION_RESOURCE_RESET, 1);
2121
2122         efx_mcdi_execute(enp, &req);
2123
2124         if (req.emr_rc != 0) {
2125                 rc = req.emr_rc;
2126                 goto fail3;
2127         }
2128
2129         /* Clear RX/TX DMA queue errors */
2130         enp->en_reset_flags &= ~(EFX_RESET_RXQ_ERR | EFX_RESET_TXQ_ERR);
2131
2132         return (0);
2133
2134 fail3:
2135         EFSYS_PROBE(fail3);
2136 fail2:
2137         EFSYS_PROBE(fail2);
2138 fail1:
2139         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2140
2141         return (rc);
2142 }
2143
2144         __checkReturn   efx_rc_t
2145 ef10_nic_init(
2146         __in            efx_nic_t *enp)
2147 {
2148         efx_drv_cfg_t *edcp = &(enp->en_drv_cfg);
2149         uint32_t min_vi_count, max_vi_count;
2150         uint32_t vi_count, vi_base, vi_shift;
2151         uint32_t i;
2152         uint32_t retry;
2153         uint32_t delay_us;
2154         uint32_t vi_window_size;
2155         efx_rc_t rc;
2156
2157         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2158             enp->en_family == EFX_FAMILY_MEDFORD ||
2159             enp->en_family == EFX_FAMILY_MEDFORD2);
2160
2161         /* Enable reporting of some events (e.g. link change) */
2162         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
2163                 goto fail1;
2164
2165         /* Allocate (optional) on-chip PIO buffers */
2166         ef10_nic_alloc_piobufs(enp, edcp->edc_max_piobuf_count);
2167
2168         /*
2169          * For best performance, PIO writes should use a write-combined
2170          * (WC) memory mapping. Using a separate WC mapping for the PIO
2171          * aperture of each VI would be a burden to drivers (and not
2172          * possible if the host page size is >4Kbyte).
2173          *
2174          * To avoid this we use a single uncached (UC) mapping for VI
2175          * register access, and a single WC mapping for extra VIs used
2176          * for PIO writes.
2177          *
2178          * Each piobuf must be linked to a VI in the WC mapping, and to
2179          * each VI that is using a sub-allocated block from the piobuf.
2180          */
2181         min_vi_count = edcp->edc_min_vi_count;
2182         max_vi_count =
2183             edcp->edc_max_vi_count + enp->en_arch.ef10.ena_piobuf_count;
2184
2185         /* Ensure that the previously attached driver's VIs are freed */
2186         if ((rc = efx_mcdi_free_vis(enp)) != 0)
2187                 goto fail2;
2188
2189         /*
2190          * Reserve VI resources (EVQ+RXQ+TXQ) for this PCIe function. If this
2191          * fails then retrying the request for fewer VI resources may succeed.
2192          */
2193         vi_count = 0;
2194         if ((rc = efx_mcdi_alloc_vis(enp, min_vi_count, max_vi_count,
2195                     &vi_base, &vi_count, &vi_shift)) != 0)
2196                 goto fail3;
2197
2198         EFSYS_PROBE2(vi_alloc, uint32_t, vi_base, uint32_t, vi_count);
2199
2200         if (vi_count < min_vi_count) {
2201                 rc = ENOMEM;
2202                 goto fail4;
2203         }
2204
2205         enp->en_arch.ef10.ena_vi_base = vi_base;
2206         enp->en_arch.ef10.ena_vi_count = vi_count;
2207         enp->en_arch.ef10.ena_vi_shift = vi_shift;
2208
2209         if (vi_count < min_vi_count + enp->en_arch.ef10.ena_piobuf_count) {
2210                 /* Not enough extra VIs to map piobufs */
2211                 ef10_nic_free_piobufs(enp);
2212         }
2213
2214         enp->en_arch.ef10.ena_pio_write_vi_base =
2215             vi_count - enp->en_arch.ef10.ena_piobuf_count;
2216
2217         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, !=,
2218             EFX_VI_WINDOW_SHIFT_INVALID);
2219         EFSYS_ASSERT3U(enp->en_nic_cfg.enc_vi_window_shift, <=,
2220             EFX_VI_WINDOW_SHIFT_64K);
2221         vi_window_size = 1U << enp->en_nic_cfg.enc_vi_window_shift;
2222
2223         /* Save UC memory mapping details */
2224         enp->en_arch.ef10.ena_uc_mem_map_offset = 0;
2225         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2226                 enp->en_arch.ef10.ena_uc_mem_map_size =
2227                     (vi_window_size *
2228                     enp->en_arch.ef10.ena_pio_write_vi_base);
2229         } else {
2230                 enp->en_arch.ef10.ena_uc_mem_map_size =
2231                     (vi_window_size *
2232                     enp->en_arch.ef10.ena_vi_count);
2233         }
2234
2235         /* Save WC memory mapping details */
2236         enp->en_arch.ef10.ena_wc_mem_map_offset =
2237             enp->en_arch.ef10.ena_uc_mem_map_offset +
2238             enp->en_arch.ef10.ena_uc_mem_map_size;
2239
2240         enp->en_arch.ef10.ena_wc_mem_map_size =
2241             (vi_window_size *
2242             enp->en_arch.ef10.ena_piobuf_count);
2243
2244         /* Link piobufs to extra VIs in WC mapping */
2245         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2246                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2247                         rc = efx_mcdi_link_piobuf(enp,
2248                             enp->en_arch.ef10.ena_pio_write_vi_base + i,
2249                             enp->en_arch.ef10.ena_piobuf_handle[i]);
2250                         if (rc != 0)
2251                                 break;
2252                 }
2253         }
2254
2255         /*
2256          * Allocate a vAdaptor attached to our upstream vPort/pPort.
2257          *
2258          * On a VF, this may fail with MC_CMD_ERR_NO_EVB_PORT (ENOENT) if the PF
2259          * driver has yet to bring up the EVB port. See bug 56147. In this case,
2260          * retry the request several times after waiting a while. The wait time
2261          * between retries starts small (10ms) and exponentially increases.
2262          * Total wait time is a little over two seconds. Retry logic in the
2263          * client driver may mean this whole loop is repeated if it continues to
2264          * fail.
2265          */
2266         retry = 0;
2267         delay_us = 10000;
2268         while ((rc = efx_mcdi_vadaptor_alloc(enp, EVB_PORT_ID_ASSIGNED)) != 0) {
2269                 if (EFX_PCI_FUNCTION_IS_PF(&enp->en_nic_cfg) ||
2270                     (rc != ENOENT)) {
2271                         /*
2272                          * Do not retry alloc for PF, or for other errors on
2273                          * a VF.
2274                          */
2275                         goto fail5;
2276                 }
2277
2278                 /* VF startup before PF is ready. Retry allocation. */
2279                 if (retry > 5) {
2280                         /* Too many attempts */
2281                         rc = EINVAL;
2282                         goto fail6;
2283                 }
2284                 EFSYS_PROBE1(mcdi_no_evb_port_retry, int, retry);
2285                 EFSYS_SLEEP(delay_us);
2286                 retry++;
2287                 if (delay_us < 500000)
2288                         delay_us <<= 2;
2289         }
2290
2291         enp->en_vport_id = EVB_PORT_ID_ASSIGNED;
2292         enp->en_nic_cfg.enc_mcdi_max_payload_length = MCDI_CTL_SDU_LEN_MAX_V2;
2293
2294         return (0);
2295
2296 fail6:
2297         EFSYS_PROBE(fail6);
2298 fail5:
2299         EFSYS_PROBE(fail5);
2300 fail4:
2301         EFSYS_PROBE(fail4);
2302 fail3:
2303         EFSYS_PROBE(fail3);
2304 fail2:
2305         EFSYS_PROBE(fail2);
2306
2307         ef10_nic_free_piobufs(enp);
2308
2309 fail1:
2310         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2311
2312         return (rc);
2313 }
2314
2315         __checkReturn   efx_rc_t
2316 ef10_nic_get_vi_pool(
2317         __in            efx_nic_t *enp,
2318         __out           uint32_t *vi_countp)
2319 {
2320         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2321             enp->en_family == EFX_FAMILY_MEDFORD ||
2322             enp->en_family == EFX_FAMILY_MEDFORD2);
2323
2324         /*
2325          * Report VIs that the client driver can use.
2326          * Do not include VIs used for PIO buffer writes.
2327          */
2328         *vi_countp = enp->en_arch.ef10.ena_pio_write_vi_base;
2329
2330         return (0);
2331 }
2332
2333         __checkReturn   efx_rc_t
2334 ef10_nic_get_bar_region(
2335         __in            efx_nic_t *enp,
2336         __in            efx_nic_region_t region,
2337         __out           uint32_t *offsetp,
2338         __out           size_t *sizep)
2339 {
2340         efx_rc_t rc;
2341
2342         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
2343             enp->en_family == EFX_FAMILY_MEDFORD ||
2344             enp->en_family == EFX_FAMILY_MEDFORD2);
2345
2346         /*
2347          * TODO: Specify host memory mapping alignment and granularity
2348          * in efx_drv_limits_t so that they can be taken into account
2349          * when allocating extra VIs for PIO writes.
2350          */
2351         switch (region) {
2352         case EFX_REGION_VI:
2353                 /* UC mapped memory BAR region for VI registers */
2354                 *offsetp = enp->en_arch.ef10.ena_uc_mem_map_offset;
2355                 *sizep = enp->en_arch.ef10.ena_uc_mem_map_size;
2356                 break;
2357
2358         case EFX_REGION_PIO_WRITE_VI:
2359                 /* WC mapped memory BAR region for piobuf writes */
2360                 *offsetp = enp->en_arch.ef10.ena_wc_mem_map_offset;
2361                 *sizep = enp->en_arch.ef10.ena_wc_mem_map_size;
2362                 break;
2363
2364         default:
2365                 rc = EINVAL;
2366                 goto fail1;
2367         }
2368
2369         return (0);
2370
2371 fail1:
2372         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2373
2374         return (rc);
2375 }
2376
2377         __checkReturn   boolean_t
2378 ef10_nic_hw_unavailable(
2379         __in            efx_nic_t *enp)
2380 {
2381         efx_dword_t dword;
2382
2383         if (enp->en_reset_flags & EFX_RESET_HW_UNAVAIL)
2384                 return (B_TRUE);
2385
2386         EFX_BAR_READD(enp, ER_DZ_BIU_MC_SFT_STATUS_REG, &dword, B_FALSE);
2387         if (EFX_DWORD_FIELD(dword, EFX_DWORD_0) == 0xffffffff)
2388                 goto unavail;
2389
2390         return (B_FALSE);
2391
2392 unavail:
2393         ef10_nic_set_hw_unavailable(enp);
2394
2395         return (B_TRUE);
2396 }
2397
2398                         void
2399 ef10_nic_set_hw_unavailable(
2400         __in            efx_nic_t *enp)
2401 {
2402         EFSYS_PROBE(hw_unavail);
2403         enp->en_reset_flags |= EFX_RESET_HW_UNAVAIL;
2404 }
2405
2406
2407                         void
2408 ef10_nic_fini(
2409         __in            efx_nic_t *enp)
2410 {
2411         uint32_t i;
2412         efx_rc_t rc;
2413
2414         (void) efx_mcdi_vadaptor_free(enp, enp->en_vport_id);
2415         enp->en_vport_id = 0;
2416
2417         /* Unlink piobufs from extra VIs in WC mapping */
2418         if (enp->en_arch.ef10.ena_piobuf_count > 0) {
2419                 for (i = 0; i < enp->en_arch.ef10.ena_piobuf_count; i++) {
2420                         rc = efx_mcdi_unlink_piobuf(enp,
2421                             enp->en_arch.ef10.ena_pio_write_vi_base + i);
2422                         if (rc != 0)
2423                                 break;
2424                 }
2425         }
2426
2427         ef10_nic_free_piobufs(enp);
2428
2429         (void) efx_mcdi_free_vis(enp);
2430         enp->en_arch.ef10.ena_vi_count = 0;
2431 }
2432
2433                         void
2434 ef10_nic_unprobe(
2435         __in            efx_nic_t *enp)
2436 {
2437 #if EFSYS_OPT_MON_STATS
2438         mcdi_mon_cfg_free(enp);
2439 #endif /* EFSYS_OPT_MON_STATS */
2440         (void) efx_mcdi_drv_attach(enp, B_FALSE);
2441 }
2442
2443 #if EFSYS_OPT_DIAG
2444
2445         __checkReturn   efx_rc_t
2446 ef10_nic_register_test(
2447         __in            efx_nic_t *enp)
2448 {
2449         efx_rc_t rc;
2450
2451         /* FIXME */
2452         _NOTE(ARGUNUSED(enp))
2453         _NOTE(CONSTANTCONDITION)
2454         if (B_FALSE) {
2455                 rc = ENOTSUP;
2456                 goto fail1;
2457         }
2458         /* FIXME */
2459
2460         return (0);
2461
2462 fail1:
2463         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2464
2465         return (rc);
2466 }
2467
2468 #endif  /* EFSYS_OPT_DIAG */
2469
2470 #if EFSYS_OPT_FW_SUBVARIANT_AWARE
2471
2472         __checkReturn   efx_rc_t
2473 efx_mcdi_get_nic_global(
2474         __in            efx_nic_t *enp,
2475         __in            uint32_t key,
2476         __out           uint32_t *valuep)
2477 {
2478         efx_mcdi_req_t req;
2479         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_NIC_GLOBAL_IN_LEN,
2480                 MC_CMD_GET_NIC_GLOBAL_OUT_LEN);
2481         efx_rc_t rc;
2482
2483         req.emr_cmd = MC_CMD_GET_NIC_GLOBAL;
2484         req.emr_in_buf = payload;
2485         req.emr_in_length = MC_CMD_GET_NIC_GLOBAL_IN_LEN;
2486         req.emr_out_buf = payload;
2487         req.emr_out_length = MC_CMD_GET_NIC_GLOBAL_OUT_LEN;
2488
2489         MCDI_IN_SET_DWORD(req, GET_NIC_GLOBAL_IN_KEY, key);
2490
2491         efx_mcdi_execute(enp, &req);
2492
2493         if (req.emr_rc != 0) {
2494                 rc = req.emr_rc;
2495                 goto fail1;
2496         }
2497
2498         if (req.emr_out_length_used != MC_CMD_GET_NIC_GLOBAL_OUT_LEN) {
2499                 rc = EMSGSIZE;
2500                 goto fail2;
2501         }
2502
2503         *valuep = MCDI_OUT_DWORD(req, GET_NIC_GLOBAL_OUT_VALUE);
2504
2505         return (0);
2506
2507 fail2:
2508         EFSYS_PROBE(fail2);
2509 fail1:
2510         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2511
2512         return (rc);
2513 }
2514
2515         __checkReturn   efx_rc_t
2516 efx_mcdi_set_nic_global(
2517         __in            efx_nic_t *enp,
2518         __in            uint32_t key,
2519         __in            uint32_t value)
2520 {
2521         efx_mcdi_req_t req;
2522         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_NIC_GLOBAL_IN_LEN, 0);
2523         efx_rc_t rc;
2524
2525         req.emr_cmd = MC_CMD_SET_NIC_GLOBAL;
2526         req.emr_in_buf = payload;
2527         req.emr_in_length = MC_CMD_SET_NIC_GLOBAL_IN_LEN;
2528         req.emr_out_buf = NULL;
2529         req.emr_out_length = 0;
2530
2531         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_KEY, key);
2532         MCDI_IN_SET_DWORD(req, SET_NIC_GLOBAL_IN_VALUE, value);
2533
2534         efx_mcdi_execute(enp, &req);
2535
2536         if (req.emr_rc != 0) {
2537                 rc = req.emr_rc;
2538                 goto fail1;
2539         }
2540
2541         return (0);
2542
2543 fail1:
2544         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2545
2546         return (rc);
2547 }
2548
2549 #endif  /* EFSYS_OPT_FW_SUBVARIANT_AWARE */
2550
2551 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */