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