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         encp->enc_features = enp->en_features;
 220
 221         return (0);
 222
 223 #if EFSYS_OPT_MAC_STATS
 224 fail10:
 225         EFSYS_PROBE(fail10);
 226 #endif
 227 fail8:
 228         EFSYS_PROBE(fail8);
 229 fail7:
 230         EFSYS_PROBE(fail7);
 231 fail6:
 232         EFSYS_PROBE(fail6);
 233 fail5:
 234         EFSYS_PROBE(fail5);
 235 fail4:
 236         EFSYS_PROBE(fail4);
 237 fail3:
 238         EFSYS_PROBE(fail3);
 239 fail2:
 240         EFSYS_PROBE(fail2);
 241 fail1:
 242         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 243
 244         return (rc);
 245 }
 246
 247         __checkReturn   efx_rc_t
 248 siena_nic_reset(
 249         __in            efx_nic_t *enp)
 250 {
 251         efx_mcdi_req_t req;
 252         efx_rc_t rc;
 253
 254         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
 255
 256         /* siena_nic_reset() is called to recover from BADASSERT failures. */
 257         if ((rc = efx_mcdi_read_assertion(enp)) != 0)
 258                 goto fail1;
 259         if ((rc = efx_mcdi_exit_assertion_handler(enp)) != 0)
 260                 goto fail2;
 261
 262         /*
 263          * Bug24908: ENTITY_RESET_IN_LEN is non zero but zero may be supplied
 264          * for backwards compatibility with PORT_RESET_IN_LEN.
 265          */
 266         EFX_STATIC_ASSERT(MC_CMD_ENTITY_RESET_OUT_LEN == 0);
 267
 268         req.emr_cmd = MC_CMD_ENTITY_RESET;
 269         req.emr_in_buf = NULL;
 270         req.emr_in_length = 0;
 271         req.emr_out_buf = NULL;
 272         req.emr_out_length = 0;
 273
 274         efx_mcdi_execute(enp, &req);
 275
 276         if (req.emr_rc != 0) {
 277                 rc = req.emr_rc;
 278                 goto fail3;
 279         }
 280
 281         return (0);
 282
 283 fail3:
 284         EFSYS_PROBE(fail3);
 285 fail2:
 286         EFSYS_PROBE(fail2);
 287 fail1:
 288         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 289
 290         return (0);
 291 }
 292
 293 static                  void
 294 siena_nic_rx_cfg(
 295         __in            efx_nic_t *enp)
 296 {
 297         efx_oword_t oword;
 298
 299         /*
 300          * RX_INGR_EN is always enabled on Siena, because we rely on
 301          * the RX parser to be resiliant to missing SOP/EOP.
 302          */
 303         EFX_BAR_READO(enp, FR_AZ_RX_CFG_REG, &oword);
 304         EFX_SET_OWORD_FIELD(oword, FRF_BZ_RX_INGR_EN, 1);
 305         EFX_BAR_WRITEO(enp, FR_AZ_RX_CFG_REG, &oword);
 306
 307         /* Disable parsing of additional 802.1Q in Q packets */
 308         EFX_BAR_READO(enp, FR_AZ_RX_FILTER_CTL_REG, &oword);
 309         EFX_SET_OWORD_FIELD(oword, FRF_CZ_RX_FILTER_ALL_VLAN_ETHERTYPES, 0);
 310         EFX_BAR_WRITEO(enp, FR_AZ_RX_FILTER_CTL_REG, &oword);
 311 }
 312
 313 static                  void
 314 siena_nic_usrev_dis(
 315         __in            efx_nic_t *enp)
 316 {
 317         efx_oword_t     oword;
 318
 319         EFX_POPULATE_OWORD_1(oword, FRF_CZ_USREV_DIS, 1);
 320         EFX_BAR_WRITEO(enp, FR_CZ_USR_EV_CFG, &oword);
 321 }
 322
 323         __checkReturn   efx_rc_t
 324 siena_nic_init(
 325         __in            efx_nic_t *enp)
 326 {
 327         efx_rc_t rc;
 328
 329         EFSYS_ASSERT3U(enp->en_family, ==, EFX_FAMILY_SIENA);
 330
 331         /* Enable reporting of some events (e.g. link change) */
 332         if ((rc = efx_mcdi_log_ctrl(enp)) != 0)
 333                 goto fail1;
 334
 335         siena_sram_init(enp);
 336
 337         /* Configure Siena's RX block */
 338         siena_nic_rx_cfg(enp);
 339
 340         /* Disable USR_EVents for now */
 341         siena_nic_usrev_dis(enp);
 342
 343         /* bug17057: Ensure set_link is called */
 344         if ((rc = siena_phy_reconfigure(enp)) != 0)
 345                 goto fail2;
 346
 347         enp->en_nic_cfg.enc_mcdi_max_payload_length = MCDI_CTL_SDU_LEN_MAX_V1;
 348
 349         return (0);
 350
 351 fail2:
 352         EFSYS_PROBE(fail2);
 353 fail1:
 354         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 355
 356         return (rc);
 357 }
 358
 359                         void
 360 siena_nic_fini(
 361         __in            efx_nic_t *enp)
 362 {
 363         _NOTE(ARGUNUSED(enp))
 364 }
 365
 366                         void
 367 siena_nic_unprobe(
 368         __in            efx_nic_t *enp)
 369 {
 370         (void) efx_mcdi_drv_attach(enp, B_FALSE);
 371 }
 372
 373 #if EFSYS_OPT_DIAG
 374
 375 static efx_register_set_t __siena_registers[] = {
 376         { FR_AZ_ADR_REGION_REG_OFST, 0, 1 },
 377         { FR_CZ_USR_EV_CFG_OFST, 0, 1 },
 378         { FR_AZ_RX_CFG_REG_OFST, 0, 1 },
 379         { FR_AZ_TX_CFG_REG_OFST, 0, 1 },
 380         { FR_AZ_TX_RESERVED_REG_OFST, 0, 1 },
 381         { FR_AZ_SRM_TX_DC_CFG_REG_OFST, 0, 1 },
 382         { FR_AZ_RX_DC_CFG_REG_OFST, 0, 1 },
 383         { FR_AZ_RX_DC_PF_WM_REG_OFST, 0, 1 },
 384         { FR_AZ_DP_CTRL_REG_OFST, 0, 1 },
 385         { FR_BZ_RX_RSS_TKEY_REG_OFST, 0, 1},
 386         { FR_CZ_RX_RSS_IPV6_REG1_OFST, 0, 1},
 387         { FR_CZ_RX_RSS_IPV6_REG2_OFST, 0, 1},
 388         { FR_CZ_RX_RSS_IPV6_REG3_OFST, 0, 1}
 389 };
 390
 391 static const uint32_t __siena_register_masks[] = {
 392         0x0003FFFF, 0x0003FFFF, 0x0003FFFF, 0x0003FFFF,
 393         0x000103FF, 0x00000000, 0x00000000, 0x00000000,
 394         0xFFFFFFFE, 0xFFFFFFFF, 0x0003FFFF, 0x00000000,
 395         0x7FFF0037, 0xFFFF8000, 0xFFFFFFFF, 0x03FFFFFF,
 396         0xFFFEFE80, 0x1FFFFFFF, 0x020000FE, 0x007FFFFF,
 397         0x001FFFFF, 0x00000000, 0x00000000, 0x00000000,
 398         0x00000003, 0x00000000, 0x00000000, 0x00000000,
 399         0x000003FF, 0x00000000, 0x00000000, 0x00000000,
 400         0x00000FFF, 0x00000000, 0x00000000, 0x00000000,
 401         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 402         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 403         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 404         0xFFFFFFFF, 0xFFFFFFFF, 0x00000007, 0x00000000
 405 };
 406
 407 static efx_register_set_t __siena_tables[] = {
 408         { FR_AZ_RX_FILTER_TBL0_OFST, FR_AZ_RX_FILTER_TBL0_STEP,
 409             FR_AZ_RX_FILTER_TBL0_ROWS },
 410         { FR_CZ_RX_MAC_FILTER_TBL0_OFST, FR_CZ_RX_MAC_FILTER_TBL0_STEP,
 411             FR_CZ_RX_MAC_FILTER_TBL0_ROWS },
 412         { FR_AZ_RX_DESC_PTR_TBL_OFST,
 413             FR_AZ_RX_DESC_PTR_TBL_STEP, FR_CZ_RX_DESC_PTR_TBL_ROWS },
 414         { FR_AZ_TX_DESC_PTR_TBL_OFST,
 415             FR_AZ_TX_DESC_PTR_TBL_STEP, FR_CZ_TX_DESC_PTR_TBL_ROWS },
 416         { FR_AZ_TIMER_TBL_OFST, FR_AZ_TIMER_TBL_STEP, FR_CZ_TIMER_TBL_ROWS },
 417         { FR_CZ_TX_FILTER_TBL0_OFST,
 418             FR_CZ_TX_FILTER_TBL0_STEP, FR_CZ_TX_FILTER_TBL0_ROWS },
 419         { FR_CZ_TX_MAC_FILTER_TBL0_OFST,
 420             FR_CZ_TX_MAC_FILTER_TBL0_STEP, FR_CZ_TX_MAC_FILTER_TBL0_ROWS }
 421 };
 422
 423 static const uint32_t __siena_table_masks[] = {
 424         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x000003FF,
 425         0xFFFF0FFF, 0xFFFFFFFF, 0x00000E7F, 0x00000000,
 426         0xFFFFFFFE, 0x0FFFFFFF, 0x01800000, 0x00000000,
 427         0xFFFFFFFE, 0x0FFFFFFF, 0x0C000000, 0x00000000,
 428         0x3FFFFFFF, 0x00000000, 0x00000000, 0x00000000,
 429         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x000013FF,
 430         0xFFFF07FF, 0xFFFFFFFF, 0x0000007F, 0x00000000,
 431 };
 432
 433         __checkReturn   efx_rc_t
 434 siena_nic_register_test(
 435         __in            efx_nic_t *enp)
 436 {
 437         efx_register_set_t *rsp;
 438         const uint32_t *dwordp;
 439         unsigned int nitems;
 440         unsigned int count;
 441         efx_rc_t rc;
 442
 443         /* Fill out the register mask entries */
 444         EFX_STATIC_ASSERT(EFX_ARRAY_SIZE(__siena_register_masks)
 445                     == EFX_ARRAY_SIZE(__siena_registers) * 4);
 446
 447         nitems = EFX_ARRAY_SIZE(__siena_registers);
 448         dwordp = __siena_register_masks;
 449         for (count = 0; count < nitems; ++count) {
 450                 rsp = __siena_registers + count;
 451                 rsp->mask.eo_u32[0] = *dwordp++;
 452                 rsp->mask.eo_u32[1] = *dwordp++;
 453                 rsp->mask.eo_u32[2] = *dwordp++;
 454                 rsp->mask.eo_u32[3] = *dwordp++;
 455         }
 456
 457         /* Fill out the register table entries */
 458         EFX_STATIC_ASSERT(EFX_ARRAY_SIZE(__siena_table_masks)
 459                     == EFX_ARRAY_SIZE(__siena_tables) * 4);
 460
 461         nitems = EFX_ARRAY_SIZE(__siena_tables);
 462         dwordp = __siena_table_masks;
 463         for (count = 0; count < nitems; ++count) {
 464                 rsp = __siena_tables + count;
 465                 rsp->mask.eo_u32[0] = *dwordp++;
 466                 rsp->mask.eo_u32[1] = *dwordp++;
 467                 rsp->mask.eo_u32[2] = *dwordp++;
 468                 rsp->mask.eo_u32[3] = *dwordp++;
 469         }
 470
 471         if ((rc = efx_nic_test_registers(enp, __siena_registers,
 472             EFX_ARRAY_SIZE(__siena_registers))) != 0)
 473                 goto fail1;
 474
 475         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 476             EFX_PATTERN_BYTE_ALTERNATE,
 477             EFX_ARRAY_SIZE(__siena_tables))) != 0)
 478                 goto fail2;
 479
 480         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 481             EFX_PATTERN_BYTE_CHANGING,
 482             EFX_ARRAY_SIZE(__siena_tables))) != 0)
 483                 goto fail3;
 484
 485         if ((rc = efx_nic_test_tables(enp, __siena_tables,
 486             EFX_PATTERN_BIT_SWEEP, EFX_ARRAY_SIZE(__siena_tables))) != 0)
 487                 goto fail4;
 488
 489         return (0);
 490
 491 fail4:
 492         EFSYS_PROBE(fail4);
 493 fail3:
 494         EFSYS_PROBE(fail3);
 495 fail2:
 496         EFSYS_PROBE(fail2);
 497 fail1:
 498         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 499
 500         return (rc);
 501 }
 502
 503 #endif  /* EFSYS_OPT_DIAG */
 504
 505 #endif  /* EFSYS_OPT_SIENA */