net/sfc/base: move MAC address config to ef10 NIC board cfg
[dpdk.git] / drivers / net / sfc / base / hunt_nic.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  *
3  * Copyright (c) 2012-2018 Solarflare Communications Inc.
4  * All rights reserved.
5  */
6
7 #include "efx.h"
8 #include "efx_impl.h"
9 #if EFSYS_OPT_MON_MCDI
10 #include "mcdi_mon.h"
11 #endif
12
13 #if EFSYS_OPT_HUNTINGTON
14
15 #include "ef10_tlv_layout.h"
16
17 static  __checkReturn   efx_rc_t
18 hunt_nic_get_required_pcie_bandwidth(
19         __in            efx_nic_t *enp,
20         __out           uint32_t *bandwidth_mbpsp)
21 {
22         uint32_t port_modes;
23         uint32_t max_port_mode;
24         uint32_t bandwidth;
25         efx_rc_t rc;
26
27         /*
28          * On Huntington, the firmware may not give us the current port mode, so
29          * we need to go by the set of available port modes and assume the most
30          * capable mode is in use.
31          */
32
33         if ((rc = efx_mcdi_get_port_modes(enp, &port_modes, NULL)) != 0) {
34                 /* No port mode info available */
35                 bandwidth = 0;
36                 goto out;
37         }
38
39         if (port_modes & (1 << TLV_PORT_MODE_40G_40G)) {
40                 /*
41                  * This needs the full PCIe bandwidth (and could use
42                  * more) - roughly 64 Gbit/s for 8 lanes of Gen3.
43                  */
44                 if ((rc = efx_nic_calculate_pcie_link_bandwidth(8,
45                             EFX_PCIE_LINK_SPEED_GEN3, &bandwidth)) != 0)
46                         goto fail1;
47         } else {
48                 if (port_modes & (1 << TLV_PORT_MODE_40G)) {
49                         max_port_mode = TLV_PORT_MODE_40G;
50                 } else if (port_modes & (1 << TLV_PORT_MODE_10G_10G_10G_10G)) {
51                         max_port_mode = TLV_PORT_MODE_10G_10G_10G_10G;
52                 } else {
53                         /* Assume two 10G ports */
54                         max_port_mode = TLV_PORT_MODE_10G_10G;
55                 }
56
57                 if ((rc = ef10_nic_get_port_mode_bandwidth(max_port_mode,
58                                                             &bandwidth)) != 0)
59                         goto fail2;
60         }
61
62 out:
63         *bandwidth_mbpsp = bandwidth;
64
65         return (0);
66
67 fail2:
68         EFSYS_PROBE(fail2);
69 fail1:
70         EFSYS_PROBE1(fail1, efx_rc_t, rc);
71
72         return (rc);
73 }
74
75         __checkReturn   efx_rc_t
76 hunt_board_cfg(
77         __in            efx_nic_t *enp)
78 {
79         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
80         uint32_t board_type = 0;
81         ef10_link_state_t els;
82         efx_port_t *epp = &(enp->en_port);
83         uint32_t mask;
84         uint32_t flags;
85         uint32_t sysclk, dpcpu_clk;
86         uint32_t base, nvec;
87         uint32_t bandwidth;
88         efx_rc_t rc;
89
90         /* Huntington has a fixed 8Kbyte VI window size */
91         EFX_STATIC_ASSERT(ER_DZ_EVQ_RPTR_REG_STEP       == 8192);
92         EFX_STATIC_ASSERT(ER_DZ_EVQ_TMR_REG_STEP        == 8192);
93         EFX_STATIC_ASSERT(ER_DZ_RX_DESC_UPD_REG_STEP    == 8192);
94         EFX_STATIC_ASSERT(ER_DZ_TX_DESC_UPD_REG_STEP    == 8192);
95         EFX_STATIC_ASSERT(ER_DZ_TX_PIOBUF_STEP          == 8192);
96
97         EFX_STATIC_ASSERT(1U << EFX_VI_WINDOW_SHIFT_8K  == 8192);
98         encp->enc_vi_window_shift = EFX_VI_WINDOW_SHIFT_8K;
99
100         /* Board configuration */
101         rc = efx_mcdi_get_board_cfg(enp, &board_type, NULL, NULL);
102         if (rc != 0) {
103                 /* Unprivileged functions may not be able to read board cfg */
104                 if (rc == EACCES)
105                         board_type = 0;
106                 else
107                         goto fail1;
108         }
109
110         encp->enc_board_type = board_type;
111         encp->enc_clk_mult = 1; /* not used for Huntington */
112
113         /* Fill out fields in enp->en_port and enp->en_nic_cfg from MCDI */
114         if ((rc = efx_mcdi_get_phy_cfg(enp)) != 0)
115                 goto fail2;
116
117         /* Obtain the default PHY advertised capabilities */
118         if ((rc = ef10_phy_get_link(enp, &els)) != 0)
119                 goto fail3;
120         epp->ep_default_adv_cap_mask = els.els_adv_cap_mask;
121         epp->ep_adv_cap_mask = els.els_adv_cap_mask;
122
123         /*
124          * Enable firmware workarounds for hardware errata.
125          * Expected responses are:
126          *  - 0 (zero):
127          *      Success: workaround enabled or disabled as requested.
128          *  - MC_CMD_ERR_ENOSYS (reported as ENOTSUP):
129          *      Firmware does not support the MC_CMD_WORKAROUND request.
130          *      (assume that the workaround is not supported).
131          *  - MC_CMD_ERR_ENOENT (reported as ENOENT):
132          *      Firmware does not support the requested workaround.
133          *  - MC_CMD_ERR_EPERM  (reported as EACCES):
134          *      Unprivileged function cannot enable/disable workarounds.
135          *
136          * See efx_mcdi_request_errcode() for MCDI error translations.
137          */
138
139         /*
140          * If the bug35388 workaround is enabled, then use an indirect access
141          * method to avoid unsafe EVQ writes.
142          */
143         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG35388, B_TRUE,
144             NULL);
145         if ((rc == 0) || (rc == EACCES))
146                 encp->enc_bug35388_workaround = B_TRUE;
147         else if ((rc == ENOTSUP) || (rc == ENOENT))
148                 encp->enc_bug35388_workaround = B_FALSE;
149         else
150                 goto fail4;
151
152         /*
153          * If the bug41750 workaround is enabled, then do not test interrupts,
154          * as the test will fail (seen with Greenport controllers).
155          */
156         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG41750, B_TRUE,
157             NULL);
158         if (rc == 0) {
159                 encp->enc_bug41750_workaround = B_TRUE;
160         } else if (rc == EACCES) {
161                 /* Assume a controller with 40G ports needs the workaround. */
162                 if (epp->ep_default_adv_cap_mask & EFX_PHY_CAP_40000FDX)
163                         encp->enc_bug41750_workaround = B_TRUE;
164                 else
165                         encp->enc_bug41750_workaround = B_FALSE;
166         } else if ((rc == ENOTSUP) || (rc == ENOENT)) {
167                 encp->enc_bug41750_workaround = B_FALSE;
168         } else {
169                 goto fail5;
170         }
171         if (EFX_PCI_FUNCTION_IS_VF(encp)) {
172                 /* Interrupt testing does not work for VFs. See bug50084. */
173                 encp->enc_bug41750_workaround = B_TRUE;
174         }
175
176         /*
177          * If the bug26807 workaround is enabled, then firmware has enabled
178          * support for chained multicast filters. Firmware will reset (FLR)
179          * functions which have filters in the hardware filter table when the
180          * workaround is enabled/disabled.
181          *
182          * We must recheck if the workaround is enabled after inserting the
183          * first hardware filter, in case it has been changed since this check.
184          */
185         rc = efx_mcdi_set_workaround(enp, MC_CMD_WORKAROUND_BUG26807,
186             B_TRUE, &flags);
187         if (rc == 0) {
188                 encp->enc_bug26807_workaround = B_TRUE;
189                 if (flags & (1 << MC_CMD_WORKAROUND_EXT_OUT_FLR_DONE_LBN)) {
190                         /*
191                          * Other functions had installed filters before the
192                          * workaround was enabled, and they have been reset
193                          * by firmware.
194                          */
195                         EFSYS_PROBE(bug26807_workaround_flr_done);
196                         /* FIXME: bump MC warm boot count ? */
197                 }
198         } else if (rc == EACCES) {
199                 /*
200                  * Unprivileged functions cannot enable the workaround in older
201                  * firmware.
202                  */
203                 encp->enc_bug26807_workaround = B_FALSE;
204         } else if ((rc == ENOTSUP) || (rc == ENOENT)) {
205                 encp->enc_bug26807_workaround = B_FALSE;
206         } else {
207                 goto fail6;
208         }
209
210         /* Get clock frequencies (in MHz). */
211         if ((rc = efx_mcdi_get_clock(enp, &sysclk, &dpcpu_clk)) != 0)
212                 goto fail7;
213
214         /*
215          * The Huntington timer quantum is 1536 sysclk cycles, documented for
216          * the EV_TMR_VAL field of EV_TIMER_TBL. Scale for MHz and ns units.
217          */
218         encp->enc_evq_timer_quantum_ns = 1536000UL / sysclk; /* 1536 cycles */
219         if (encp->enc_bug35388_workaround) {
220                 encp->enc_evq_timer_max_us = (encp->enc_evq_timer_quantum_ns <<
221                 ERF_DD_EVQ_IND_TIMER_VAL_WIDTH) / 1000;
222         } else {
223                 encp->enc_evq_timer_max_us = (encp->enc_evq_timer_quantum_ns <<
224                 FRF_CZ_TC_TIMER_VAL_WIDTH) / 1000;
225         }
226
227         encp->enc_bug61265_workaround = B_FALSE; /* Medford only */
228
229         /* Check capabilities of running datapath firmware */
230         if ((rc = ef10_get_datapath_caps(enp)) != 0)
231                 goto fail8;
232
233         /* Alignment for receive packet DMA buffers */
234         encp->enc_rx_buf_align_start = 1;
235         encp->enc_rx_buf_align_end = 64; /* RX DMA end padding */
236
237         /* Alignment for WPTR updates */
238         encp->enc_rx_push_align = EF10_RX_WPTR_ALIGN;
239
240         /*
241          * Maximum number of exclusive RSS contexts which can be allocated. The
242          * hardware supports 64, but 6 are reserved for shared contexts. They
243          * are a global resource so not all may be available.
244          */
245         encp->enc_rx_scale_max_exclusive_contexts = 58;
246
247         encp->enc_tx_dma_desc_size_max = EFX_MASK32(ESF_DZ_RX_KER_BYTE_CNT);
248         /* No boundary crossing limits */
249         encp->enc_tx_dma_desc_boundary = 0;
250
251         /*
252          * Set resource limits for MC_CMD_ALLOC_VIS. Note that we cannot use
253          * MC_CMD_GET_RESOURCE_LIMITS here as that reports the available
254          * resources (allocated to this PCIe function), which is zero until
255          * after we have allocated VIs.
256          */
257         encp->enc_evq_limit = 1024;
258         encp->enc_rxq_limit = EFX_RXQ_LIMIT_TARGET;
259         encp->enc_txq_limit = EFX_TXQ_LIMIT_TARGET;
260
261         /*
262          * The workaround for bug35388 uses the top bit of transmit queue
263          * descriptor writes, preventing the use of 4096 descriptor TXQs.
264          */
265         encp->enc_txq_max_ndescs = encp->enc_bug35388_workaround ? 2048 : 4096;
266
267         encp->enc_buftbl_limit = 0xFFFFFFFF;
268
269         EFX_STATIC_ASSERT(HUNT_PIOBUF_NBUFS <= EF10_MAX_PIOBUF_NBUFS);
270         encp->enc_piobuf_limit = HUNT_PIOBUF_NBUFS;
271         encp->enc_piobuf_size = HUNT_PIOBUF_SIZE;
272         encp->enc_piobuf_min_alloc_size = HUNT_MIN_PIO_ALLOC_SIZE;
273
274         /*
275          * Get the current privilege mask. Note that this may be modified
276          * dynamically, so this value is informational only. DO NOT use
277          * the privilege mask to check for sufficient privileges, as that
278          * can result in time-of-check/time-of-use bugs.
279          */
280         if ((rc = ef10_get_privilege_mask(enp, &mask)) != 0)
281                 goto fail9;
282         encp->enc_privilege_mask = mask;
283
284         /* Get interrupt vector limits */
285         if ((rc = efx_mcdi_get_vector_cfg(enp, &base, &nvec, NULL)) != 0) {
286                 if (EFX_PCI_FUNCTION_IS_PF(encp))
287                         goto fail10;
288
289                 /* Ignore error (cannot query vector limits from a VF). */
290                 base = 0;
291                 nvec = 1024;
292         }
293         encp->enc_intr_vec_base = base;
294         encp->enc_intr_limit = nvec;
295
296         /*
297          * Maximum number of bytes into the frame the TCP header can start for
298          * firmware assisted TSO to work.
299          */
300         encp->enc_tx_tso_tcp_header_offset_limit = EF10_TCP_HEADER_OFFSET_LIMIT;
301
302         if ((rc = hunt_nic_get_required_pcie_bandwidth(enp, &bandwidth)) != 0)
303                 goto fail11;
304         encp->enc_required_pcie_bandwidth_mbps = bandwidth;
305
306         /* All Huntington devices have a PCIe Gen3, 8 lane connector */
307         encp->enc_max_pcie_link_gen = EFX_PCIE_LINK_SPEED_GEN3;
308
309         return (0);
310
311 fail11:
312         EFSYS_PROBE(fail11);
313 fail10:
314         EFSYS_PROBE(fail10);
315 fail9:
316         EFSYS_PROBE(fail9);
317 fail8:
318         EFSYS_PROBE(fail8);
319 fail7:
320         EFSYS_PROBE(fail7);
321 fail6:
322         EFSYS_PROBE(fail6);
323 fail5:
324         EFSYS_PROBE(fail5);
325 fail4:
326         EFSYS_PROBE(fail4);
327 fail3:
328         EFSYS_PROBE(fail3);
329 fail2:
330         EFSYS_PROBE(fail2);
331 fail1:
332         EFSYS_PROBE1(fail1, efx_rc_t, rc);
333
334         return (rc);
335 }
336
337
338 #endif  /* EFSYS_OPT_HUNTINGTON */