Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2001-2020 Intel Corporation
3 : : */
4 : :
5 : : #include "ixgbe_type.h"
6 : : #include "ixgbe_82598.h"
7 : : #include "ixgbe_api.h"
8 : : #include "ixgbe_common.h"
9 : : #include "ixgbe_phy.h"
10 : :
11 : : #define IXGBE_82598_MAX_TX_QUEUES 32
12 : : #define IXGBE_82598_MAX_RX_QUEUES 64
13 : : #define IXGBE_82598_RAR_ENTRIES 16
14 : : #define IXGBE_82598_MC_TBL_SIZE 128
15 : : #define IXGBE_82598_VFT_TBL_SIZE 128
16 : : #define IXGBE_82598_RX_PB_SIZE 512
17 : :
18 : : STATIC s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
19 : : ixgbe_link_speed *speed,
20 : : bool *autoneg);
21 : : STATIC enum ixgbe_media_type ixgbe_get_media_type_82598(struct ixgbe_hw *hw);
22 : : STATIC s32 ixgbe_start_mac_link_82598(struct ixgbe_hw *hw,
23 : : bool autoneg_wait_to_complete);
24 : : STATIC s32 ixgbe_check_mac_link_82598(struct ixgbe_hw *hw,
25 : : ixgbe_link_speed *speed, bool *link_up,
26 : : bool link_up_wait_to_complete);
27 : : STATIC s32 ixgbe_setup_mac_link_82598(struct ixgbe_hw *hw,
28 : : ixgbe_link_speed speed,
29 : : bool autoneg_wait_to_complete);
30 : : STATIC s32 ixgbe_setup_copper_link_82598(struct ixgbe_hw *hw,
31 : : ixgbe_link_speed speed,
32 : : bool autoneg_wait_to_complete);
33 : : STATIC s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw);
34 : : STATIC s32 ixgbe_clear_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq);
35 : : STATIC s32 ixgbe_clear_vfta_82598(struct ixgbe_hw *hw);
36 : : STATIC void ixgbe_set_rxpba_82598(struct ixgbe_hw *hw, int num_pb,
37 : : u32 headroom, int strategy);
38 : : STATIC s32 ixgbe_read_i2c_sff8472_82598(struct ixgbe_hw *hw, u8 byte_offset,
39 : : u8 *sff8472_data);
40 : : /**
41 : : * ixgbe_set_pcie_completion_timeout - set pci-e completion timeout
42 : : * @hw: pointer to the HW structure
43 : : *
44 : : * The defaults for 82598 should be in the range of 50us to 50ms,
45 : : * however the hardware default for these parts is 500us to 1ms which is less
46 : : * than the 10ms recommended by the pci-e spec. To address this we need to
47 : : * increase the value to either 10ms to 250ms for capability version 1 config,
48 : : * or 16ms to 55ms for version 2.
49 : : **/
50 : 0 : void ixgbe_set_pcie_completion_timeout(struct ixgbe_hw *hw)
51 : : {
52 : 0 : u32 gcr = IXGBE_READ_REG(hw, IXGBE_GCR);
53 : : u16 pcie_devctl2;
54 : :
55 : : /* only take action if timeout value is defaulted to 0 */
56 [ # # ]: 0 : if (gcr & IXGBE_GCR_CMPL_TMOUT_MASK)
57 : 0 : goto out;
58 : :
59 : : /*
60 : : * if capababilities version is type 1 we can write the
61 : : * timeout of 10ms to 250ms through the GCR register
62 : : */
63 [ # # ]: 0 : if (!(gcr & IXGBE_GCR_CAP_VER2)) {
64 : 0 : gcr |= IXGBE_GCR_CMPL_TMOUT_10ms;
65 : 0 : goto out;
66 : : }
67 : :
68 : : /*
69 : : * for version 2 capabilities we need to write the config space
70 : : * directly in order to set the completion timeout value for
71 : : * 16ms to 55ms
72 : : */
73 : : pcie_devctl2 = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2);
74 : : pcie_devctl2 |= IXGBE_PCI_DEVICE_CONTROL2_16ms;
75 : : IXGBE_WRITE_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2, pcie_devctl2);
76 : 0 : out:
77 : : /* disable completion timeout resend */
78 : 0 : gcr &= ~IXGBE_GCR_CMPL_TMOUT_RESEND;
79 : 0 : IXGBE_WRITE_REG(hw, IXGBE_GCR, gcr);
80 : 0 : }
81 : :
82 : : /**
83 : : * ixgbe_init_ops_82598 - Inits func ptrs and MAC type
84 : : * @hw: pointer to hardware structure
85 : : *
86 : : * Initialize the function pointers and assign the MAC type for 82598.
87 : : * Does not touch the hardware.
88 : : **/
89 : 0 : s32 ixgbe_init_ops_82598(struct ixgbe_hw *hw)
90 : : {
91 : : struct ixgbe_mac_info *mac = &hw->mac;
92 : : struct ixgbe_phy_info *phy = &hw->phy;
93 : : s32 ret_val;
94 : :
95 : 0 : DEBUGFUNC("ixgbe_init_ops_82598");
96 : :
97 : 0 : ret_val = ixgbe_init_phy_ops_generic(hw);
98 : 0 : ret_val = ixgbe_init_ops_generic(hw);
99 : :
100 : : /* PHY */
101 : 0 : phy->ops.init = ixgbe_init_phy_ops_82598;
102 : :
103 : : /* MAC */
104 : 0 : mac->ops.start_hw = ixgbe_start_hw_82598;
105 : 0 : mac->ops.enable_relaxed_ordering = ixgbe_enable_relaxed_ordering_82598;
106 : 0 : mac->ops.reset_hw = ixgbe_reset_hw_82598;
107 : 0 : mac->ops.get_media_type = ixgbe_get_media_type_82598;
108 : 0 : mac->ops.get_supported_physical_layer =
109 : : ixgbe_get_supported_physical_layer_82598;
110 : 0 : mac->ops.read_analog_reg8 = ixgbe_read_analog_reg8_82598;
111 : 0 : mac->ops.write_analog_reg8 = ixgbe_write_analog_reg8_82598;
112 : 0 : mac->ops.set_lan_id = ixgbe_set_lan_id_multi_port_pcie_82598;
113 : 0 : mac->ops.enable_rx_dma = ixgbe_enable_rx_dma_82598;
114 : :
115 : : /* RAR, Multicast, VLAN */
116 : 0 : mac->ops.set_vmdq = ixgbe_set_vmdq_82598;
117 : 0 : mac->ops.clear_vmdq = ixgbe_clear_vmdq_82598;
118 : 0 : mac->ops.set_vfta = ixgbe_set_vfta_82598;
119 : 0 : mac->ops.set_vlvf = NULL;
120 : 0 : mac->ops.clear_vfta = ixgbe_clear_vfta_82598;
121 : :
122 : : /* Flow Control */
123 : 0 : mac->ops.fc_enable = ixgbe_fc_enable_82598;
124 : :
125 : 0 : mac->mcft_size = IXGBE_82598_MC_TBL_SIZE;
126 : 0 : mac->vft_size = IXGBE_82598_VFT_TBL_SIZE;
127 : 0 : mac->num_rar_entries = IXGBE_82598_RAR_ENTRIES;
128 : 0 : mac->rx_pb_size = IXGBE_82598_RX_PB_SIZE;
129 : 0 : mac->max_rx_queues = IXGBE_82598_MAX_RX_QUEUES;
130 : 0 : mac->max_tx_queues = IXGBE_82598_MAX_TX_QUEUES;
131 : 0 : mac->max_msix_vectors = ixgbe_get_pcie_msix_count_generic(hw);
132 : :
133 : : /* SFP+ Module */
134 : 0 : phy->ops.read_i2c_eeprom = ixgbe_read_i2c_eeprom_82598;
135 : 0 : phy->ops.read_i2c_sff8472 = ixgbe_read_i2c_sff8472_82598;
136 : :
137 : : /* Link */
138 : 0 : mac->ops.check_link = ixgbe_check_mac_link_82598;
139 : 0 : mac->ops.setup_link = ixgbe_setup_mac_link_82598;
140 : 0 : mac->ops.flap_tx_laser = NULL;
141 : 0 : mac->ops.get_link_capabilities = ixgbe_get_link_capabilities_82598;
142 : 0 : mac->ops.setup_rxpba = ixgbe_set_rxpba_82598;
143 : :
144 : : /* Manageability interface */
145 : 0 : mac->ops.set_fw_drv_ver = NULL;
146 : :
147 : 0 : mac->ops.get_rtrup2tc = NULL;
148 : :
149 : 0 : return ret_val;
150 : : }
151 : :
152 : : /**
153 : : * ixgbe_init_phy_ops_82598 - PHY/SFP specific init
154 : : * @hw: pointer to hardware structure
155 : : *
156 : : * Initialize any function pointers that were not able to be
157 : : * set during init_shared_code because the PHY/SFP type was
158 : : * not known. Perform the SFP init if necessary.
159 : : *
160 : : **/
161 : 0 : s32 ixgbe_init_phy_ops_82598(struct ixgbe_hw *hw)
162 : : {
163 : : struct ixgbe_mac_info *mac = &hw->mac;
164 : : struct ixgbe_phy_info *phy = &hw->phy;
165 : : s32 ret_val = IXGBE_SUCCESS;
166 : : u16 list_offset, data_offset;
167 : :
168 : 0 : DEBUGFUNC("ixgbe_init_phy_ops_82598");
169 : :
170 : : /* Identify the PHY */
171 : 0 : phy->ops.identify(hw);
172 : :
173 : : /* Overwrite the link function pointers if copper PHY */
174 [ # # ]: 0 : if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
175 : 0 : mac->ops.setup_link = ixgbe_setup_copper_link_82598;
176 : 0 : mac->ops.get_link_capabilities =
177 : : ixgbe_get_copper_link_capabilities_generic;
178 : : }
179 : :
180 [ # # # ]: 0 : switch (hw->phy.type) {
181 : 0 : case ixgbe_phy_tn:
182 : 0 : phy->ops.setup_link = ixgbe_setup_phy_link_tnx;
183 : 0 : phy->ops.check_link = ixgbe_check_phy_link_tnx;
184 : 0 : phy->ops.get_firmware_version =
185 : : ixgbe_get_phy_firmware_version_tnx;
186 : 0 : break;
187 : 0 : case ixgbe_phy_nl:
188 : 0 : phy->ops.reset = ixgbe_reset_phy_nl;
189 : :
190 : : /* Call SFP+ identify routine to get the SFP+ module type */
191 : 0 : ret_val = phy->ops.identify_sfp(hw);
192 [ # # ]: 0 : if (ret_val != IXGBE_SUCCESS)
193 : 0 : goto out;
194 [ # # ]: 0 : else if (hw->phy.sfp_type == ixgbe_sfp_type_unknown) {
195 : : ret_val = IXGBE_ERR_SFP_NOT_SUPPORTED;
196 : 0 : goto out;
197 : : }
198 : :
199 : : /* Check to see if SFP+ module is supported */
200 : 0 : ret_val = ixgbe_get_sfp_init_sequence_offsets(hw,
201 : : &list_offset,
202 : : &data_offset);
203 [ # # ]: 0 : if (ret_val != IXGBE_SUCCESS) {
204 : : ret_val = IXGBE_ERR_SFP_NOT_SUPPORTED;
205 : 0 : goto out;
206 : : }
207 : : break;
208 : : default:
209 : : break;
210 : : }
211 : :
212 : 0 : out:
213 : 0 : return ret_val;
214 : : }
215 : :
216 : : /**
217 : : * ixgbe_start_hw_82598 - Prepare hardware for Tx/Rx
218 : : * @hw: pointer to hardware structure
219 : : *
220 : : * Starts the hardware using the generic start_hw function.
221 : : * Disables relaxed ordering Then set pcie completion timeout
222 : : *
223 : : **/
224 : 0 : s32 ixgbe_start_hw_82598(struct ixgbe_hw *hw)
225 : : {
226 : : u32 regval;
227 : : u32 i;
228 : : s32 ret_val = IXGBE_SUCCESS;
229 : :
230 : 0 : DEBUGFUNC("ixgbe_start_hw_82598");
231 : :
232 : 0 : ret_val = ixgbe_start_hw_generic(hw);
233 [ # # ]: 0 : if (ret_val)
234 : : return ret_val;
235 : :
236 : : /* Disable relaxed ordering */
237 [ # # # # ]: 0 : for (i = 0; ((i < hw->mac.max_tx_queues) &&
238 : 0 : (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
239 : 0 : regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i));
240 : 0 : regval &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
241 : 0 : IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), regval);
242 : : }
243 : :
244 [ # # # # ]: 0 : for (i = 0; ((i < hw->mac.max_rx_queues) &&
245 : 0 : (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
246 : 0 : regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
247 : 0 : regval &= ~(IXGBE_DCA_RXCTRL_DATA_WRO_EN |
248 : : IXGBE_DCA_RXCTRL_HEAD_WRO_EN);
249 : 0 : IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
250 : : }
251 : :
252 : : /* set the completion timeout for interface */
253 : 0 : ixgbe_set_pcie_completion_timeout(hw);
254 : :
255 : 0 : return ret_val;
256 : : }
257 : :
258 : : /**
259 : : * ixgbe_get_link_capabilities_82598 - Determines link capabilities
260 : : * @hw: pointer to hardware structure
261 : : * @speed: pointer to link speed
262 : : * @autoneg: boolean auto-negotiation value
263 : : *
264 : : * Determines the link capabilities by reading the AUTOC register.
265 : : **/
266 : 0 : STATIC s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
267 : : ixgbe_link_speed *speed,
268 : : bool *autoneg)
269 : : {
270 : : s32 status = IXGBE_SUCCESS;
271 : : u32 autoc = 0;
272 : :
273 : 0 : DEBUGFUNC("ixgbe_get_link_capabilities_82598");
274 : :
275 : : /*
276 : : * Determine link capabilities based on the stored value of AUTOC,
277 : : * which represents EEPROM defaults. If AUTOC value has not been
278 : : * stored, use the current register value.
279 : : */
280 [ # # ]: 0 : if (hw->mac.orig_link_settings_stored)
281 : 0 : autoc = hw->mac.orig_autoc;
282 : : else
283 : 0 : autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
284 : :
285 [ # # # # : 0 : switch (autoc & IXGBE_AUTOC_LMS_MASK) {
# ]
286 : 0 : case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
287 : 0 : *speed = IXGBE_LINK_SPEED_1GB_FULL;
288 : 0 : *autoneg = false;
289 : 0 : break;
290 : :
291 : 0 : case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
292 : 0 : *speed = IXGBE_LINK_SPEED_10GB_FULL;
293 : 0 : *autoneg = false;
294 : 0 : break;
295 : :
296 : 0 : case IXGBE_AUTOC_LMS_1G_AN:
297 : 0 : *speed = IXGBE_LINK_SPEED_1GB_FULL;
298 : 0 : *autoneg = true;
299 : 0 : break;
300 : :
301 : 0 : case IXGBE_AUTOC_LMS_KX4_AN:
302 : : case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
303 : 0 : *speed = IXGBE_LINK_SPEED_UNKNOWN;
304 [ # # ]: 0 : if (autoc & IXGBE_AUTOC_KX4_SUPP)
305 : 0 : *speed |= IXGBE_LINK_SPEED_10GB_FULL;
306 [ # # ]: 0 : if (autoc & IXGBE_AUTOC_KX_SUPP)
307 : 0 : *speed |= IXGBE_LINK_SPEED_1GB_FULL;
308 : 0 : *autoneg = true;
309 : 0 : break;
310 : :
311 : : default:
312 : : status = IXGBE_ERR_LINK_SETUP;
313 : : break;
314 : : }
315 : :
316 : 0 : return status;
317 : : }
318 : :
319 : : /**
320 : : * ixgbe_get_media_type_82598 - Determines media type
321 : : * @hw: pointer to hardware structure
322 : : *
323 : : * Returns the media type (fiber, copper, backplane)
324 : : **/
325 : 0 : STATIC enum ixgbe_media_type ixgbe_get_media_type_82598(struct ixgbe_hw *hw)
326 : : {
327 : : enum ixgbe_media_type media_type;
328 : :
329 : 0 : DEBUGFUNC("ixgbe_get_media_type_82598");
330 : :
331 : : /* Detect if there is a copper PHY attached. */
332 [ # # ]: 0 : switch (hw->phy.type) {
333 : 0 : case ixgbe_phy_cu_unknown:
334 : : case ixgbe_phy_tn:
335 : : media_type = ixgbe_media_type_copper;
336 : 0 : goto out;
337 : : default:
338 : : break;
339 : : }
340 : :
341 : : /* Media type for I82598 is based on device ID */
342 [ # # # # : 0 : switch (hw->device_id) {
# ]
343 : : case IXGBE_DEV_ID_82598:
344 : : case IXGBE_DEV_ID_82598_BX:
345 : : /* Default device ID is mezzanine card KX/KX4 */
346 : : media_type = ixgbe_media_type_backplane;
347 : : break;
348 : 0 : case IXGBE_DEV_ID_82598AF_DUAL_PORT:
349 : : case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
350 : : case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
351 : : case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
352 : : case IXGBE_DEV_ID_82598EB_XF_LR:
353 : : case IXGBE_DEV_ID_82598EB_SFP_LOM:
354 : : media_type = ixgbe_media_type_fiber;
355 : 0 : break;
356 : 0 : case IXGBE_DEV_ID_82598EB_CX4:
357 : : case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
358 : : media_type = ixgbe_media_type_cx4;
359 : 0 : break;
360 : 0 : case IXGBE_DEV_ID_82598AT:
361 : : case IXGBE_DEV_ID_82598AT2:
362 : : media_type = ixgbe_media_type_copper;
363 : 0 : break;
364 : 0 : default:
365 : : media_type = ixgbe_media_type_unknown;
366 : 0 : break;
367 : : }
368 : 0 : out:
369 : 0 : return media_type;
370 : : }
371 : :
372 : : /**
373 : : * ixgbe_fc_enable_82598 - Enable flow control
374 : : * @hw: pointer to hardware structure
375 : : *
376 : : * Enable flow control according to the current settings.
377 : : **/
378 : 0 : s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw)
379 : : {
380 : : s32 ret_val = IXGBE_SUCCESS;
381 : : u32 fctrl_reg;
382 : : u32 rmcs_reg;
383 : : u32 reg;
384 : : u32 fcrtl, fcrth;
385 : 0 : u32 link_speed = 0;
386 : : int i;
387 : : bool link_up;
388 : :
389 : 0 : DEBUGFUNC("ixgbe_fc_enable_82598");
390 : :
391 : : /* Validate the water mark configuration */
392 [ # # ]: 0 : if (!hw->fc.pause_time) {
393 : : ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
394 : 0 : goto out;
395 : : }
396 : :
397 : : /* Low water mark of zero causes XOFF floods */
398 [ # # ]: 0 : for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
399 [ # # ]: 0 : if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
400 [ # # ]: 0 : hw->fc.high_water[i]) {
401 [ # # # # ]: 0 : if (!hw->fc.low_water[i] ||
402 : : hw->fc.low_water[i] >= hw->fc.high_water[i]) {
403 : 0 : DEBUGOUT("Invalid water mark configuration\n");
404 : : ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
405 : 0 : goto out;
406 : : }
407 : : }
408 : : }
409 : :
410 : : /*
411 : : * On 82598 having Rx FC on causes resets while doing 1G
412 : : * so if it's on turn it off once we know link_speed. For
413 : : * more details see 82598 Specification update.
414 : : */
415 : 0 : hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
416 [ # # # # ]: 0 : if (link_up && link_speed == IXGBE_LINK_SPEED_1GB_FULL) {
417 [ # # # ]: 0 : switch (hw->fc.requested_mode) {
418 : 0 : case ixgbe_fc_full:
419 : 0 : hw->fc.requested_mode = ixgbe_fc_tx_pause;
420 : 0 : break;
421 : 0 : case ixgbe_fc_rx_pause:
422 : 0 : hw->fc.requested_mode = ixgbe_fc_none;
423 : 0 : break;
424 : : default:
425 : : /* no change */
426 : : break;
427 : : }
428 : : }
429 : :
430 : : /* Negotiate the fc mode to use */
431 : 0 : ixgbe_fc_autoneg(hw);
432 : :
433 : : /* Disable any previous flow control settings */
434 : 0 : fctrl_reg = IXGBE_READ_REG(hw, IXGBE_FCTRL);
435 : 0 : fctrl_reg &= ~(IXGBE_FCTRL_RFCE | IXGBE_FCTRL_RPFCE);
436 : :
437 : 0 : rmcs_reg = IXGBE_READ_REG(hw, IXGBE_RMCS);
438 : 0 : rmcs_reg &= ~(IXGBE_RMCS_TFCE_PRIORITY | IXGBE_RMCS_TFCE_802_3X);
439 : :
440 : : /*
441 : : * The possible values of fc.current_mode are:
442 : : * 0: Flow control is completely disabled
443 : : * 1: Rx flow control is enabled (we can receive pause frames,
444 : : * but not send pause frames).
445 : : * 2: Tx flow control is enabled (we can send pause frames but
446 : : * we do not support receiving pause frames).
447 : : * 3: Both Rx and Tx flow control (symmetric) are enabled.
448 : : * other: Invalid.
449 : : */
450 [ # # # # : 0 : switch (hw->fc.current_mode) {
# ]
451 : : case ixgbe_fc_none:
452 : : /*
453 : : * Flow control is disabled by software override or autoneg.
454 : : * The code below will actually disable it in the HW.
455 : : */
456 : : break;
457 : 0 : case ixgbe_fc_rx_pause:
458 : : /*
459 : : * Rx Flow control is enabled and Tx Flow control is
460 : : * disabled by software override. Since there really
461 : : * isn't a way to advertise that we are capable of RX
462 : : * Pause ONLY, we will advertise that we support both
463 : : * symmetric and asymmetric Rx PAUSE. Later, we will
464 : : * disable the adapter's ability to send PAUSE frames.
465 : : */
466 : 0 : fctrl_reg |= IXGBE_FCTRL_RFCE;
467 : 0 : break;
468 : 0 : case ixgbe_fc_tx_pause:
469 : : /*
470 : : * Tx Flow control is enabled, and Rx Flow control is
471 : : * disabled by software override.
472 : : */
473 : 0 : rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
474 : 0 : break;
475 : 0 : case ixgbe_fc_full:
476 : : /* Flow control (both Rx and Tx) is enabled by SW override. */
477 : 0 : fctrl_reg |= IXGBE_FCTRL_RFCE;
478 : 0 : rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
479 : 0 : break;
480 : 0 : default:
481 : 0 : DEBUGOUT("Flow control param set incorrectly\n");
482 : : ret_val = IXGBE_ERR_CONFIG;
483 : 0 : goto out;
484 : : break;
485 : : }
486 : :
487 : : /* Set 802.3x based flow control settings. */
488 : 0 : fctrl_reg |= IXGBE_FCTRL_DPF;
489 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl_reg);
490 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RMCS, rmcs_reg);
491 : :
492 : : /* Set up and enable Rx high/low water mark thresholds, enable XON. */
493 [ # # ]: 0 : for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
494 [ # # ]: 0 : if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
495 [ # # ]: 0 : hw->fc.high_water[i]) {
496 : 0 : fcrtl = (hw->fc.low_water[i] << 10) | IXGBE_FCRTL_XONE;
497 : 0 : fcrth = (hw->fc.high_water[i] << 10) | IXGBE_FCRTH_FCEN;
498 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCRTL(i), fcrtl);
499 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCRTH(i), fcrth);
500 : : } else {
501 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCRTL(i), 0);
502 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCRTH(i), 0);
503 : : }
504 : :
505 : : }
506 : :
507 : : /* Configure pause time (2 TCs per register) */
508 : 0 : reg = hw->fc.pause_time * 0x00010001;
509 [ # # ]: 0 : for (i = 0; i < (IXGBE_DCB_MAX_TRAFFIC_CLASS / 2); i++)
510 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
511 : :
512 : : /* Configure flow control refresh threshold value */
513 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
514 : :
515 : 0 : out:
516 : 0 : return ret_val;
517 : : }
518 : :
519 : : /**
520 : : * ixgbe_start_mac_link_82598 - Configures MAC link settings
521 : : * @hw: pointer to hardware structure
522 : : * @autoneg_wait_to_complete: true when waiting for completion is needed
523 : : *
524 : : * Configures link settings based on values in the ixgbe_hw struct.
525 : : * Restarts the link. Performs autonegotiation if needed.
526 : : **/
527 : 0 : STATIC s32 ixgbe_start_mac_link_82598(struct ixgbe_hw *hw,
528 : : bool autoneg_wait_to_complete)
529 : : {
530 : : u32 autoc_reg;
531 : : u32 links_reg;
532 : : u32 i;
533 : : s32 status = IXGBE_SUCCESS;
534 : :
535 : 0 : DEBUGFUNC("ixgbe_start_mac_link_82598");
536 : :
537 : : /* Restart link */
538 : 0 : autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
539 : 0 : autoc_reg |= IXGBE_AUTOC_AN_RESTART;
540 : 0 : IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
541 : :
542 : : /* Only poll for autoneg to complete if specified to do so */
543 [ # # ]: 0 : if (autoneg_wait_to_complete) {
544 : 0 : if ((autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
545 [ # # ]: 0 : IXGBE_AUTOC_LMS_KX4_AN ||
546 : : (autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
547 : : IXGBE_AUTOC_LMS_KX4_AN_1G_AN) {
548 : : links_reg = 0; /* Just in case Autoneg time = 0 */
549 [ # # ]: 0 : for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) {
550 : 0 : links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
551 [ # # ]: 0 : if (links_reg & IXGBE_LINKS_KX_AN_COMP)
552 : : break;
553 : 0 : msec_delay(100);
554 : : }
555 [ # # ]: 0 : if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) {
556 : : status = IXGBE_ERR_AUTONEG_NOT_COMPLETE;
557 : 0 : DEBUGOUT("Autonegotiation did not complete.\n");
558 : : }
559 : : }
560 : : }
561 : :
562 : : /* Add delay to filter out noises during initial link setup */
563 : 0 : msec_delay(50);
564 : :
565 : 0 : return status;
566 : : }
567 : :
568 : : /**
569 : : * ixgbe_validate_link_ready - Function looks for phy link
570 : : * @hw: pointer to hardware structure
571 : : *
572 : : * Function indicates success when phy link is available. If phy is not ready
573 : : * within 5 seconds of MAC indicating link, the function returns error.
574 : : **/
575 : 0 : STATIC s32 ixgbe_validate_link_ready(struct ixgbe_hw *hw)
576 : : {
577 : : u32 timeout;
578 : : u16 an_reg;
579 : :
580 [ # # ]: 0 : if (hw->device_id != IXGBE_DEV_ID_82598AT2)
581 : : return IXGBE_SUCCESS;
582 : :
583 : : for (timeout = 0;
584 [ # # ]: 0 : timeout < IXGBE_VALIDATE_LINK_READY_TIMEOUT; timeout++) {
585 : 0 : hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
586 : : IXGBE_MDIO_AUTO_NEG_DEV_TYPE, &an_reg);
587 : :
588 [ # # ]: 0 : if ((an_reg & IXGBE_MII_AUTONEG_COMPLETE) &&
589 : : (an_reg & IXGBE_MII_AUTONEG_LINK_UP))
590 : : break;
591 : :
592 : 0 : msec_delay(100);
593 : : }
594 : :
595 [ # # ]: 0 : if (timeout == IXGBE_VALIDATE_LINK_READY_TIMEOUT) {
596 : 0 : DEBUGOUT("Link was indicated but link is down\n");
597 : 0 : return IXGBE_ERR_LINK_SETUP;
598 : : }
599 : :
600 : : return IXGBE_SUCCESS;
601 : : }
602 : :
603 : : /**
604 : : * ixgbe_check_mac_link_82598 - Get link/speed status
605 : : * @hw: pointer to hardware structure
606 : : * @speed: pointer to link speed
607 : : * @link_up: true is link is up, false otherwise
608 : : * @link_up_wait_to_complete: bool used to wait for link up or not
609 : : *
610 : : * Reads the links register to determine if link is up and the current speed
611 : : **/
612 : 0 : STATIC s32 ixgbe_check_mac_link_82598(struct ixgbe_hw *hw,
613 : : ixgbe_link_speed *speed, bool *link_up,
614 : : bool link_up_wait_to_complete)
615 : : {
616 : : u32 links_reg;
617 : : u32 i;
618 : : u16 link_reg, adapt_comp_reg;
619 : :
620 : 0 : DEBUGFUNC("ixgbe_check_mac_link_82598");
621 : :
622 : : /*
623 : : * SERDES PHY requires us to read link status from undocumented
624 : : * register 0xC79F. Bit 0 set indicates link is up/ready; clear
625 : : * indicates link down. OxC00C is read to check that the XAUI lanes
626 : : * are active. Bit 0 clear indicates active; set indicates inactive.
627 : : */
628 [ # # ]: 0 : if (hw->phy.type == ixgbe_phy_nl) {
629 : 0 : hw->phy.ops.read_reg(hw, 0xC79F, IXGBE_TWINAX_DEV, &link_reg);
630 : 0 : hw->phy.ops.read_reg(hw, 0xC79F, IXGBE_TWINAX_DEV, &link_reg);
631 : 0 : hw->phy.ops.read_reg(hw, 0xC00C, IXGBE_TWINAX_DEV,
632 : : &adapt_comp_reg);
633 [ # # ]: 0 : if (link_up_wait_to_complete) {
634 [ # # ]: 0 : for (i = 0; i < hw->mac.max_link_up_time; i++) {
635 [ # # ]: 0 : if ((link_reg & 1) &&
636 [ # # ]: 0 : ((adapt_comp_reg & 1) == 0)) {
637 : 0 : *link_up = true;
638 : 0 : break;
639 : : } else {
640 : 0 : *link_up = false;
641 : : }
642 : 0 : msec_delay(100);
643 : 0 : hw->phy.ops.read_reg(hw, 0xC79F,
644 : : IXGBE_TWINAX_DEV,
645 : : &link_reg);
646 : 0 : hw->phy.ops.read_reg(hw, 0xC00C,
647 : : IXGBE_TWINAX_DEV,
648 : : &adapt_comp_reg);
649 : : }
650 : : } else {
651 [ # # # # ]: 0 : if ((link_reg & 1) && ((adapt_comp_reg & 1) == 0))
652 : 0 : *link_up = true;
653 : : else
654 : 0 : *link_up = false;
655 : : }
656 : :
657 [ # # ]: 0 : if (*link_up == false)
658 : 0 : goto out;
659 : : }
660 : :
661 : 0 : links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
662 [ # # ]: 0 : if (link_up_wait_to_complete) {
663 [ # # ]: 0 : for (i = 0; i < hw->mac.max_link_up_time; i++) {
664 [ # # ]: 0 : if (links_reg & IXGBE_LINKS_UP) {
665 : 0 : *link_up = true;
666 : 0 : break;
667 : : } else {
668 : 0 : *link_up = false;
669 : : }
670 : 0 : msec_delay(100);
671 : 0 : links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
672 : : }
673 : : } else {
674 [ # # ]: 0 : if (links_reg & IXGBE_LINKS_UP)
675 : 0 : *link_up = true;
676 : : else
677 : 0 : *link_up = false;
678 : : }
679 : :
680 [ # # ]: 0 : if (links_reg & IXGBE_LINKS_SPEED)
681 : 0 : *speed = IXGBE_LINK_SPEED_10GB_FULL;
682 : : else
683 : 0 : *speed = IXGBE_LINK_SPEED_1GB_FULL;
684 : :
685 [ # # # # : 0 : if ((hw->device_id == IXGBE_DEV_ID_82598AT2) && (*link_up == true) &&
# # ]
686 : 0 : (ixgbe_validate_link_ready(hw) != IXGBE_SUCCESS))
687 : 0 : *link_up = false;
688 : :
689 : 0 : out:
690 : 0 : return IXGBE_SUCCESS;
691 : : }
692 : :
693 : : /**
694 : : * ixgbe_setup_mac_link_82598 - Set MAC link speed
695 : : * @hw: pointer to hardware structure
696 : : * @speed: new link speed
697 : : * @autoneg_wait_to_complete: true when waiting for completion is needed
698 : : *
699 : : * Set the link speed in the AUTOC register and restarts link.
700 : : **/
701 : 0 : STATIC s32 ixgbe_setup_mac_link_82598(struct ixgbe_hw *hw,
702 : : ixgbe_link_speed speed,
703 : : bool autoneg_wait_to_complete)
704 : : {
705 : 0 : bool autoneg = false;
706 : : s32 status = IXGBE_SUCCESS;
707 : 0 : ixgbe_link_speed link_capabilities = IXGBE_LINK_SPEED_UNKNOWN;
708 : 0 : u32 curr_autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
709 : : u32 autoc = curr_autoc;
710 : 0 : u32 link_mode = autoc & IXGBE_AUTOC_LMS_MASK;
711 : :
712 : 0 : DEBUGFUNC("ixgbe_setup_mac_link_82598");
713 : :
714 : : /* Check to see if speed passed in is supported. */
715 : 0 : ixgbe_get_link_capabilities(hw, &link_capabilities, &autoneg);
716 : 0 : speed &= link_capabilities;
717 : :
718 [ # # ]: 0 : if (speed == IXGBE_LINK_SPEED_UNKNOWN)
719 : : status = IXGBE_ERR_LINK_SETUP;
720 : :
721 : : /* Set KX4/KX support according to speed requested */
722 : 0 : else if (link_mode == IXGBE_AUTOC_LMS_KX4_AN ||
723 [ # # ]: 0 : link_mode == IXGBE_AUTOC_LMS_KX4_AN_1G_AN) {
724 : 0 : autoc &= ~IXGBE_AUTOC_KX4_KX_SUPP_MASK;
725 [ # # ]: 0 : if (speed & IXGBE_LINK_SPEED_10GB_FULL)
726 : 0 : autoc |= IXGBE_AUTOC_KX4_SUPP;
727 [ # # ]: 0 : if (speed & IXGBE_LINK_SPEED_1GB_FULL)
728 : 0 : autoc |= IXGBE_AUTOC_KX_SUPP;
729 [ # # ]: 0 : if (autoc != curr_autoc)
730 : 0 : IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc);
731 : : }
732 : :
733 : : if (status == IXGBE_SUCCESS) {
734 : : /*
735 : : * Setup and restart the link based on the new values in
736 : : * ixgbe_hw This will write the AUTOC register based on the new
737 : : * stored values
738 : : */
739 : 0 : status = ixgbe_start_mac_link_82598(hw,
740 : : autoneg_wait_to_complete);
741 : : }
742 : :
743 : 0 : return status;
744 : : }
745 : :
746 : :
747 : : /**
748 : : * ixgbe_setup_copper_link_82598 - Set the PHY autoneg advertised field
749 : : * @hw: pointer to hardware structure
750 : : * @speed: new link speed
751 : : * @autoneg_wait_to_complete: true if waiting is needed to complete
752 : : *
753 : : * Sets the link speed in the AUTOC register in the MAC and restarts link.
754 : : **/
755 : 0 : STATIC s32 ixgbe_setup_copper_link_82598(struct ixgbe_hw *hw,
756 : : ixgbe_link_speed speed,
757 : : bool autoneg_wait_to_complete)
758 : : {
759 : : s32 status;
760 : :
761 : 0 : DEBUGFUNC("ixgbe_setup_copper_link_82598");
762 : :
763 : : /* Setup the PHY according to input speed */
764 : 0 : status = hw->phy.ops.setup_link_speed(hw, speed,
765 : : autoneg_wait_to_complete);
766 : : /* Set up MAC */
767 : 0 : ixgbe_start_mac_link_82598(hw, autoneg_wait_to_complete);
768 : :
769 : 0 : return status;
770 : : }
771 : :
772 : : /**
773 : : * ixgbe_reset_hw_82598 - Performs hardware reset
774 : : * @hw: pointer to hardware structure
775 : : *
776 : : * Resets the hardware by resetting the transmit and receive units, masks and
777 : : * clears all interrupts, performing a PHY reset, and performing a link (MAC)
778 : : * reset.
779 : : **/
780 : 0 : STATIC s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw)
781 : : {
782 : : s32 status = IXGBE_SUCCESS;
783 : : s32 phy_status = IXGBE_SUCCESS;
784 : : u32 ctrl;
785 : : u32 gheccr;
786 : : u32 i;
787 : : u32 autoc;
788 : : u8 analog_val;
789 : :
790 : 0 : DEBUGFUNC("ixgbe_reset_hw_82598");
791 : :
792 : : /* Call adapter stop to disable tx/rx and clear interrupts */
793 : 0 : status = hw->mac.ops.stop_adapter(hw);
794 [ # # ]: 0 : if (status != IXGBE_SUCCESS)
795 : 0 : goto reset_hw_out;
796 : :
797 : : /*
798 : : * Power up the Atlas Tx lanes if they are currently powered down.
799 : : * Atlas Tx lanes are powered down for MAC loopback tests, but
800 : : * they are not automatically restored on reset.
801 : : */
802 : 0 : hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK, &analog_val);
803 [ # # ]: 0 : if (analog_val & IXGBE_ATLAS_PDN_TX_REG_EN) {
804 : : /* Enable Tx Atlas so packets can be transmitted again */
805 : 0 : hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK,
806 : : &analog_val);
807 : 0 : analog_val &= ~IXGBE_ATLAS_PDN_TX_REG_EN;
808 : 0 : hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK,
809 : : analog_val);
810 : :
811 : 0 : hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_10G,
812 : : &analog_val);
813 : 0 : analog_val &= ~IXGBE_ATLAS_PDN_TX_10G_QL_ALL;
814 : 0 : hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_10G,
815 : : analog_val);
816 : :
817 : 0 : hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_1G,
818 : : &analog_val);
819 : 0 : analog_val &= ~IXGBE_ATLAS_PDN_TX_1G_QL_ALL;
820 : 0 : hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_1G,
821 : : analog_val);
822 : :
823 : 0 : hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_AN,
824 : : &analog_val);
825 : 0 : analog_val &= ~IXGBE_ATLAS_PDN_TX_AN_QL_ALL;
826 : 0 : hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_AN,
827 : : analog_val);
828 : : }
829 : :
830 : : /* Reset PHY */
831 [ # # ]: 0 : if (hw->phy.reset_disable == false) {
832 : : /* PHY ops must be identified and initialized prior to reset */
833 : :
834 : : /* Init PHY and function pointers, perform SFP setup */
835 : 0 : phy_status = hw->phy.ops.init(hw);
836 [ # # ]: 0 : if (phy_status == IXGBE_ERR_SFP_NOT_SUPPORTED)
837 : 0 : goto reset_hw_out;
838 [ # # ]: 0 : if (phy_status == IXGBE_ERR_SFP_NOT_PRESENT)
839 : 0 : goto mac_reset_top;
840 : :
841 : 0 : hw->phy.ops.reset(hw);
842 : : }
843 : :
844 : 0 : mac_reset_top:
845 : : /*
846 : : * Issue global reset to the MAC. This needs to be a SW reset.
847 : : * If link reset is used, it might reset the MAC when mng is using it
848 : : */
849 : 0 : ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL) | IXGBE_CTRL_RST;
850 : 0 : IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
851 : 0 : IXGBE_WRITE_FLUSH(hw);
852 : :
853 : : /* Poll for reset bit to self-clear indicating reset is complete */
854 [ # # ]: 0 : for (i = 0; i < 10; i++) {
855 : 0 : usec_delay(1);
856 : 0 : ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
857 [ # # ]: 0 : if (!(ctrl & IXGBE_CTRL_RST))
858 : : break;
859 : : }
860 [ # # ]: 0 : if (ctrl & IXGBE_CTRL_RST) {
861 : : status = IXGBE_ERR_RESET_FAILED;
862 : 0 : DEBUGOUT("Reset polling failed to complete.\n");
863 : : }
864 : :
865 : 0 : msec_delay(50);
866 : :
867 : : /*
868 : : * Double resets are required for recovery from certain error
869 : : * conditions. Between resets, it is necessary to stall to allow time
870 : : * for any pending HW events to complete.
871 : : */
872 [ # # ]: 0 : if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) {
873 : 0 : hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
874 : 0 : goto mac_reset_top;
875 : : }
876 : :
877 : 0 : gheccr = IXGBE_READ_REG(hw, IXGBE_GHECCR);
878 : 0 : gheccr &= ~((1 << 21) | (1 << 18) | (1 << 9) | (1 << 6));
879 : 0 : IXGBE_WRITE_REG(hw, IXGBE_GHECCR, gheccr);
880 : :
881 : : /*
882 : : * Store the original AUTOC value if it has not been
883 : : * stored off yet. Otherwise restore the stored original
884 : : * AUTOC value since the reset operation sets back to deaults.
885 : : */
886 : 0 : autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
887 [ # # ]: 0 : if (hw->mac.orig_link_settings_stored == false) {
888 : 0 : hw->mac.orig_autoc = autoc;
889 : 0 : hw->mac.orig_link_settings_stored = true;
890 [ # # ]: 0 : } else if (autoc != hw->mac.orig_autoc) {
891 : 0 : IXGBE_WRITE_REG(hw, IXGBE_AUTOC, hw->mac.orig_autoc);
892 : : }
893 : :
894 : : /* Store the permanent mac address */
895 : 0 : hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
896 : :
897 : : /*
898 : : * Store MAC address from RAR0, clear receive address registers, and
899 : : * clear the multicast table
900 : : */
901 : 0 : hw->mac.ops.init_rx_addrs(hw);
902 : :
903 : 0 : reset_hw_out:
904 [ # # ]: 0 : if (phy_status != IXGBE_SUCCESS)
905 : : status = phy_status;
906 : :
907 : 0 : return status;
908 : : }
909 : :
910 : : /**
911 : : * ixgbe_set_vmdq_82598 - Associate a VMDq set index with a rx address
912 : : * @hw: pointer to hardware struct
913 : : * @rar: receive address register index to associate with a VMDq index
914 : : * @vmdq: VMDq set index
915 : : **/
916 : 0 : s32 ixgbe_set_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
917 : : {
918 : : u32 rar_high;
919 : 0 : u32 rar_entries = hw->mac.num_rar_entries;
920 : :
921 : 0 : DEBUGFUNC("ixgbe_set_vmdq_82598");
922 : :
923 : : /* Make sure we are using a valid rar index range */
924 [ # # ]: 0 : if (rar >= rar_entries) {
925 : 0 : DEBUGOUT1("RAR index %d is out of range.\n", rar);
926 : 0 : return IXGBE_ERR_INVALID_ARGUMENT;
927 : : }
928 : :
929 [ # # ]: 0 : rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
930 : 0 : rar_high &= ~IXGBE_RAH_VIND_MASK;
931 : 0 : rar_high |= ((vmdq << IXGBE_RAH_VIND_SHIFT) & IXGBE_RAH_VIND_MASK);
932 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RAH(rar), rar_high);
933 : 0 : return IXGBE_SUCCESS;
934 : : }
935 : :
936 : : /**
937 : : * ixgbe_clear_vmdq_82598 - Disassociate a VMDq set index from an rx address
938 : : * @hw: pointer to hardware struct
939 : : * @rar: receive address register index to associate with a VMDq index
940 : : * @vmdq: VMDq clear index (not used in 82598, but elsewhere)
941 : : **/
942 : 0 : STATIC s32 ixgbe_clear_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
943 : : {
944 : : u32 rar_high;
945 : 0 : u32 rar_entries = hw->mac.num_rar_entries;
946 : :
947 : : UNREFERENCED_1PARAMETER(vmdq);
948 : :
949 : : /* Make sure we are using a valid rar index range */
950 [ # # ]: 0 : if (rar >= rar_entries) {
951 : 0 : DEBUGOUT1("RAR index %d is out of range.\n", rar);
952 : 0 : return IXGBE_ERR_INVALID_ARGUMENT;
953 : : }
954 : :
955 [ # # ]: 0 : rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
956 [ # # ]: 0 : if (rar_high & IXGBE_RAH_VIND_MASK) {
957 : 0 : rar_high &= ~IXGBE_RAH_VIND_MASK;
958 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RAH(rar), rar_high);
959 : : }
960 : :
961 : : return IXGBE_SUCCESS;
962 : : }
963 : :
964 : : /**
965 : : * ixgbe_set_vfta_82598 - Set VLAN filter table
966 : : * @hw: pointer to hardware structure
967 : : * @vlan: VLAN id to write to VLAN filter
968 : : * @vind: VMDq output index that maps queue to VLAN id in VFTA
969 : : * @vlan_on: boolean flag to turn on/off VLAN in VFTA
970 : : * @vlvf_bypass: boolean flag - unused
971 : : *
972 : : * Turn on/off specified VLAN in the VLAN filter table.
973 : : **/
974 : 0 : s32 ixgbe_set_vfta_82598(struct ixgbe_hw *hw, u32 vlan, u32 vind,
975 : : bool vlan_on, bool vlvf_bypass)
976 : : {
977 : : u32 regindex;
978 : : u32 bitindex;
979 : : u32 bits;
980 : : u32 vftabyte;
981 : :
982 : : UNREFERENCED_1PARAMETER(vlvf_bypass);
983 : :
984 : 0 : DEBUGFUNC("ixgbe_set_vfta_82598");
985 : :
986 [ # # ]: 0 : if (vlan > 4095)
987 : : return IXGBE_ERR_PARAM;
988 : :
989 : : /* Determine 32-bit word position in array */
990 : 0 : regindex = (vlan >> 5) & 0x7F; /* upper seven bits */
991 : :
992 : : /* Determine the location of the (VMD) queue index */
993 : 0 : vftabyte = ((vlan >> 3) & 0x03); /* bits (4:3) indicating byte array */
994 : 0 : bitindex = (vlan & 0x7) << 2; /* lower 3 bits indicate nibble */
995 : :
996 : : /* Set the nibble for VMD queue index */
997 : 0 : bits = IXGBE_READ_REG(hw, IXGBE_VFTAVIND(vftabyte, regindex));
998 : 0 : bits &= (~(0x0F << bitindex));
999 : 0 : bits |= (vind << bitindex);
1000 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VFTAVIND(vftabyte, regindex), bits);
1001 : :
1002 : : /* Determine the location of the bit for this VLAN id */
1003 : 0 : bitindex = vlan & 0x1F; /* lower five bits */
1004 : :
1005 : 0 : bits = IXGBE_READ_REG(hw, IXGBE_VFTA(regindex));
1006 [ # # ]: 0 : if (vlan_on)
1007 : : /* Turn on this VLAN id */
1008 : 0 : bits |= (1 << bitindex);
1009 : : else
1010 : : /* Turn off this VLAN id */
1011 : 0 : bits &= ~(1 << bitindex);
1012 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VFTA(regindex), bits);
1013 : :
1014 : 0 : return IXGBE_SUCCESS;
1015 : : }
1016 : :
1017 : : /**
1018 : : * ixgbe_clear_vfta_82598 - Clear VLAN filter table
1019 : : * @hw: pointer to hardware structure
1020 : : *
1021 : : * Clears the VLAN filer table, and the VMDq index associated with the filter
1022 : : **/
1023 : 0 : STATIC s32 ixgbe_clear_vfta_82598(struct ixgbe_hw *hw)
1024 : : {
1025 : : u32 offset;
1026 : : u32 vlanbyte;
1027 : :
1028 : 0 : DEBUGFUNC("ixgbe_clear_vfta_82598");
1029 : :
1030 [ # # ]: 0 : for (offset = 0; offset < hw->mac.vft_size; offset++)
1031 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VFTA(offset), 0);
1032 : :
1033 [ # # ]: 0 : for (vlanbyte = 0; vlanbyte < 4; vlanbyte++)
1034 [ # # ]: 0 : for (offset = 0; offset < hw->mac.vft_size; offset++)
1035 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VFTAVIND(vlanbyte, offset),
1036 : : 0);
1037 : :
1038 : 0 : return IXGBE_SUCCESS;
1039 : : }
1040 : :
1041 : : /**
1042 : : * ixgbe_read_analog_reg8_82598 - Reads 8 bit Atlas analog register
1043 : : * @hw: pointer to hardware structure
1044 : : * @reg: analog register to read
1045 : : * @val: read value
1046 : : *
1047 : : * Performs read operation to Atlas analog register specified.
1048 : : **/
1049 : 0 : s32 ixgbe_read_analog_reg8_82598(struct ixgbe_hw *hw, u32 reg, u8 *val)
1050 : : {
1051 : : u32 atlas_ctl;
1052 : :
1053 : 0 : DEBUGFUNC("ixgbe_read_analog_reg8_82598");
1054 : :
1055 : 0 : IXGBE_WRITE_REG(hw, IXGBE_ATLASCTL,
1056 : : IXGBE_ATLASCTL_WRITE_CMD | (reg << 8));
1057 : 0 : IXGBE_WRITE_FLUSH(hw);
1058 : 0 : usec_delay(10);
1059 : 0 : atlas_ctl = IXGBE_READ_REG(hw, IXGBE_ATLASCTL);
1060 : 0 : *val = (u8)atlas_ctl;
1061 : :
1062 : 0 : return IXGBE_SUCCESS;
1063 : : }
1064 : :
1065 : : /**
1066 : : * ixgbe_write_analog_reg8_82598 - Writes 8 bit Atlas analog register
1067 : : * @hw: pointer to hardware structure
1068 : : * @reg: atlas register to write
1069 : : * @val: value to write
1070 : : *
1071 : : * Performs write operation to Atlas analog register specified.
1072 : : **/
1073 : 0 : s32 ixgbe_write_analog_reg8_82598(struct ixgbe_hw *hw, u32 reg, u8 val)
1074 : : {
1075 : : u32 atlas_ctl;
1076 : :
1077 : 0 : DEBUGFUNC("ixgbe_write_analog_reg8_82598");
1078 : :
1079 : 0 : atlas_ctl = (reg << 8) | val;
1080 : 0 : IXGBE_WRITE_REG(hw, IXGBE_ATLASCTL, atlas_ctl);
1081 : 0 : IXGBE_WRITE_FLUSH(hw);
1082 : 0 : usec_delay(10);
1083 : :
1084 : 0 : return IXGBE_SUCCESS;
1085 : : }
1086 : :
1087 : : /**
1088 : : * ixgbe_read_i2c_phy_82598 - Reads 8 bit word over I2C interface.
1089 : : * @hw: pointer to hardware structure
1090 : : * @dev_addr: address to read from
1091 : : * @byte_offset: byte offset to read from dev_addr
1092 : : * @eeprom_data: value read
1093 : : *
1094 : : * Performs 8 byte read operation to SFP module's EEPROM over I2C interface.
1095 : : **/
1096 : 0 : STATIC s32 ixgbe_read_i2c_phy_82598(struct ixgbe_hw *hw, u8 dev_addr,
1097 : : u8 byte_offset, u8 *eeprom_data)
1098 : : {
1099 : : s32 status = IXGBE_SUCCESS;
1100 : : u16 sfp_addr = 0;
1101 : 0 : u16 sfp_data = 0;
1102 : 0 : u16 sfp_stat = 0;
1103 : : u16 gssr;
1104 : : u32 i;
1105 : :
1106 : 0 : DEBUGFUNC("ixgbe_read_i2c_phy_82598");
1107 : :
1108 [ # # ]: 0 : if (IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1)
1109 : : gssr = IXGBE_GSSR_PHY1_SM;
1110 : : else
1111 : : gssr = IXGBE_GSSR_PHY0_SM;
1112 : :
1113 [ # # ]: 0 : if (hw->mac.ops.acquire_swfw_sync(hw, gssr) != IXGBE_SUCCESS)
1114 : : return IXGBE_ERR_SWFW_SYNC;
1115 : :
1116 [ # # ]: 0 : if (hw->phy.type == ixgbe_phy_nl) {
1117 : : /*
1118 : : * NetLogic phy SDA/SCL registers are at addresses 0xC30A to
1119 : : * 0xC30D. These registers are used to talk to the SFP+
1120 : : * module's EEPROM through the SDA/SCL (I2C) interface.
1121 : : */
1122 : 0 : sfp_addr = (dev_addr << 8) + byte_offset;
1123 : 0 : sfp_addr = (sfp_addr | IXGBE_I2C_EEPROM_READ_MASK);
1124 : 0 : hw->phy.ops.write_reg_mdi(hw,
1125 : : IXGBE_MDIO_PMA_PMD_SDA_SCL_ADDR,
1126 : : IXGBE_MDIO_PMA_PMD_DEV_TYPE,
1127 : : sfp_addr);
1128 : :
1129 : : /* Poll status */
1130 [ # # ]: 0 : for (i = 0; i < 100; i++) {
1131 : 0 : hw->phy.ops.read_reg_mdi(hw,
1132 : : IXGBE_MDIO_PMA_PMD_SDA_SCL_STAT,
1133 : : IXGBE_MDIO_PMA_PMD_DEV_TYPE,
1134 : : &sfp_stat);
1135 : 0 : sfp_stat = sfp_stat & IXGBE_I2C_EEPROM_STATUS_MASK;
1136 [ # # ]: 0 : if (sfp_stat != IXGBE_I2C_EEPROM_STATUS_IN_PROGRESS)
1137 : : break;
1138 : 0 : msec_delay(10);
1139 : : }
1140 : :
1141 [ # # ]: 0 : if (sfp_stat != IXGBE_I2C_EEPROM_STATUS_PASS) {
1142 : 0 : DEBUGOUT("EEPROM read did not pass.\n");
1143 : : status = IXGBE_ERR_SFP_NOT_PRESENT;
1144 : 0 : goto out;
1145 : : }
1146 : :
1147 : : /* Read data */
1148 : 0 : hw->phy.ops.read_reg_mdi(hw, IXGBE_MDIO_PMA_PMD_SDA_SCL_DATA,
1149 : : IXGBE_MDIO_PMA_PMD_DEV_TYPE, &sfp_data);
1150 : :
1151 : 0 : *eeprom_data = (u8)(sfp_data >> 8);
1152 : : } else {
1153 : : status = IXGBE_ERR_PHY;
1154 : : }
1155 : :
1156 : 0 : out:
1157 : 0 : hw->mac.ops.release_swfw_sync(hw, gssr);
1158 : 0 : return status;
1159 : : }
1160 : :
1161 : : /**
1162 : : * ixgbe_read_i2c_eeprom_82598 - Reads 8 bit word over I2C interface.
1163 : : * @hw: pointer to hardware structure
1164 : : * @byte_offset: EEPROM byte offset to read
1165 : : * @eeprom_data: value read
1166 : : *
1167 : : * Performs 8 byte read operation to SFP module's EEPROM over I2C interface.
1168 : : **/
1169 : 0 : s32 ixgbe_read_i2c_eeprom_82598(struct ixgbe_hw *hw, u8 byte_offset,
1170 : : u8 *eeprom_data)
1171 : : {
1172 : 0 : return ixgbe_read_i2c_phy_82598(hw, IXGBE_I2C_EEPROM_DEV_ADDR,
1173 : : byte_offset, eeprom_data);
1174 : : }
1175 : :
1176 : : /**
1177 : : * ixgbe_read_i2c_sff8472_82598 - Reads 8 bit word over I2C interface.
1178 : : * @hw: pointer to hardware structure
1179 : : * @byte_offset: byte offset at address 0xA2
1180 : : * @sff8472_data: value read
1181 : : *
1182 : : * Performs 8 byte read operation to SFP module's SFF-8472 data over I2C
1183 : : **/
1184 : 0 : STATIC s32 ixgbe_read_i2c_sff8472_82598(struct ixgbe_hw *hw, u8 byte_offset,
1185 : : u8 *sff8472_data)
1186 : : {
1187 : 0 : return ixgbe_read_i2c_phy_82598(hw, IXGBE_I2C_EEPROM_DEV_ADDR2,
1188 : : byte_offset, sff8472_data);
1189 : : }
1190 : :
1191 : : /**
1192 : : * ixgbe_get_supported_physical_layer_82598 - Returns physical layer type
1193 : : * @hw: pointer to hardware structure
1194 : : *
1195 : : * Determines physical layer capabilities of the current configuration.
1196 : : **/
1197 : 0 : u64 ixgbe_get_supported_physical_layer_82598(struct ixgbe_hw *hw)
1198 : : {
1199 : : u64 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1200 : 0 : u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
1201 : 0 : u32 pma_pmd_10g = autoc & IXGBE_AUTOC_10G_PMA_PMD_MASK;
1202 : 0 : u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
1203 : 0 : u16 ext_ability = 0;
1204 : :
1205 : 0 : DEBUGFUNC("ixgbe_get_supported_physical_layer_82598");
1206 : :
1207 : 0 : hw->phy.ops.identify(hw);
1208 : :
1209 : : /* Copper PHY must be checked before AUTOC LMS to determine correct
1210 : : * physical layer because 10GBase-T PHYs use LMS = KX4/KX */
1211 [ # # ]: 0 : switch (hw->phy.type) {
1212 : 0 : case ixgbe_phy_tn:
1213 : : case ixgbe_phy_cu_unknown:
1214 : 0 : hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
1215 : : IXGBE_MDIO_PMA_PMD_DEV_TYPE, &ext_ability);
1216 [ # # ]: 0 : if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
1217 : : physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
1218 [ # # ]: 0 : if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
1219 : 0 : physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
1220 [ # # ]: 0 : if (ext_ability & IXGBE_MDIO_PHY_100BASETX_ABILITY)
1221 : 0 : physical_layer |= IXGBE_PHYSICAL_LAYER_100BASE_TX;
1222 : 0 : goto out;
1223 : : default:
1224 : : break;
1225 : : }
1226 : :
1227 [ # # # # ]: 0 : switch (autoc & IXGBE_AUTOC_LMS_MASK) {
1228 : 0 : case IXGBE_AUTOC_LMS_1G_AN:
1229 : : case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
1230 [ # # ]: 0 : if (pma_pmd_1g == IXGBE_AUTOC_1G_KX)
1231 : : physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_KX;
1232 : : else
1233 : : physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_BX;
1234 : : break;
1235 : 0 : case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
1236 [ # # ]: 0 : if (pma_pmd_10g == IXGBE_AUTOC_10G_CX4)
1237 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
1238 [ # # ]: 0 : else if (pma_pmd_10g == IXGBE_AUTOC_10G_KX4)
1239 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
1240 : : else /* XAUI */
1241 : : physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1242 : : break;
1243 : 0 : case IXGBE_AUTOC_LMS_KX4_AN:
1244 : : case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
1245 [ # # ]: 0 : if (autoc & IXGBE_AUTOC_KX_SUPP)
1246 : : physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_KX;
1247 [ # # ]: 0 : if (autoc & IXGBE_AUTOC_KX4_SUPP)
1248 : 0 : physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
1249 : : break;
1250 : : default:
1251 : : break;
1252 : : }
1253 : :
1254 [ # # ]: 0 : if (hw->phy.type == ixgbe_phy_nl) {
1255 : 0 : hw->phy.ops.identify_sfp(hw);
1256 : :
1257 [ # # ]: 0 : switch (hw->phy.sfp_type) {
1258 : : case ixgbe_sfp_type_da_cu:
1259 : : physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
1260 : : break;
1261 : : case ixgbe_sfp_type_sr:
1262 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
1263 : : break;
1264 : : case ixgbe_sfp_type_lr:
1265 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
1266 : : break;
1267 : : default:
1268 : : physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1269 : : break;
1270 : : }
1271 : : }
1272 : :
1273 [ # # # # ]: 0 : switch (hw->device_id) {
1274 : 0 : case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
1275 : : physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
1276 : 0 : break;
1277 : 0 : case IXGBE_DEV_ID_82598AF_DUAL_PORT:
1278 : : case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
1279 : : case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
1280 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
1281 : 0 : break;
1282 : 0 : case IXGBE_DEV_ID_82598EB_XF_LR:
1283 : : physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
1284 : 0 : break;
1285 : : default:
1286 : : break;
1287 : : }
1288 : :
1289 : 0 : out:
1290 : 0 : return physical_layer;
1291 : : }
1292 : :
1293 : : /**
1294 : : * ixgbe_set_lan_id_multi_port_pcie_82598 - Set LAN id for PCIe multiple
1295 : : * port devices.
1296 : : * @hw: pointer to the HW structure
1297 : : *
1298 : : * Calls common function and corrects issue with some single port devices
1299 : : * that enable LAN1 but not LAN0.
1300 : : **/
1301 : 0 : void ixgbe_set_lan_id_multi_port_pcie_82598(struct ixgbe_hw *hw)
1302 : : {
1303 : : struct ixgbe_bus_info *bus = &hw->bus;
1304 : 0 : u16 pci_gen = 0;
1305 : 0 : u16 pci_ctrl2 = 0;
1306 : :
1307 : 0 : DEBUGFUNC("ixgbe_set_lan_id_multi_port_pcie_82598");
1308 : :
1309 : 0 : ixgbe_set_lan_id_multi_port_pcie(hw);
1310 : :
1311 : : /* check if LAN0 is disabled */
1312 : 0 : hw->eeprom.ops.read(hw, IXGBE_PCIE_GENERAL_PTR, &pci_gen);
1313 [ # # ]: 0 : if ((pci_gen != 0) && (pci_gen != 0xFFFF)) {
1314 : :
1315 : 0 : hw->eeprom.ops.read(hw, pci_gen + IXGBE_PCIE_CTRL2, &pci_ctrl2);
1316 : :
1317 : : /* if LAN0 is completely disabled force function to 0 */
1318 [ # # ]: 0 : if ((pci_ctrl2 & IXGBE_PCIE_CTRL2_LAN_DISABLE) &&
1319 [ # # ]: 0 : !(pci_ctrl2 & IXGBE_PCIE_CTRL2_DISABLE_SELECT) &&
1320 : : !(pci_ctrl2 & IXGBE_PCIE_CTRL2_DUMMY_ENABLE)) {
1321 : :
1322 : 0 : bus->func = 0;
1323 : : }
1324 : : }
1325 : 0 : }
1326 : :
1327 : : /**
1328 : : * ixgbe_enable_relaxed_ordering_82598 - enable relaxed ordering
1329 : : * @hw: pointer to hardware structure
1330 : : *
1331 : : **/
1332 : 0 : void ixgbe_enable_relaxed_ordering_82598(struct ixgbe_hw *hw)
1333 : : {
1334 : : u32 regval;
1335 : : u32 i;
1336 : :
1337 : 0 : DEBUGFUNC("ixgbe_enable_relaxed_ordering_82598");
1338 : :
1339 : : /* Enable relaxed ordering */
1340 [ # # # # ]: 0 : for (i = 0; ((i < hw->mac.max_tx_queues) &&
1341 : 0 : (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
1342 : 0 : regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i));
1343 : 0 : regval |= IXGBE_DCA_TXCTRL_DESC_WRO_EN;
1344 : 0 : IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), regval);
1345 : : }
1346 : :
1347 [ # # # # ]: 0 : for (i = 0; ((i < hw->mac.max_rx_queues) &&
1348 : 0 : (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
1349 : 0 : regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
1350 : 0 : regval |= IXGBE_DCA_RXCTRL_DATA_WRO_EN |
1351 : : IXGBE_DCA_RXCTRL_HEAD_WRO_EN;
1352 : 0 : IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
1353 : : }
1354 : :
1355 : 0 : }
1356 : :
1357 : : /**
1358 : : * ixgbe_set_rxpba_82598 - Initialize RX packet buffer
1359 : : * @hw: pointer to hardware structure
1360 : : * @num_pb: number of packet buffers to allocate
1361 : : * @headroom: reserve n KB of headroom
1362 : : * @strategy: packet buffer allocation strategy
1363 : : **/
1364 : 0 : STATIC void ixgbe_set_rxpba_82598(struct ixgbe_hw *hw, int num_pb,
1365 : : u32 headroom, int strategy)
1366 : : {
1367 : : u32 rxpktsize = IXGBE_RXPBSIZE_64KB;
1368 : : u8 i = 0;
1369 : : UNREFERENCED_1PARAMETER(headroom);
1370 : :
1371 [ # # ]: 0 : if (!num_pb)
1372 : : return;
1373 : :
1374 : : /* Setup Rx packet buffer sizes */
1375 [ # # ]: 0 : switch (strategy) {
1376 : : case PBA_STRATEGY_WEIGHTED:
1377 : : /* Setup the first four at 80KB */
1378 : : rxpktsize = IXGBE_RXPBSIZE_80KB;
1379 [ # # ]: 0 : for (; i < 4; i++)
1380 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
1381 : : /* Setup the last four at 48KB...don't re-init i */
1382 : : rxpktsize = IXGBE_RXPBSIZE_48KB;
1383 : : /* Fall Through */
1384 : : case PBA_STRATEGY_EQUAL:
1385 : : default:
1386 : : /* Divide the remaining Rx packet buffer evenly among the TCs */
1387 [ # # ]: 0 : for (; i < IXGBE_MAX_PACKET_BUFFERS; i++)
1388 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
1389 : : break;
1390 : : }
1391 : :
1392 : : /* Setup Tx packet buffer sizes */
1393 [ # # ]: 0 : for (i = 0; i < IXGBE_MAX_PACKET_BUFFERS; i++)
1394 : 0 : IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), IXGBE_TXPBSIZE_40KB);
1395 : : }
1396 : :
1397 : : /**
1398 : : * ixgbe_enable_rx_dma_82598 - Enable the Rx DMA unit
1399 : : * @hw: pointer to hardware structure
1400 : : * @regval: register value to write to RXCTRL
1401 : : *
1402 : : * Enables the Rx DMA unit
1403 : : **/
1404 : 0 : s32 ixgbe_enable_rx_dma_82598(struct ixgbe_hw *hw, u32 regval)
1405 : : {
1406 : 0 : DEBUGFUNC("ixgbe_enable_rx_dma_82598");
1407 : :
1408 : 0 : IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, regval);
1409 : :
1410 : 0 : return IXGBE_SUCCESS;
1411 : : }
|
