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