sys/dev/sfxge/common/ef10_nic.c

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