drivers/net/sfc/base/siena_nic.c

   1 /*
   2  * Copyright (c) 2009-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 "efx.h"
  32 #include "efx_impl.h"
  33 #include "mcdi_mon.h"
  34
  35 #if EFSYS_OPT_SIENA
  36
  37 static  __checkReturn   efx_rc_t
  38 siena_board_cfg(
  39         __in            efx_nic_t *enp)
  40 {
  41         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
  42         uint8_t mac_addr[6];
  43         efx_dword_t capabilities;
  44         uint32_t board_type;
  45         uint32_t nevq, nrxq, ntxq;
  46         efx_rc_t rc;
  47
  48         /* External port identifier using one-based port numbering */
  49         encp->enc_external_port = (uint8_t)enp->en_mcdi.em_emip.emi_port;
  50
  51         /* Board configuration */
  52         if ((rc = efx_mcdi_get_board_cfg(enp, &board_type,
  53                     &capabilities, mac_addr)) != 0)
  54                 goto fail1;
  55
  56         EFX_MAC_ADDR_COPY(encp->enc_mac_addr, mac_addr);
  57
  58         encp->enc_board_type = board_type;
  59
  60         /*
  61          * There is no possibility to determine the number of PFs on Siena
  62          * by issuing MCDI request, and it is not an easy task to find the
  63          * value based on the board type, so 'enc_hw_pf_count' is set to 1
  64          */
  65         encp->enc_hw_pf_count = 1;
  66
  67         /* Additional capabilities */
  68         encp->enc_clk_mult = 1;
  69         if (EFX_DWORD_FIELD(capabilities, MC_CMD_CAPABILITIES_TURBO)) {
  70                 enp->en_features |= EFX_FEATURE_TURBO;
  71
  72                 if (EFX_DWORD_FIELD(capabilities,
  73                         MC_CMD_CAPABILITIES_TURBO_ACTIVE)) {
  74                         encp->enc_clk_mult = 2;
  75                 }
  76         }
  77
  78         encp->enc_evq_timer_quantum_ns =
  79                 EFX_EVQ_SIENA_TIMER_QUANTUM_NS / encp->enc_clk_mult;
  80         encp->enc_evq_timer_max_us = (encp->enc_evq_timer_quantum_ns <<
  81                 FRF_CZ_TC_TIMER_VAL_WIDTH) / 1000;
  82
  83         /* When hash header insertion is enabled, Siena inserts 16 bytes */
  84         encp->enc_rx_prefix_size = 16;
  85
  86         /* Alignment for receive packet DMA buffers */
  87         encp->enc_rx_buf_align_start = 1;
  88         encp->enc_rx_buf_align_end = 1;
  89
  90         /* Alignment for WPTR updates */
  91         encp->enc_rx_push_align = 1;
  92
  93         /* Resource limits */
  94         rc = efx_mcdi_get_resource_limits(enp, &nevq, &nrxq, &ntxq);
  95         if (rc != 0) {
  96                 if (rc != ENOTSUP)
  97                         goto fail2;
  98
  99                 nevq = 1024;
 100                 nrxq = EFX_RXQ_LIMIT_TARGET;
 101                 ntxq = EFX_TXQ_LIMIT_TARGET;
 102         }
 103         encp->enc_evq_limit = nevq;
 104         encp->enc_rxq_limit = MIN(EFX_RXQ_LIMIT_TARGET, nrxq);
 105         encp->enc_txq_limit = MIN(EFX_TXQ_LIMIT_TARGET, ntxq);
 106
 107         encp->enc_txq_max_ndescs = 4096;
 108
 109         encp->enc_buftbl_limit = SIENA_SRAM_ROWS -
 110             (encp->enc_txq_limit * EFX_TXQ_DC_NDESCS(EFX_TXQ_DC_SIZE)) -
 111             (encp->enc_rxq_limit * EFX_RXQ_DC_NDESCS(EFX_RXQ_DC_SIZE));
 112
 113         encp->enc_hw_tx_insert_vlan_enabled = B_FALSE;
 114         encp->enc_fw_assisted_tso_enabled = B_FALSE;
 115         encp->enc_fw_assisted_tso_v2_enabled = B_FALSE;
 116         encp->enc_fw_assisted_tso_v2_n_contexts = 0;
 117         encp->enc_allow_set_mac_with_installed_filters = B_TRUE;
 118         encp->enc_rx_packed_stream_supported = B_FALSE;
 119         encp->enc_rx_var_packed_stream_supported = B_FALSE;
 120
 121         /* Siena supports two 10G ports, and 8 lanes of PCIe Gen2 */
 122         encp->enc_required_pcie_bandwidth_mbps = 2 * 10000;
 123         encp->enc_max_pcie_link_gen = EFX_PCIE_LINK_SPEED_GEN2;
 124
 125         encp->enc_fw_verified_nvram_update_required = B_FALSE;
 126
 127         return (0);
 128
 129 fail2:
 130         EFSYS_PROBE(fail2);
 131 fail1:
 132         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 133
 134         return (rc);
 135 }
 136
 137 static  __checkReturn   efx_rc_t
 138 siena_phy_cfg(
 139         __in            efx_nic_t *enp)
 140 {
 141         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 142         efx_rc_t rc;
 143
 144         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
 145         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
 146                 goto fail1;
 147
 148 #if EFSYS_OPT_PHY_STATS
 149         /* Convert the MCDI statistic mask into the EFX_PHY_STAT mask */
 150         siena_phy_decode_stats(enp, encp->enc_mcdi_phy_stat_mask,
 151                             NULL, &encp->enc_phy_stat_mask, NULL);
 152 #endif  /* EFSYS_OPT_PHY_STATS */
 153
 154         return (0);
 155
 156 fail1:
 157         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 158
 159         return (rc);
 160 }
 161
 162         __checkReturn   efx_rc_t
 163 siena_nic_probe(
 164         __in            efx_nic_t *enp)
 165 {
 166         efx_port_t *epp = &(enp->en_port);
 167         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 168         siena_link_state_t sls;
 169         unsigned int mask;
 170         efx_oword_t oword;
 171         efx_rc_t rc;
 172
 173         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
 174
 175         /* Test BIU */
 176         if ((rc = efx_nic_biu_test(enp)) != 0)
 177                 goto fail1;
 178
 179         /* Clear the region register */
 180         EFX_POPULATE_OWORD_4(oword,
 181             FRF_AZ_ADR_REGION0, 0,
 182             FRF_AZ_ADR_REGION1, (1 << 16),
 183             FRF_AZ_ADR_REGION2, (2 << 16),
 184             FRF_AZ_ADR_REGION3, (3 << 16));
 185         EFX_BAR_WRITEO(enp, FR_AZ_ADR_REGION_REG, &oword);
 186
 187         /* Read clear any assertion state */
 188         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
 189                 goto fail2;
 190
 191         /* Exit the assertion handler */
 192         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
 193                 goto fail3;
 194
 195         /* Wrestle control from the BMC */
 196         if ((rc = efx_mcdi_drv_attach(enp, B_TRUE)) != 0)
 197                 goto fail4;
 198
 199         if ((rc = siena_board_cfg(enp)) != 0)
 200                 goto fail5;
 201
 202         if ((rc = siena_phy_cfg(enp)) != 0)
 203                 goto fail6;
 204
 205         /* Obtain the default PHY advertised capabilities */
 206         if ((rc = siena_nic_reset(enp)) != 0)
 207                 goto fail7;
 208         if ((rc = siena_phy_get_link(enp, &sls)) != 0)
 209                 goto fail8;
 210         epp->ep_default_adv_cap_mask = sls.sls_adv_cap_mask;
 211         epp->ep_adv_cap_mask = sls.sls_adv_cap_mask;
 212
 213 #if EFSYS_OPT_MAC_STATS
 214         /* Wipe the MAC statistics */
 215         if ((rc = efx_mcdi_mac_stats_clear(enp)) != 0)
 216                 goto fail10;
 217 #endif
 218
 219 #if EFSYS_OPT_LOOPBACK
 220         if ((rc = efx_mcdi_get_loopback_modes(enp)) != 0)
 221                 goto fail11;
 222 #endif
 223
 224         encp->enc_features = enp->en_features;
 225
 226         return (0);
 227
 228 #if EFSYS_OPT_LOOPBACK
 229 fail11:
 230         EFSYS_PROBE(fail11);
 231 #endif
 232 #if EFSYS_OPT_MAC_STATS
 233 fail10:
 234         EFSYS_PROBE(fail10);
 235 #endif
 236 fail8:
 237         EFSYS_PROBE(fail8);
 238 fail7:
 239         EFSYS_PROBE(fail7);
 240 fail6:
 241         EFSYS_PROBE(fail6);
 242 fail5:
 243         EFSYS_PROBE(fail5);
 244 fail4:
 245         EFSYS_PROBE(fail4);
 246 fail3:
 247         EFSYS_PROBE(fail3);
 248 fail2:
 249         EFSYS_PROBE(fail2);
 250 fail1:
 251         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 252
 253         return (rc);
 254 }
 255
 256         __checkReturn   efx_rc_t
 257 siena_nic_reset(
 258         __in            efx_nic_t *enp)
 259 {
 260         efx_mcdi_req_t req;
 261         efx_rc_t rc;
 262
 263         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
 264
 265         /* siena_nic_reset() is called to recover from BADASSERT failures. */
 266         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
 267                 goto fail1;
 268         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
 269                 goto fail2;
 270
 271         /*
 272          * Bug24908: ENTITY_RESET_IN_LEN is non zero but zero may be supplied
 273          * for backwards compatibility with PORT_RESET_IN_LEN.
 274          */
 275         EFX_STATIC_ASSERT(MC_CMD_ENTITY_RESET_OUT_LEN == 0);
 276
 277         req.emr_cmd = MC_CMD_ENTITY_RESET;
 278         req.emr_in_buf = NULL;
 279         req.emr_in_length = 0;
 280         req.emr_out_buf = NULL;
 281         req.emr_out_length = 0;
 282
 283         efx_mcdi_execute(enp, &req);
 284
 285         if (req.emr_rc != 0) {
 286                 rc = req.emr_rc;
 287                 goto fail3;
 288         }
 289
 290         return (0);
 291
 292 fail3:
 293         EFSYS_PROBE(fail3);
 294 fail2:
 295         EFSYS_PROBE(fail2);
 296 fail1:
 297         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 298
 299         return (0);
 300 }
 301
 302 static                  void
 303 siena_nic_rx_cfg(
 304         __in            efx_nic_t *enp)
 305 {
 306         efx_oword_t oword;
 307
 308         /*
 309          * RX_INGR_EN is always enabled on Siena, because we rely on
 310          * the RX parser to be resiliant to missing SOP/EOP.
 311          */
 312         EFX_BAR_READO(enp, FR_AZ_RX_CFG_REG, &oword);
 313         EFX_SET_OWORD_FIELD(oword, FRF_BZ_RX_INGR_EN, 1);
 314         EFX_BAR_WRITEO(enp, FR_AZ_RX_CFG_REG, &oword);
 315
 316         /* Disable parsing of additional 802.1Q in Q packets */
 317         EFX_BAR_READO(enp, FR_AZ_RX_FILTER_CTL_REG, &oword);
 318         EFX_SET_OWORD_FIELD(oword, FRF_CZ_RX_FILTER_ALL_VLAN_ETHERTYPES, 0);
 319         EFX_BAR_WRITEO(enp, FR_AZ_RX_FILTER_CTL_REG, &oword);
 320 }
 321
 322 static                  void
 323 siena_nic_usrev_dis(
 324         __in            efx_nic_t *enp)
 325 {
 326         efx_oword_t     oword;
 327
 328         EFX_POPULATE_OWORD_1(oword, FRF_CZ_USREV_DIS, 1);
 329         EFX_BAR_WRITEO(enp, FR_CZ_USR_EV_CFG, &oword);
 330 }
 331
 332         __checkReturn   efx_rc_t
 333 siena_nic_init(
 334         __in            efx_nic_t *enp)
 335 {
 336         efx_rc_t rc;
 337
 338         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
 339
 340         /* Enable reporting of some events (e.g. link change) */
 341         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
 342                 goto fail1;
 343
 344         siena_sram_init(enp);
 345
 346         /* Configure Siena's RX block */
 347         siena_nic_rx_cfg(enp);
 348
 349         /* Disable USR_EVents for now */
 350         siena_nic_usrev_dis(enp);
 351
 352         /* bug17057: Ensure set_link is called */
 353         if ((rc = siena_phy_reconfigure(enp)) != 0)
 354                 goto fail2;
 355
 356         enp->en_nic_cfg.enc_mcdi_max_payload_length = MCDI_CTL_SDU_LEN_MAX_V1;
 357
 358         return (0);
 359
 360 fail2:
 361         EFSYS_PROBE(fail2);
 362 fail1:
 363         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 364
 365         return (rc);
 366 }
 367
 368                         void
 369 siena_nic_fini(
 370         __in            efx_nic_t *enp)
 371 {
 372         _NOTE(ARGUNUSED(enp))
 373 }
 374
 375                         void
 376 siena_nic_unprobe(
 377         __in            efx_nic_t *enp)
 378 {
 379         (void) efx_mcdi_drv_attach(enp, B_FALSE);
 380 }
 381
 382 #if EFSYS_OPT_DIAG
 383
 384 static efx_register_set_t __siena_registers[] = {
 385         { FR_AZ_ADR_REGION_REG_OFST, 0, 1 },
 386         { FR_CZ_USR_EV_CFG_OFST, 0, 1 },
 387         { FR_AZ_RX_CFG_REG_OFST, 0, 1 },
 388         { FR_AZ_TX_CFG_REG_OFST, 0, 1 },
 389         { FR_AZ_TX_RESERVED_REG_OFST, 0, 1 },
 390         { FR_AZ_SRM_TX_DC_CFG_REG_OFST, 0, 1 },
 391         { FR_AZ_RX_DC_CFG_REG_OFST, 0, 1 },
 392         { FR_AZ_RX_DC_PF_WM_REG_OFST, 0, 1 },
 393         { FR_AZ_DP_CTRL_REG_OFST, 0, 1 },
 394         { FR_BZ_RX_RSS_TKEY_REG_OFST, 0, 1},
 395         { FR_CZ_RX_RSS_IPV6_REG1_OFST, 0, 1},
 396         { FR_CZ_RX_RSS_IPV6_REG2_OFST, 0, 1},
 397         { FR_CZ_RX_RSS_IPV6_REG3_OFST, 0, 1}
 398 };
 399
 400 static const uint32_t __siena_register_masks[] = {
 401         0x0003FFFF, 0x0003FFFF, 0x0003FFFF, 0x0003FFFF,
 402         0x000103FF, 0x00000000, 0x00000000, 0x00000000,
 403         0xFFFFFFFE, 0xFFFFFFFF, 0x0003FFFF, 0x00000000,
 404         0x7FFF0037, 0xFFFF8000, 0xFFFFFFFF, 0x03FFFFFF,
 405         0xFFFEFE80, 0x1FFFFFFF, 0x020000FE, 0x007FFFFF,
 406         0x001FFFFF, 0x00000000, 0x00000000, 0x00000000,
 407         0x00000003, 0x00000000, 0x00000000, 0x00000000,
 408         0x000003FF, 0x00000000, 0x00000000, 0x00000000,
 409         0x00000FFF, 0x00000000, 0x00000000, 0x00000000,
 410         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 411         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 412         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 413         0xFFFFFFFF, 0xFFFFFFFF, 0x00000007, 0x00000000
 414 };
 415
 416 static efx_register_set_t __siena_tables[] = {
 417         { FR_AZ_RX_FILTER_TBL0_OFST, FR_AZ_RX_FILTER_TBL0_STEP,
 418             FR_AZ_RX_FILTER_TBL0_ROWS },
 419         { FR_CZ_RX_MAC_FILTER_TBL0_OFST, FR_CZ_RX_MAC_FILTER_TBL0_STEP,
 420             FR_CZ_RX_MAC_FILTER_TBL0_ROWS },
 421         { FR_AZ_RX_DESC_PTR_TBL_OFST,
 422             FR_AZ_RX_DESC_PTR_TBL_STEP, FR_CZ_RX_DESC_PTR_TBL_ROWS },
 423         { FR_AZ_TX_DESC_PTR_TBL_OFST,
 424             FR_AZ_TX_DESC_PTR_TBL_STEP, FR_CZ_TX_DESC_PTR_TBL_ROWS },
 425         { FR_AZ_TIMER_TBL_OFST, FR_AZ_TIMER_TBL_STEP, FR_CZ_TIMER_TBL_ROWS },
 426         { FR_CZ_TX_FILTER_TBL0_OFST,
 427             FR_CZ_TX_FILTER_TBL0_STEP, FR_CZ_TX_FILTER_TBL0_ROWS },
 428         { FR_CZ_TX_MAC_FILTER_TBL0_OFST,
 429             FR_CZ_TX_MAC_FILTER_TBL0_STEP, FR_CZ_TX_MAC_FILTER_TBL0_ROWS }
 430 };
 431
 432 static const uint32_t __siena_table_masks[] = {
 433         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x000003FF,
 434         0xFFFF0FFF, 0xFFFFFFFF, 0x00000E7F, 0x00000000,
 435         0xFFFFFFFE, 0x0FFFFFFF, 0x01800000, 0x00000000,
 436         0xFFFFFFFE, 0x0FFFFFFF, 0x0C000000, 0x00000000,
 437         0x3FFFFFFF, 0x00000000, 0x00000000, 0x00000000,
 438         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x000013FF,
 439         0xFFFF07FF, 0xFFFFFFFF, 0x0000007F, 0x00000000,
 440 };
 441
 442         __checkReturn   efx_rc_t
 443 siena_nic_register_test(
 444         __in            efx_nic_t *enp)
 445 {
 446         efx_register_set_t *rsp;
 447         const uint32_t *dwordp;
 448         unsigned int nitems;
 449         unsigned int count;
 450         efx_rc_t rc;
 451
 452         /* Fill out the register mask entries */
 453         EFX_STATIC_ASSERT(EFX_ARRAY_SIZE(__siena_register_masks)
 454                     == EFX_ARRAY_SIZE(__siena_registers) * 4);
 455
 456         nitems = EFX_ARRAY_SIZE(__siena_registers);
 457         dwordp = __siena_register_masks;
 458         for (count = 0; count < nitems; ++count) {
 459                 rsp = __siena_registers + count;
 460                 rsp->mask.eo_u32[0] = *dwordp++;
 461                 rsp->mask.eo_u32[1] = *dwordp++;
 462                 rsp->mask.eo_u32[2] = *dwordp++;
 463                 rsp->mask.eo_u32[3] = *dwordp++;
 464         }
 465
 466         /* Fill out the register table entries */
 467         EFX_STATIC_ASSERT(EFX_ARRAY_SIZE(__siena_table_masks)
 468                     == EFX_ARRAY_SIZE(__siena_tables) * 4);
 469
 470         nitems = EFX_ARRAY_SIZE(__siena_tables);
 471         dwordp = __siena_table_masks;
 472         for (count = 0; count < nitems; ++count) {
 473                 rsp = __siena_tables + count;
 474                 rsp->mask.eo_u32[0] = *dwordp++;
 475                 rsp->mask.eo_u32[1] = *dwordp++;
 476                 rsp->mask.eo_u32[2] = *dwordp++;
 477                 rsp->mask.eo_u32[3] = *dwordp++;
 478         }
 479
 480         if ((rc = efx_nic_test_registers(enp, __siena_registers,
 481             EFX_ARRAY_SIZE(__siena_registers))) != 0)
 482                 goto fail1;
 483
 484         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 485             EFX_PATTERN_BYTE_ALTERNATE,
 486             EFX_ARRAY_SIZE(__siena_tables))) != 0)
 487                 goto fail2;
 488
 489         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 490             EFX_PATTERN_BYTE_CHANGING,
 491             EFX_ARRAY_SIZE(__siena_tables))) != 0)
 492                 goto fail3;
 493
 494         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 495             EFX_PATTERN_BIT_SWEEP, EFX_ARRAY_SIZE(__siena_tables))) != 0)
 496                 goto fail4;
 497
 498         return (0);
 499
 500 fail4:
 501         EFSYS_PROBE(fail4);
 502 fail3:
 503         EFSYS_PROBE(fail3);
 504 fail2:
 505         EFSYS_PROBE(fail2);
 506 fail1:
 507         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 508
 509         return (rc);
 510 }
 511
 512 #endif  /* EFSYS_OPT_DIAG */
 513
 514 #endif  /* EFSYS_OPT_SIENA */