1 /*******************************************************************************
3 Copyright (c) 2001-2015, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
32 ***************************************************************************/
34 #include "ixgbe_x550.h"
35 #include "ixgbe_x540.h"
36 #include "ixgbe_type.h"
37 #include "ixgbe_api.h"
38 #include "ixgbe_common.h"
39 #include "ixgbe_phy.h"
41 STATIC s32 ixgbe_setup_ixfi_x550em(struct ixgbe_hw *hw, ixgbe_link_speed *speed);
42 STATIC s32 ixgbe_acquire_swfw_sync_X550a(struct ixgbe_hw *, u32 mask);
43 STATIC void ixgbe_release_swfw_sync_X550a(struct ixgbe_hw *, u32 mask);
46 * ixgbe_init_ops_X550 - Inits func ptrs and MAC type
47 * @hw: pointer to hardware structure
49 * Initialize the function pointers and assign the MAC type for X550.
50 * Does not touch the hardware.
52 s32 ixgbe_init_ops_X550(struct ixgbe_hw *hw)
54 struct ixgbe_mac_info *mac = &hw->mac;
55 struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
58 DEBUGFUNC("ixgbe_init_ops_X550");
60 ret_val = ixgbe_init_ops_X540(hw);
61 mac->ops.dmac_config = ixgbe_dmac_config_X550;
62 mac->ops.dmac_config_tcs = ixgbe_dmac_config_tcs_X550;
63 mac->ops.dmac_update_tcs = ixgbe_dmac_update_tcs_X550;
64 mac->ops.setup_eee = ixgbe_setup_eee_X550;
65 mac->ops.set_source_address_pruning =
66 ixgbe_set_source_address_pruning_X550;
67 mac->ops.set_ethertype_anti_spoofing =
68 ixgbe_set_ethertype_anti_spoofing_X550;
70 mac->ops.get_rtrup2tc = ixgbe_dcb_get_rtrup2tc_generic;
71 eeprom->ops.init_params = ixgbe_init_eeprom_params_X550;
72 eeprom->ops.calc_checksum = ixgbe_calc_eeprom_checksum_X550;
73 eeprom->ops.read = ixgbe_read_ee_hostif_X550;
74 eeprom->ops.read_buffer = ixgbe_read_ee_hostif_buffer_X550;
75 eeprom->ops.write = ixgbe_write_ee_hostif_X550;
76 eeprom->ops.write_buffer = ixgbe_write_ee_hostif_buffer_X550;
77 eeprom->ops.update_checksum = ixgbe_update_eeprom_checksum_X550;
78 eeprom->ops.validate_checksum = ixgbe_validate_eeprom_checksum_X550;
80 mac->ops.disable_mdd = ixgbe_disable_mdd_X550;
81 mac->ops.enable_mdd = ixgbe_enable_mdd_X550;
82 mac->ops.mdd_event = ixgbe_mdd_event_X550;
83 mac->ops.restore_mdd_vf = ixgbe_restore_mdd_vf_X550;
84 mac->ops.disable_rx = ixgbe_disable_rx_x550;
85 switch (hw->device_id) {
86 case IXGBE_DEV_ID_X550EM_X_10G_T:
87 case IXGBE_DEV_ID_X550EM_A_10G_T:
88 hw->mac.ops.led_on = ixgbe_led_on_t_X550em;
89 hw->mac.ops.led_off = ixgbe_led_off_t_X550em;
98 * ixgbe_read_cs4227 - Read CS4227 register
99 * @hw: pointer to hardware structure
100 * @reg: register number to write
101 * @value: pointer to receive value read
103 * Returns status code
105 STATIC s32 ixgbe_read_cs4227(struct ixgbe_hw *hw, u16 reg, u16 *value)
107 return hw->link.ops.read_link_unlocked(hw, hw->link.addr, reg, value);
111 * ixgbe_write_cs4227 - Write CS4227 register
112 * @hw: pointer to hardware structure
113 * @reg: register number to write
114 * @value: value to write to register
116 * Returns status code
118 STATIC s32 ixgbe_write_cs4227(struct ixgbe_hw *hw, u16 reg, u16 value)
120 return hw->link.ops.write_link_unlocked(hw, hw->link.addr, reg, value);
124 * ixgbe_read_pe - Read register from port expander
125 * @hw: pointer to hardware structure
126 * @reg: register number to read
127 * @value: pointer to receive read value
129 * Returns status code
131 STATIC s32 ixgbe_read_pe(struct ixgbe_hw *hw, u8 reg, u8 *value)
135 status = ixgbe_read_i2c_byte_unlocked(hw, reg, IXGBE_PE, value);
136 if (status != IXGBE_SUCCESS)
137 ERROR_REPORT2(IXGBE_ERROR_CAUTION,
138 "port expander access failed with %d\n", status);
143 * ixgbe_write_pe - Write register to port expander
144 * @hw: pointer to hardware structure
145 * @reg: register number to write
146 * @value: value to write
148 * Returns status code
150 STATIC s32 ixgbe_write_pe(struct ixgbe_hw *hw, u8 reg, u8 value)
154 status = ixgbe_write_i2c_byte_unlocked(hw, reg, IXGBE_PE, value);
155 if (status != IXGBE_SUCCESS)
156 ERROR_REPORT2(IXGBE_ERROR_CAUTION,
157 "port expander access failed with %d\n", status);
162 * ixgbe_reset_cs4227 - Reset CS4227 using port expander
163 * @hw: pointer to hardware structure
165 * This function assumes that the caller has acquired the proper semaphore.
168 STATIC s32 ixgbe_reset_cs4227(struct ixgbe_hw *hw)
175 /* Trigger hard reset. */
176 status = ixgbe_read_pe(hw, IXGBE_PE_OUTPUT, ®);
177 if (status != IXGBE_SUCCESS)
179 reg |= IXGBE_PE_BIT1;
180 status = ixgbe_write_pe(hw, IXGBE_PE_OUTPUT, reg);
181 if (status != IXGBE_SUCCESS)
184 status = ixgbe_read_pe(hw, IXGBE_PE_CONFIG, ®);
185 if (status != IXGBE_SUCCESS)
187 reg &= ~IXGBE_PE_BIT1;
188 status = ixgbe_write_pe(hw, IXGBE_PE_CONFIG, reg);
189 if (status != IXGBE_SUCCESS)
192 status = ixgbe_read_pe(hw, IXGBE_PE_OUTPUT, ®);
193 if (status != IXGBE_SUCCESS)
195 reg &= ~IXGBE_PE_BIT1;
196 status = ixgbe_write_pe(hw, IXGBE_PE_OUTPUT, reg);
197 if (status != IXGBE_SUCCESS)
200 usec_delay(IXGBE_CS4227_RESET_HOLD);
202 status = ixgbe_read_pe(hw, IXGBE_PE_OUTPUT, ®);
203 if (status != IXGBE_SUCCESS)
205 reg |= IXGBE_PE_BIT1;
206 status = ixgbe_write_pe(hw, IXGBE_PE_OUTPUT, reg);
207 if (status != IXGBE_SUCCESS)
210 /* Wait for the reset to complete. */
211 msec_delay(IXGBE_CS4227_RESET_DELAY);
212 for (retry = 0; retry < IXGBE_CS4227_RETRIES; retry++) {
213 status = ixgbe_read_cs4227(hw, IXGBE_CS4227_EFUSE_STATUS,
215 if (status == IXGBE_SUCCESS &&
216 value == IXGBE_CS4227_EEPROM_LOAD_OK)
218 msec_delay(IXGBE_CS4227_CHECK_DELAY);
220 if (retry == IXGBE_CS4227_RETRIES) {
221 ERROR_REPORT1(IXGBE_ERROR_INVALID_STATE,
222 "CS4227 reset did not complete.");
223 return IXGBE_ERR_PHY;
226 status = ixgbe_read_cs4227(hw, IXGBE_CS4227_EEPROM_STATUS, &value);
227 if (status != IXGBE_SUCCESS ||
228 !(value & IXGBE_CS4227_EEPROM_LOAD_OK)) {
229 ERROR_REPORT1(IXGBE_ERROR_INVALID_STATE,
230 "CS4227 EEPROM did not load successfully.");
231 return IXGBE_ERR_PHY;
234 return IXGBE_SUCCESS;
238 * ixgbe_check_cs4227 - Check CS4227 and reset as needed
239 * @hw: pointer to hardware structure
241 STATIC void ixgbe_check_cs4227(struct ixgbe_hw *hw)
243 s32 status = IXGBE_SUCCESS;
244 u32 swfw_mask = hw->phy.phy_semaphore_mask;
248 for (retry = 0; retry < IXGBE_CS4227_RETRIES; retry++) {
249 status = hw->mac.ops.acquire_swfw_sync(hw, swfw_mask);
250 if (status != IXGBE_SUCCESS) {
251 ERROR_REPORT2(IXGBE_ERROR_CAUTION,
252 "semaphore failed with %d", status);
253 msec_delay(IXGBE_CS4227_CHECK_DELAY);
257 /* Get status of reset flow. */
258 status = ixgbe_read_cs4227(hw, IXGBE_CS4227_SCRATCH, &value);
260 if (status == IXGBE_SUCCESS &&
261 value == IXGBE_CS4227_RESET_COMPLETE)
264 if (status != IXGBE_SUCCESS ||
265 value != IXGBE_CS4227_RESET_PENDING)
268 /* Reset is pending. Wait and check again. */
269 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
270 msec_delay(IXGBE_CS4227_CHECK_DELAY);
273 /* If still pending, assume other instance failed. */
274 if (retry == IXGBE_CS4227_RETRIES) {
275 status = hw->mac.ops.acquire_swfw_sync(hw, swfw_mask);
276 if (status != IXGBE_SUCCESS) {
277 ERROR_REPORT2(IXGBE_ERROR_CAUTION,
278 "semaphore failed with %d", status);
283 /* Reset the CS4227. */
284 status = ixgbe_reset_cs4227(hw);
285 if (status != IXGBE_SUCCESS) {
286 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
287 "CS4227 reset failed: %d", status);
291 /* Reset takes so long, temporarily release semaphore in case the
292 * other driver instance is waiting for the reset indication.
294 ixgbe_write_cs4227(hw, IXGBE_CS4227_SCRATCH,
295 IXGBE_CS4227_RESET_PENDING);
296 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
298 status = hw->mac.ops.acquire_swfw_sync(hw, swfw_mask);
299 if (status != IXGBE_SUCCESS) {
300 ERROR_REPORT2(IXGBE_ERROR_CAUTION,
301 "semaphore failed with %d", status);
305 /* Record completion for next time. */
306 status = ixgbe_write_cs4227(hw, IXGBE_CS4227_SCRATCH,
307 IXGBE_CS4227_RESET_COMPLETE);
310 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
311 msec_delay(hw->eeprom.semaphore_delay);
315 * ixgbe_setup_mux_ctl - Setup ESDP register for I2C mux control
316 * @hw: pointer to hardware structure
318 STATIC void ixgbe_setup_mux_ctl(struct ixgbe_hw *hw)
320 u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
322 if (hw->bus.lan_id) {
323 esdp &= ~(IXGBE_ESDP_SDP1_NATIVE | IXGBE_ESDP_SDP1);
324 esdp |= IXGBE_ESDP_SDP1_DIR;
326 esdp &= ~(IXGBE_ESDP_SDP0_NATIVE | IXGBE_ESDP_SDP0_DIR);
327 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
328 IXGBE_WRITE_FLUSH(hw);
332 * ixgbe_read_phy_reg_mdi_22 - Read from a clause 22 PHY register without lock
333 * @hw: pointer to hardware structure
334 * @reg_addr: 32 bit address of PHY register to read
335 * @dev_type: always unused
336 * @phy_data: Pointer to read data from PHY register
338 STATIC s32 ixgbe_read_phy_reg_mdi_22(struct ixgbe_hw *hw, u32 reg_addr,
339 u32 dev_type, u16 *phy_data)
341 u32 i, data, command;
342 UNREFERENCED_1PARAMETER(dev_type);
344 /* Setup and write the read command */
345 command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
346 (hw->phy.addr << IXGBE_MSCA_PHY_ADDR_SHIFT) |
347 IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_READ_AUTOINC |
348 IXGBE_MSCA_MDI_COMMAND;
350 IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
352 /* Check every 10 usec to see if the access completed.
353 * The MDI Command bit will clear when the operation is
356 for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
359 command = IXGBE_READ_REG(hw, IXGBE_MSCA);
360 if (!(command & IXGBE_MSCA_MDI_COMMAND))
364 if (command & IXGBE_MSCA_MDI_COMMAND) {
365 ERROR_REPORT1(IXGBE_ERROR_POLLING,
366 "PHY read command did not complete.\n");
367 return IXGBE_ERR_PHY;
370 /* Read operation is complete. Get the data from MSRWD */
371 data = IXGBE_READ_REG(hw, IXGBE_MSRWD);
372 data >>= IXGBE_MSRWD_READ_DATA_SHIFT;
373 *phy_data = (u16)data;
375 return IXGBE_SUCCESS;
379 * ixgbe_write_phy_reg_mdi_22 - Write to a clause 22 PHY register without lock
380 * @hw: pointer to hardware structure
381 * @reg_addr: 32 bit PHY register to write
382 * @dev_type: always unused
383 * @phy_data: Data to write to the PHY register
385 STATIC s32 ixgbe_write_phy_reg_mdi_22(struct ixgbe_hw *hw, u32 reg_addr,
386 u32 dev_type, u16 phy_data)
389 UNREFERENCED_1PARAMETER(dev_type);
391 /* Put the data in the MDI single read and write data register*/
392 IXGBE_WRITE_REG(hw, IXGBE_MSRWD, (u32)phy_data);
394 /* Setup and write the write command */
395 command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
396 (hw->phy.addr << IXGBE_MSCA_PHY_ADDR_SHIFT) |
397 IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_WRITE |
398 IXGBE_MSCA_MDI_COMMAND;
400 IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
402 /* Check every 10 usec to see if the access completed.
403 * The MDI Command bit will clear when the operation is
406 for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
409 command = IXGBE_READ_REG(hw, IXGBE_MSCA);
410 if (!(command & IXGBE_MSCA_MDI_COMMAND))
414 if (command & IXGBE_MSCA_MDI_COMMAND) {
415 ERROR_REPORT1(IXGBE_ERROR_POLLING,
416 "PHY write cmd didn't complete\n");
417 return IXGBE_ERR_PHY;
420 return IXGBE_SUCCESS;
424 * ixgbe_identify_phy_x550em - Get PHY type based on device id
425 * @hw: pointer to hardware structure
429 STATIC s32 ixgbe_identify_phy_x550em(struct ixgbe_hw *hw)
431 switch (hw->device_id) {
432 case IXGBE_DEV_ID_X550EM_A_SFP:
433 hw->phy.ops.read_reg = ixgbe_read_phy_reg_x550a;
434 hw->phy.ops.write_reg = ixgbe_write_phy_reg_x550a;
436 hw->phy.phy_semaphore_mask |= IXGBE_GSSR_PHY1_SM;
438 hw->phy.phy_semaphore_mask |= IXGBE_GSSR_PHY0_SM;
439 return ixgbe_identify_module_generic(hw);
440 case IXGBE_DEV_ID_X550EM_X_SFP:
441 /* set up for CS4227 usage */
442 hw->phy.phy_semaphore_mask = IXGBE_GSSR_SHARED_I2C_SM;
443 ixgbe_setup_mux_ctl(hw);
444 ixgbe_check_cs4227(hw);
447 case IXGBE_DEV_ID_X550EM_A_SFP_N:
448 return ixgbe_identify_module_generic(hw);
450 case IXGBE_DEV_ID_X550EM_X_KX4:
451 hw->phy.type = ixgbe_phy_x550em_kx4;
453 case IXGBE_DEV_ID_X550EM_X_KR:
454 case IXGBE_DEV_ID_X550EM_A_KR:
455 case IXGBE_DEV_ID_X550EM_A_KR_L:
456 hw->phy.type = ixgbe_phy_x550em_kr;
458 case IXGBE_DEV_ID_X550EM_A_10G_T:
459 hw->phy.ops.read_reg = ixgbe_read_phy_reg_x550a;
460 hw->phy.ops.write_reg = ixgbe_write_phy_reg_x550a;
461 /* Fallthrough to ixgbe_identify_phy_generic */
462 case IXGBE_DEV_ID_X550EM_A_1G_T:
463 case IXGBE_DEV_ID_X550EM_A_1G_T_L:
464 case IXGBE_DEV_ID_X550EM_X_1G_T:
465 case IXGBE_DEV_ID_X550EM_X_10G_T:
466 return ixgbe_identify_phy_generic(hw);
470 return IXGBE_SUCCESS;
473 STATIC s32 ixgbe_read_phy_reg_x550em(struct ixgbe_hw *hw, u32 reg_addr,
474 u32 device_type, u16 *phy_data)
476 UNREFERENCED_4PARAMETER(*hw, reg_addr, device_type, *phy_data);
477 return IXGBE_NOT_IMPLEMENTED;
480 STATIC s32 ixgbe_write_phy_reg_x550em(struct ixgbe_hw *hw, u32 reg_addr,
481 u32 device_type, u16 phy_data)
483 UNREFERENCED_4PARAMETER(*hw, reg_addr, device_type, phy_data);
484 return IXGBE_NOT_IMPLEMENTED;
488 * ixgbe_read_i2c_combined_generic - Perform I2C read combined operation
489 * @hw: pointer to the hardware structure
490 * @addr: I2C bus address to read from
491 * @reg: I2C device register to read from
492 * @val: pointer to location to receive read value
494 * Returns an error code on error.
496 STATIC s32 ixgbe_read_i2c_combined_generic(struct ixgbe_hw *hw, u8 addr,
499 return ixgbe_read_i2c_combined_generic_int(hw, addr, reg, val, true);
503 * ixgbe_read_i2c_combined_generic_unlocked - Do I2C read combined operation
504 * @hw: pointer to the hardware structure
505 * @addr: I2C bus address to read from
506 * @reg: I2C device register to read from
507 * @val: pointer to location to receive read value
509 * Returns an error code on error.
512 ixgbe_read_i2c_combined_generic_unlocked(struct ixgbe_hw *hw, u8 addr,
515 return ixgbe_read_i2c_combined_generic_int(hw, addr, reg, val, false);
519 * ixgbe_write_i2c_combined_generic - Perform I2C write combined operation
520 * @hw: pointer to the hardware structure
521 * @addr: I2C bus address to write to
522 * @reg: I2C device register to write to
523 * @val: value to write
525 * Returns an error code on error.
527 STATIC s32 ixgbe_write_i2c_combined_generic(struct ixgbe_hw *hw,
528 u8 addr, u16 reg, u16 val)
530 return ixgbe_write_i2c_combined_generic_int(hw, addr, reg, val, true);
534 * ixgbe_write_i2c_combined_generic_unlocked - Do I2C write combined operation
535 * @hw: pointer to the hardware structure
536 * @addr: I2C bus address to write to
537 * @reg: I2C device register to write to
538 * @val: value to write
540 * Returns an error code on error.
543 ixgbe_write_i2c_combined_generic_unlocked(struct ixgbe_hw *hw,
544 u8 addr, u16 reg, u16 val)
546 return ixgbe_write_i2c_combined_generic_int(hw, addr, reg, val, false);
550 * ixgbe_init_ops_X550EM - Inits func ptrs and MAC type
551 * @hw: pointer to hardware structure
553 * Initialize the function pointers and for MAC type X550EM.
554 * Does not touch the hardware.
556 s32 ixgbe_init_ops_X550EM(struct ixgbe_hw *hw)
558 struct ixgbe_mac_info *mac = &hw->mac;
559 struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
560 struct ixgbe_phy_info *phy = &hw->phy;
563 DEBUGFUNC("ixgbe_init_ops_X550EM");
565 /* Similar to X550 so start there. */
566 ret_val = ixgbe_init_ops_X550(hw);
568 /* Since this function eventually calls
569 * ixgbe_init_ops_540 by design, we are setting
570 * the pointers to NULL explicitly here to overwrite
571 * the values being set in the x540 function.
573 /* Thermal sensor not supported in x550EM */
574 mac->ops.get_thermal_sensor_data = NULL;
575 mac->ops.init_thermal_sensor_thresh = NULL;
576 mac->thermal_sensor_enabled = false;
578 /* FCOE not supported in x550EM */
579 mac->ops.get_san_mac_addr = NULL;
580 mac->ops.set_san_mac_addr = NULL;
581 mac->ops.get_wwn_prefix = NULL;
582 mac->ops.get_fcoe_boot_status = NULL;
584 /* IPsec not supported in x550EM */
585 mac->ops.disable_sec_rx_path = NULL;
586 mac->ops.enable_sec_rx_path = NULL;
588 /* AUTOC register is not present in x550EM. */
589 mac->ops.prot_autoc_read = NULL;
590 mac->ops.prot_autoc_write = NULL;
592 /* X550EM bus type is internal*/
593 hw->bus.type = ixgbe_bus_type_internal;
594 mac->ops.get_bus_info = ixgbe_get_bus_info_X550em;
597 mac->ops.get_media_type = ixgbe_get_media_type_X550em;
598 mac->ops.setup_sfp = ixgbe_setup_sfp_modules_X550em;
599 mac->ops.get_link_capabilities = ixgbe_get_link_capabilities_X550em;
600 mac->ops.reset_hw = ixgbe_reset_hw_X550em;
601 mac->ops.get_supported_physical_layer =
602 ixgbe_get_supported_physical_layer_X550em;
604 if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper)
605 mac->ops.setup_fc = ixgbe_setup_fc_generic;
607 mac->ops.setup_fc = ixgbe_setup_fc_X550em;
609 switch (hw->device_id) {
610 case IXGBE_DEV_ID_X550EM_X_KR:
611 case IXGBE_DEV_ID_X550EM_A_KR:
612 case IXGBE_DEV_ID_X550EM_A_KR_L:
615 mac->ops.setup_eee = NULL;
619 phy->ops.init = ixgbe_init_phy_ops_X550em;
620 phy->ops.identify = ixgbe_identify_phy_x550em;
621 if (mac->ops.get_media_type(hw) != ixgbe_media_type_copper)
622 phy->ops.set_phy_power = NULL;
626 eeprom->ops.init_params = ixgbe_init_eeprom_params_X540;
627 eeprom->ops.read = ixgbe_read_ee_hostif_X550;
628 eeprom->ops.read_buffer = ixgbe_read_ee_hostif_buffer_X550;
629 eeprom->ops.write = ixgbe_write_ee_hostif_X550;
630 eeprom->ops.write_buffer = ixgbe_write_ee_hostif_buffer_X550;
631 eeprom->ops.update_checksum = ixgbe_update_eeprom_checksum_X550;
632 eeprom->ops.validate_checksum = ixgbe_validate_eeprom_checksum_X550;
633 eeprom->ops.calc_checksum = ixgbe_calc_eeprom_checksum_X550;
639 * ixgbe_init_ops_X550EM_a - Inits func ptrs and MAC type
640 * @hw: pointer to hardware structure
642 * Initialize the function pointers and for MAC type X550EM_a.
643 * Does not touch the hardware.
645 s32 ixgbe_init_ops_X550EM_a(struct ixgbe_hw *hw)
647 struct ixgbe_mac_info *mac = &hw->mac;
650 DEBUGFUNC("ixgbe_init_ops_X550EM_a");
652 /* Start with generic X550EM init */
653 ret_val = ixgbe_init_ops_X550EM(hw);
655 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII ||
656 hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII_L) {
657 mac->ops.read_iosf_sb_reg = ixgbe_read_iosf_sb_reg_x550;
658 mac->ops.write_iosf_sb_reg = ixgbe_write_iosf_sb_reg_x550;
660 mac->ops.read_iosf_sb_reg = ixgbe_read_iosf_sb_reg_x550a;
661 mac->ops.write_iosf_sb_reg = ixgbe_write_iosf_sb_reg_x550a;
663 mac->ops.acquire_swfw_sync = ixgbe_acquire_swfw_sync_X550a;
664 mac->ops.release_swfw_sync = ixgbe_release_swfw_sync_X550a;
666 switch (mac->ops.get_media_type(hw)) {
667 case ixgbe_media_type_fiber:
668 mac->ops.setup_fc = ixgbe_setup_fc_fiber_x550em_a;
669 mac->ops.fc_autoneg = ixgbe_fc_autoneg_fiber_x550em_a;
671 case ixgbe_media_type_backplane:
672 mac->ops.fc_autoneg = ixgbe_fc_autoneg_backplane_x550em_a;
673 mac->ops.setup_fc = ixgbe_setup_fc_backplane_x550em_a;
683 * ixgbe_init_ops_X550EM_x - Inits func ptrs and MAC type
684 * @hw: pointer to hardware structure
686 * Initialize the function pointers and for MAC type X550EM_x.
687 * Does not touch the hardware.
689 s32 ixgbe_init_ops_X550EM_x(struct ixgbe_hw *hw)
691 struct ixgbe_mac_info *mac = &hw->mac;
692 struct ixgbe_link_info *link = &hw->link;
695 DEBUGFUNC("ixgbe_init_ops_X550EM_x");
697 /* Start with generic X550EM init */
698 ret_val = ixgbe_init_ops_X550EM(hw);
700 mac->ops.read_iosf_sb_reg = ixgbe_read_iosf_sb_reg_x550;
701 mac->ops.write_iosf_sb_reg = ixgbe_write_iosf_sb_reg_x550;
702 mac->ops.acquire_swfw_sync = ixgbe_acquire_swfw_sync_X550em;
703 mac->ops.release_swfw_sync = ixgbe_release_swfw_sync_X550em;
704 link->ops.read_link = ixgbe_read_i2c_combined_generic;
705 link->ops.read_link_unlocked = ixgbe_read_i2c_combined_generic_unlocked;
706 link->ops.write_link = ixgbe_write_i2c_combined_generic;
707 link->ops.write_link_unlocked =
708 ixgbe_write_i2c_combined_generic_unlocked;
709 link->addr = IXGBE_CS4227;
715 * ixgbe_dmac_config_X550
716 * @hw: pointer to hardware structure
718 * Configure DMA coalescing. If enabling dmac, dmac is activated.
719 * When disabling dmac, dmac enable dmac bit is cleared.
721 s32 ixgbe_dmac_config_X550(struct ixgbe_hw *hw)
723 u32 reg, high_pri_tc;
725 DEBUGFUNC("ixgbe_dmac_config_X550");
727 /* Disable DMA coalescing before configuring */
728 reg = IXGBE_READ_REG(hw, IXGBE_DMACR);
729 reg &= ~IXGBE_DMACR_DMAC_EN;
730 IXGBE_WRITE_REG(hw, IXGBE_DMACR, reg);
732 /* Disable DMA Coalescing if the watchdog timer is 0 */
733 if (!hw->mac.dmac_config.watchdog_timer)
736 ixgbe_dmac_config_tcs_X550(hw);
738 /* Configure DMA Coalescing Control Register */
739 reg = IXGBE_READ_REG(hw, IXGBE_DMACR);
741 /* Set the watchdog timer in units of 40.96 usec */
742 reg &= ~IXGBE_DMACR_DMACWT_MASK;
743 reg |= (hw->mac.dmac_config.watchdog_timer * 100) / 4096;
745 reg &= ~IXGBE_DMACR_HIGH_PRI_TC_MASK;
746 /* If fcoe is enabled, set high priority traffic class */
747 if (hw->mac.dmac_config.fcoe_en) {
748 high_pri_tc = 1 << hw->mac.dmac_config.fcoe_tc;
749 reg |= ((high_pri_tc << IXGBE_DMACR_HIGH_PRI_TC_SHIFT) &
750 IXGBE_DMACR_HIGH_PRI_TC_MASK);
752 reg |= IXGBE_DMACR_EN_MNG_IND;
754 /* Enable DMA coalescing after configuration */
755 reg |= IXGBE_DMACR_DMAC_EN;
756 IXGBE_WRITE_REG(hw, IXGBE_DMACR, reg);
759 return IXGBE_SUCCESS;
763 * ixgbe_dmac_config_tcs_X550
764 * @hw: pointer to hardware structure
766 * Configure DMA coalescing threshold per TC. The dmac enable bit must
767 * be cleared before configuring.
769 s32 ixgbe_dmac_config_tcs_X550(struct ixgbe_hw *hw)
771 u32 tc, reg, pb_headroom, rx_pb_size, maxframe_size_kb;
773 DEBUGFUNC("ixgbe_dmac_config_tcs_X550");
775 /* Configure DMA coalescing enabled */
776 switch (hw->mac.dmac_config.link_speed) {
777 case IXGBE_LINK_SPEED_10_FULL:
778 case IXGBE_LINK_SPEED_100_FULL:
779 pb_headroom = IXGBE_DMACRXT_100M;
781 case IXGBE_LINK_SPEED_1GB_FULL:
782 pb_headroom = IXGBE_DMACRXT_1G;
785 pb_headroom = IXGBE_DMACRXT_10G;
789 maxframe_size_kb = ((IXGBE_READ_REG(hw, IXGBE_MAXFRS) >>
790 IXGBE_MHADD_MFS_SHIFT) / 1024);
792 /* Set the per Rx packet buffer receive threshold */
793 for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++) {
794 reg = IXGBE_READ_REG(hw, IXGBE_DMCTH(tc));
795 reg &= ~IXGBE_DMCTH_DMACRXT_MASK;
797 if (tc < hw->mac.dmac_config.num_tcs) {
799 rx_pb_size = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(tc));
800 rx_pb_size = (rx_pb_size & IXGBE_RXPBSIZE_MASK) >>
801 IXGBE_RXPBSIZE_SHIFT;
803 /* Calculate receive buffer threshold in kilobytes */
804 if (rx_pb_size > pb_headroom)
805 rx_pb_size = rx_pb_size - pb_headroom;
809 /* Minimum of MFS shall be set for DMCTH */
810 reg |= (rx_pb_size > maxframe_size_kb) ?
811 rx_pb_size : maxframe_size_kb;
813 IXGBE_WRITE_REG(hw, IXGBE_DMCTH(tc), reg);
815 return IXGBE_SUCCESS;
819 * ixgbe_dmac_update_tcs_X550
820 * @hw: pointer to hardware structure
822 * Disables dmac, updates per TC settings, and then enables dmac.
824 s32 ixgbe_dmac_update_tcs_X550(struct ixgbe_hw *hw)
828 DEBUGFUNC("ixgbe_dmac_update_tcs_X550");
830 /* Disable DMA coalescing before configuring */
831 reg = IXGBE_READ_REG(hw, IXGBE_DMACR);
832 reg &= ~IXGBE_DMACR_DMAC_EN;
833 IXGBE_WRITE_REG(hw, IXGBE_DMACR, reg);
835 ixgbe_dmac_config_tcs_X550(hw);
837 /* Enable DMA coalescing after configuration */
838 reg = IXGBE_READ_REG(hw, IXGBE_DMACR);
839 reg |= IXGBE_DMACR_DMAC_EN;
840 IXGBE_WRITE_REG(hw, IXGBE_DMACR, reg);
842 return IXGBE_SUCCESS;
846 * ixgbe_init_eeprom_params_X550 - Initialize EEPROM params
847 * @hw: pointer to hardware structure
849 * Initializes the EEPROM parameters ixgbe_eeprom_info within the
850 * ixgbe_hw struct in order to set up EEPROM access.
852 s32 ixgbe_init_eeprom_params_X550(struct ixgbe_hw *hw)
854 struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
858 DEBUGFUNC("ixgbe_init_eeprom_params_X550");
860 if (eeprom->type == ixgbe_eeprom_uninitialized) {
861 eeprom->semaphore_delay = 10;
862 eeprom->type = ixgbe_flash;
864 eec = IXGBE_READ_REG(hw, IXGBE_EEC);
865 eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >>
866 IXGBE_EEC_SIZE_SHIFT);
867 eeprom->word_size = 1 << (eeprom_size +
868 IXGBE_EEPROM_WORD_SIZE_SHIFT);
870 DEBUGOUT2("Eeprom params: type = %d, size = %d\n",
871 eeprom->type, eeprom->word_size);
874 return IXGBE_SUCCESS;
878 * ixgbe_enable_eee_x550 - Enable EEE support
879 * @hw: pointer to hardware structure
881 STATIC s32 ixgbe_enable_eee_x550(struct ixgbe_hw *hw)
887 if (hw->mac.type == ixgbe_mac_X550) {
888 /* Advertise EEE capability */
889 hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_EEE_ADVT,
890 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
893 autoneg_eee_reg |= (IXGBE_AUTO_NEG_10GBASE_EEE_ADVT |
894 IXGBE_AUTO_NEG_1000BASE_EEE_ADVT |
895 IXGBE_AUTO_NEG_100BASE_EEE_ADVT);
897 hw->phy.ops.write_reg(hw, IXGBE_MDIO_AUTO_NEG_EEE_ADVT,
898 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
900 return IXGBE_SUCCESS;
903 switch (hw->device_id) {
904 case IXGBE_DEV_ID_X550EM_X_KR:
905 case IXGBE_DEV_ID_X550EM_A_KR:
906 case IXGBE_DEV_ID_X550EM_A_KR_L:
907 status = hw->mac.ops.read_iosf_sb_reg(hw,
908 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
909 IXGBE_SB_IOSF_TARGET_KR_PHY, &link_reg);
910 if (status != IXGBE_SUCCESS)
913 link_reg |= IXGBE_KRM_LINK_CTRL_1_TETH_EEE_CAP_KR |
914 IXGBE_KRM_LINK_CTRL_1_TETH_EEE_CAP_KX;
916 /* Don't advertise FEC capability when EEE enabled. */
917 link_reg &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_FEC;
919 status = hw->mac.ops.write_iosf_sb_reg(hw,
920 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
921 IXGBE_SB_IOSF_TARGET_KR_PHY, link_reg);
922 if (status != IXGBE_SUCCESS)
929 return IXGBE_SUCCESS;
933 * ixgbe_disable_eee_x550 - Disable EEE support
934 * @hw: pointer to hardware structure
936 STATIC s32 ixgbe_disable_eee_x550(struct ixgbe_hw *hw)
942 if (hw->mac.type == ixgbe_mac_X550) {
943 /* Disable advertised EEE capability */
944 hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_EEE_ADVT,
945 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
948 autoneg_eee_reg &= ~(IXGBE_AUTO_NEG_10GBASE_EEE_ADVT |
949 IXGBE_AUTO_NEG_1000BASE_EEE_ADVT |
950 IXGBE_AUTO_NEG_100BASE_EEE_ADVT);
952 hw->phy.ops.write_reg(hw, IXGBE_MDIO_AUTO_NEG_EEE_ADVT,
953 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
955 return IXGBE_SUCCESS;
958 switch (hw->device_id) {
959 case IXGBE_DEV_ID_X550EM_X_KR:
960 case IXGBE_DEV_ID_X550EM_A_KR:
961 case IXGBE_DEV_ID_X550EM_A_KR_L:
962 status = hw->mac.ops.read_iosf_sb_reg(hw,
963 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
964 IXGBE_SB_IOSF_TARGET_KR_PHY, &link_reg);
965 if (status != IXGBE_SUCCESS)
968 link_reg &= ~(IXGBE_KRM_LINK_CTRL_1_TETH_EEE_CAP_KR |
969 IXGBE_KRM_LINK_CTRL_1_TETH_EEE_CAP_KX);
971 /* Advertise FEC capability when EEE is disabled. */
972 link_reg |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_FEC;
974 status = hw->mac.ops.write_iosf_sb_reg(hw,
975 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
976 IXGBE_SB_IOSF_TARGET_KR_PHY, link_reg);
977 if (status != IXGBE_SUCCESS)
984 return IXGBE_SUCCESS;
988 * ixgbe_setup_eee_X550 - Enable/disable EEE support
989 * @hw: pointer to the HW structure
990 * @enable_eee: boolean flag to enable EEE
992 * Enable/disable EEE based on enable_eee flag.
993 * Auto-negotiation must be started after BASE-T EEE bits in PHY register 7.3C
997 s32 ixgbe_setup_eee_X550(struct ixgbe_hw *hw, bool enable_eee)
1002 DEBUGFUNC("ixgbe_setup_eee_X550");
1004 eeer = IXGBE_READ_REG(hw, IXGBE_EEER);
1005 /* Enable or disable EEE per flag */
1007 eeer |= (IXGBE_EEER_TX_LPI_EN | IXGBE_EEER_RX_LPI_EN);
1009 /* Not supported on first revision of X550EM_x. */
1010 if ((hw->mac.type == ixgbe_mac_X550EM_x) &&
1011 !(IXGBE_FUSES0_REV_MASK &
1012 IXGBE_READ_REG(hw, IXGBE_FUSES0_GROUP(0))))
1013 return IXGBE_SUCCESS;
1014 status = ixgbe_enable_eee_x550(hw);
1018 eeer &= ~(IXGBE_EEER_TX_LPI_EN | IXGBE_EEER_RX_LPI_EN);
1020 status = ixgbe_disable_eee_x550(hw);
1024 IXGBE_WRITE_REG(hw, IXGBE_EEER, eeer);
1026 return IXGBE_SUCCESS;
1030 * ixgbe_set_source_address_pruning_X550 - Enable/Disbale source address pruning
1031 * @hw: pointer to hardware structure
1032 * @enable: enable or disable source address pruning
1033 * @pool: Rx pool to set source address pruning for
1035 void ixgbe_set_source_address_pruning_X550(struct ixgbe_hw *hw, bool enable,
1040 /* max rx pool is 63 */
1044 pfflp = (u64)IXGBE_READ_REG(hw, IXGBE_PFFLPL);
1045 pfflp |= (u64)IXGBE_READ_REG(hw, IXGBE_PFFLPH) << 32;
1048 pfflp |= (1ULL << pool);
1050 pfflp &= ~(1ULL << pool);
1052 IXGBE_WRITE_REG(hw, IXGBE_PFFLPL, (u32)pfflp);
1053 IXGBE_WRITE_REG(hw, IXGBE_PFFLPH, (u32)(pfflp >> 32));
1057 * ixgbe_set_ethertype_anti_spoofing_X550 - Enable/Disable Ethertype anti-spoofing
1058 * @hw: pointer to hardware structure
1059 * @enable: enable or disable switch for Ethertype anti-spoofing
1060 * @vf: Virtual Function pool - VF Pool to set for Ethertype anti-spoofing
1063 void ixgbe_set_ethertype_anti_spoofing_X550(struct ixgbe_hw *hw,
1064 bool enable, int vf)
1066 int vf_target_reg = vf >> 3;
1067 int vf_target_shift = vf % 8 + IXGBE_SPOOF_ETHERTYPEAS_SHIFT;
1070 DEBUGFUNC("ixgbe_set_ethertype_anti_spoofing_X550");
1072 pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
1074 pfvfspoof |= (1 << vf_target_shift);
1076 pfvfspoof &= ~(1 << vf_target_shift);
1078 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof);
1082 * ixgbe_iosf_wait - Wait for IOSF command completion
1083 * @hw: pointer to hardware structure
1084 * @ctrl: pointer to location to receive final IOSF control value
1086 * Returns failing status on timeout
1088 * Note: ctrl can be NULL if the IOSF control register value is not needed
1090 STATIC s32 ixgbe_iosf_wait(struct ixgbe_hw *hw, u32 *ctrl)
1094 /* Check every 10 usec to see if the address cycle completed.
1095 * The SB IOSF BUSY bit will clear when the operation is
1098 for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
1099 command = IXGBE_READ_REG(hw, IXGBE_SB_IOSF_INDIRECT_CTRL);
1100 if ((command & IXGBE_SB_IOSF_CTRL_BUSY) == 0)
1106 if (i == IXGBE_MDIO_COMMAND_TIMEOUT) {
1107 ERROR_REPORT1(IXGBE_ERROR_POLLING, "Wait timed out\n");
1108 return IXGBE_ERR_PHY;
1111 return IXGBE_SUCCESS;
1115 * ixgbe_write_iosf_sb_reg_x550 - Writes a value to specified register
1116 * of the IOSF device
1117 * @hw: pointer to hardware structure
1118 * @reg_addr: 32 bit PHY register to write
1119 * @device_type: 3 bit device type
1120 * @data: Data to write to the register
1122 s32 ixgbe_write_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
1123 u32 device_type, u32 data)
1125 u32 gssr = IXGBE_GSSR_PHY1_SM | IXGBE_GSSR_PHY0_SM;
1129 ret = ixgbe_acquire_swfw_semaphore(hw, gssr);
1130 if (ret != IXGBE_SUCCESS)
1133 ret = ixgbe_iosf_wait(hw, NULL);
1134 if (ret != IXGBE_SUCCESS)
1137 command = ((reg_addr << IXGBE_SB_IOSF_CTRL_ADDR_SHIFT) |
1138 (device_type << IXGBE_SB_IOSF_CTRL_TARGET_SELECT_SHIFT));
1140 /* Write IOSF control register */
1141 IXGBE_WRITE_REG(hw, IXGBE_SB_IOSF_INDIRECT_CTRL, command);
1143 /* Write IOSF data register */
1144 IXGBE_WRITE_REG(hw, IXGBE_SB_IOSF_INDIRECT_DATA, data);
1146 ret = ixgbe_iosf_wait(hw, &command);
1148 if ((command & IXGBE_SB_IOSF_CTRL_RESP_STAT_MASK) != 0) {
1149 error = (command & IXGBE_SB_IOSF_CTRL_CMPL_ERR_MASK) >>
1150 IXGBE_SB_IOSF_CTRL_CMPL_ERR_SHIFT;
1151 ERROR_REPORT2(IXGBE_ERROR_POLLING,
1152 "Failed to write, error %x\n", error);
1153 ret = IXGBE_ERR_PHY;
1157 ixgbe_release_swfw_semaphore(hw, gssr);
1162 * ixgbe_read_iosf_sb_reg_x550 - Reads specified register of the IOSF device
1163 * @hw: pointer to hardware structure
1164 * @reg_addr: 32 bit PHY register to write
1165 * @device_type: 3 bit device type
1166 * @data: Pointer to read data from the register
1168 s32 ixgbe_read_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
1169 u32 device_type, u32 *data)
1171 u32 gssr = IXGBE_GSSR_PHY1_SM | IXGBE_GSSR_PHY0_SM;
1175 ret = ixgbe_acquire_swfw_semaphore(hw, gssr);
1176 if (ret != IXGBE_SUCCESS)
1179 ret = ixgbe_iosf_wait(hw, NULL);
1180 if (ret != IXGBE_SUCCESS)
1183 command = ((reg_addr << IXGBE_SB_IOSF_CTRL_ADDR_SHIFT) |
1184 (device_type << IXGBE_SB_IOSF_CTRL_TARGET_SELECT_SHIFT));
1186 /* Write IOSF control register */
1187 IXGBE_WRITE_REG(hw, IXGBE_SB_IOSF_INDIRECT_CTRL, command);
1189 ret = ixgbe_iosf_wait(hw, &command);
1191 if ((command & IXGBE_SB_IOSF_CTRL_RESP_STAT_MASK) != 0) {
1192 error = (command & IXGBE_SB_IOSF_CTRL_CMPL_ERR_MASK) >>
1193 IXGBE_SB_IOSF_CTRL_CMPL_ERR_SHIFT;
1194 ERROR_REPORT2(IXGBE_ERROR_POLLING,
1195 "Failed to read, error %x\n", error);
1196 ret = IXGBE_ERR_PHY;
1199 if (ret == IXGBE_SUCCESS)
1200 *data = IXGBE_READ_REG(hw, IXGBE_SB_IOSF_INDIRECT_DATA);
1203 ixgbe_release_swfw_semaphore(hw, gssr);
1208 * ixgbe_get_phy_token - Get the token for shared phy access
1209 * @hw: Pointer to hardware structure
1212 s32 ixgbe_get_phy_token(struct ixgbe_hw *hw)
1214 struct ixgbe_hic_phy_token_req token_cmd;
1217 token_cmd.hdr.cmd = FW_PHY_TOKEN_REQ_CMD;
1218 token_cmd.hdr.buf_len = FW_PHY_TOKEN_REQ_LEN;
1219 token_cmd.hdr.cmd_or_resp.cmd_resv = 0;
1220 token_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
1221 token_cmd.port_number = hw->bus.lan_id;
1222 token_cmd.command_type = FW_PHY_TOKEN_REQ;
1224 status = ixgbe_host_interface_command(hw, (u32 *)&token_cmd,
1226 IXGBE_HI_COMMAND_TIMEOUT,
1230 if (token_cmd.hdr.cmd_or_resp.ret_status == FW_PHY_TOKEN_OK)
1231 return IXGBE_SUCCESS;
1232 if (token_cmd.hdr.cmd_or_resp.ret_status != FW_PHY_TOKEN_RETRY)
1233 return IXGBE_ERR_FW_RESP_INVALID;
1235 return IXGBE_ERR_TOKEN_RETRY;
1239 * ixgbe_put_phy_token - Put the token for shared phy access
1240 * @hw: Pointer to hardware structure
1243 s32 ixgbe_put_phy_token(struct ixgbe_hw *hw)
1245 struct ixgbe_hic_phy_token_req token_cmd;
1248 token_cmd.hdr.cmd = FW_PHY_TOKEN_REQ_CMD;
1249 token_cmd.hdr.buf_len = FW_PHY_TOKEN_REQ_LEN;
1250 token_cmd.hdr.cmd_or_resp.cmd_resv = 0;
1251 token_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
1252 token_cmd.port_number = hw->bus.lan_id;
1253 token_cmd.command_type = FW_PHY_TOKEN_REL;
1255 status = ixgbe_host_interface_command(hw, (u32 *)&token_cmd,
1257 IXGBE_HI_COMMAND_TIMEOUT,
1261 if (token_cmd.hdr.cmd_or_resp.ret_status == FW_PHY_TOKEN_OK)
1262 return IXGBE_SUCCESS;
1264 DEBUGOUT("Put PHY Token host interface command failed");
1265 return IXGBE_ERR_FW_RESP_INVALID;
1269 * ixgbe_write_iosf_sb_reg_x550a - Writes a value to specified register
1270 * of the IOSF device
1271 * @hw: pointer to hardware structure
1272 * @reg_addr: 32 bit PHY register to write
1273 * @device_type: 3 bit device type
1274 * @data: Data to write to the register
1276 s32 ixgbe_write_iosf_sb_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
1277 u32 device_type, u32 data)
1279 struct ixgbe_hic_internal_phy_req write_cmd;
1281 UNREFERENCED_1PARAMETER(device_type);
1283 memset(&write_cmd, 0, sizeof(write_cmd));
1284 write_cmd.hdr.cmd = FW_INT_PHY_REQ_CMD;
1285 write_cmd.hdr.buf_len = FW_INT_PHY_REQ_LEN;
1286 write_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
1287 write_cmd.port_number = hw->bus.lan_id;
1288 write_cmd.command_type = FW_INT_PHY_REQ_WRITE;
1289 write_cmd.address = IXGBE_CPU_TO_BE16(reg_addr);
1290 write_cmd.write_data = IXGBE_CPU_TO_BE32(data);
1292 status = ixgbe_host_interface_command(hw, (u32 *)&write_cmd,
1294 IXGBE_HI_COMMAND_TIMEOUT, false);
1300 * ixgbe_read_iosf_sb_reg_x550a - Reads specified register of the IOSF device
1301 * @hw: pointer to hardware structure
1302 * @reg_addr: 32 bit PHY register to write
1303 * @device_type: 3 bit device type
1304 * @data: Pointer to read data from the register
1306 s32 ixgbe_read_iosf_sb_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
1307 u32 device_type, u32 *data)
1310 struct ixgbe_hic_internal_phy_req cmd;
1311 struct ixgbe_hic_internal_phy_resp rsp;
1314 UNREFERENCED_1PARAMETER(device_type);
1316 memset(&hic, 0, sizeof(hic));
1317 hic.cmd.hdr.cmd = FW_INT_PHY_REQ_CMD;
1318 hic.cmd.hdr.buf_len = FW_INT_PHY_REQ_LEN;
1319 hic.cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
1320 hic.cmd.port_number = hw->bus.lan_id;
1321 hic.cmd.command_type = FW_INT_PHY_REQ_READ;
1322 hic.cmd.address = IXGBE_CPU_TO_BE16(reg_addr);
1324 status = ixgbe_host_interface_command(hw, (u32 *)&hic.cmd,
1326 IXGBE_HI_COMMAND_TIMEOUT, true);
1328 /* Extract the register value from the response. */
1329 *data = IXGBE_BE32_TO_CPU(hic.rsp.read_data);
1335 * ixgbe_disable_mdd_X550
1336 * @hw: pointer to hardware structure
1338 * Disable malicious driver detection
1340 void ixgbe_disable_mdd_X550(struct ixgbe_hw *hw)
1344 DEBUGFUNC("ixgbe_disable_mdd_X550");
1346 /* Disable MDD for TX DMA and interrupt */
1347 reg = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
1348 reg &= ~(IXGBE_DMATXCTL_MDP_EN | IXGBE_DMATXCTL_MBINTEN);
1349 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, reg);
1351 /* Disable MDD for RX and interrupt */
1352 reg = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
1353 reg &= ~(IXGBE_RDRXCTL_MDP_EN | IXGBE_RDRXCTL_MBINTEN);
1354 IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, reg);
1358 * ixgbe_enable_mdd_X550
1359 * @hw: pointer to hardware structure
1361 * Enable malicious driver detection
1363 void ixgbe_enable_mdd_X550(struct ixgbe_hw *hw)
1367 DEBUGFUNC("ixgbe_enable_mdd_X550");
1369 /* Enable MDD for TX DMA and interrupt */
1370 reg = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
1371 reg |= (IXGBE_DMATXCTL_MDP_EN | IXGBE_DMATXCTL_MBINTEN);
1372 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, reg);
1374 /* Enable MDD for RX and interrupt */
1375 reg = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
1376 reg |= (IXGBE_RDRXCTL_MDP_EN | IXGBE_RDRXCTL_MBINTEN);
1377 IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, reg);
1381 * ixgbe_restore_mdd_vf_X550
1382 * @hw: pointer to hardware structure
1385 * Restore VF that was disabled during malicious driver detection event
1387 void ixgbe_restore_mdd_vf_X550(struct ixgbe_hw *hw, u32 vf)
1389 u32 idx, reg, num_qs, start_q, bitmask;
1391 DEBUGFUNC("ixgbe_restore_mdd_vf_X550");
1393 /* Map VF to queues */
1394 reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
1395 switch (reg & IXGBE_MRQC_MRQE_MASK) {
1396 case IXGBE_MRQC_VMDQRT8TCEN:
1397 num_qs = 8; /* 16 VFs / pools */
1398 bitmask = 0x000000FF;
1400 case IXGBE_MRQC_VMDQRSS32EN:
1401 case IXGBE_MRQC_VMDQRT4TCEN:
1402 num_qs = 4; /* 32 VFs / pools */
1403 bitmask = 0x0000000F;
1405 default: /* 64 VFs / pools */
1407 bitmask = 0x00000003;
1410 start_q = vf * num_qs;
1412 /* Release vf's queues by clearing WQBR_TX and WQBR_RX (RW1C) */
1415 reg |= (bitmask << (start_q % 32));
1416 IXGBE_WRITE_REG(hw, IXGBE_WQBR_TX(idx), reg);
1417 IXGBE_WRITE_REG(hw, IXGBE_WQBR_RX(idx), reg);
1421 * ixgbe_mdd_event_X550
1422 * @hw: pointer to hardware structure
1423 * @vf_bitmap: vf bitmap of malicious vfs
1425 * Handle malicious driver detection event.
1427 void ixgbe_mdd_event_X550(struct ixgbe_hw *hw, u32 *vf_bitmap)
1430 u32 i, j, reg, q, shift, vf, idx;
1432 DEBUGFUNC("ixgbe_mdd_event_X550");
1434 /* figure out pool size for mapping to vf's */
1435 reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
1436 switch (reg & IXGBE_MRQC_MRQE_MASK) {
1437 case IXGBE_MRQC_VMDQRT8TCEN:
1438 shift = 3; /* 16 VFs / pools */
1440 case IXGBE_MRQC_VMDQRSS32EN:
1441 case IXGBE_MRQC_VMDQRT4TCEN:
1442 shift = 2; /* 32 VFs / pools */
1445 shift = 1; /* 64 VFs / pools */
1449 /* Read WQBR_TX and WQBR_RX and check for malicious queues */
1450 for (i = 0; i < 4; i++) {
1451 wqbr = IXGBE_READ_REG(hw, IXGBE_WQBR_TX(i));
1452 wqbr |= IXGBE_READ_REG(hw, IXGBE_WQBR_RX(i));
1457 /* Get malicious queue */
1458 for (j = 0; j < 32 && wqbr; j++) {
1460 if (!(wqbr & (1 << j)))
1463 /* Get queue from bitmask */
1466 /* Map queue to vf */
1469 /* Set vf bit in vf_bitmap */
1471 vf_bitmap[idx] |= (1 << (vf % 32));
1478 * ixgbe_get_media_type_X550em - Get media type
1479 * @hw: pointer to hardware structure
1481 * Returns the media type (fiber, copper, backplane)
1483 enum ixgbe_media_type ixgbe_get_media_type_X550em(struct ixgbe_hw *hw)
1485 enum ixgbe_media_type media_type;
1487 DEBUGFUNC("ixgbe_get_media_type_X550em");
1489 /* Detect if there is a copper PHY attached. */
1490 switch (hw->device_id) {
1491 case IXGBE_DEV_ID_X550EM_X_KR:
1492 case IXGBE_DEV_ID_X550EM_X_KX4:
1493 case IXGBE_DEV_ID_X550EM_A_KR:
1494 case IXGBE_DEV_ID_X550EM_A_KR_L:
1495 media_type = ixgbe_media_type_backplane;
1497 case IXGBE_DEV_ID_X550EM_X_SFP:
1498 case IXGBE_DEV_ID_X550EM_A_SFP:
1499 case IXGBE_DEV_ID_X550EM_A_SFP_N:
1500 case IXGBE_DEV_ID_X550EM_A_QSFP:
1501 case IXGBE_DEV_ID_X550EM_A_QSFP_N:
1502 media_type = ixgbe_media_type_fiber;
1504 case IXGBE_DEV_ID_X550EM_X_1G_T:
1505 case IXGBE_DEV_ID_X550EM_X_10G_T:
1506 case IXGBE_DEV_ID_X550EM_A_10G_T:
1507 media_type = ixgbe_media_type_copper;
1509 case IXGBE_DEV_ID_X550EM_A_SGMII:
1510 case IXGBE_DEV_ID_X550EM_A_SGMII_L:
1511 media_type = ixgbe_media_type_backplane;
1512 hw->phy.type = ixgbe_phy_sgmii;
1514 case IXGBE_DEV_ID_X550EM_A_1G_T:
1515 case IXGBE_DEV_ID_X550EM_A_1G_T_L:
1516 media_type = ixgbe_media_type_copper;
1519 media_type = ixgbe_media_type_unknown;
1526 * ixgbe_supported_sfp_modules_X550em - Check if SFP module type is supported
1527 * @hw: pointer to hardware structure
1528 * @linear: true if SFP module is linear
1530 STATIC s32 ixgbe_supported_sfp_modules_X550em(struct ixgbe_hw *hw, bool *linear)
1532 DEBUGFUNC("ixgbe_supported_sfp_modules_X550em");
1534 switch (hw->phy.sfp_type) {
1535 case ixgbe_sfp_type_not_present:
1536 return IXGBE_ERR_SFP_NOT_PRESENT;
1537 case ixgbe_sfp_type_da_cu_core0:
1538 case ixgbe_sfp_type_da_cu_core1:
1541 case ixgbe_sfp_type_srlr_core0:
1542 case ixgbe_sfp_type_srlr_core1:
1543 case ixgbe_sfp_type_da_act_lmt_core0:
1544 case ixgbe_sfp_type_da_act_lmt_core1:
1545 case ixgbe_sfp_type_1g_sx_core0:
1546 case ixgbe_sfp_type_1g_sx_core1:
1547 case ixgbe_sfp_type_1g_lx_core0:
1548 case ixgbe_sfp_type_1g_lx_core1:
1551 case ixgbe_sfp_type_unknown:
1552 case ixgbe_sfp_type_1g_cu_core0:
1553 case ixgbe_sfp_type_1g_cu_core1:
1555 return IXGBE_ERR_SFP_NOT_SUPPORTED;
1558 return IXGBE_SUCCESS;
1562 * ixgbe_identify_sfp_module_X550em - Identifies SFP modules
1563 * @hw: pointer to hardware structure
1565 * Searches for and identifies the SFP module and assigns appropriate PHY type.
1567 s32 ixgbe_identify_sfp_module_X550em(struct ixgbe_hw *hw)
1572 DEBUGFUNC("ixgbe_identify_sfp_module_X550em");
1574 status = ixgbe_identify_module_generic(hw);
1576 if (status != IXGBE_SUCCESS)
1579 /* Check if SFP module is supported */
1580 status = ixgbe_supported_sfp_modules_X550em(hw, &linear);
1586 * ixgbe_setup_sfp_modules_X550em - Setup MAC link ops
1587 * @hw: pointer to hardware structure
1589 s32 ixgbe_setup_sfp_modules_X550em(struct ixgbe_hw *hw)
1594 DEBUGFUNC("ixgbe_setup_sfp_modules_X550em");
1596 /* Check if SFP module is supported */
1597 status = ixgbe_supported_sfp_modules_X550em(hw, &linear);
1599 if (status != IXGBE_SUCCESS)
1602 ixgbe_init_mac_link_ops_X550em(hw);
1603 hw->phy.ops.reset = NULL;
1605 return IXGBE_SUCCESS;
1609 * ixgbe_setup_sgmii - Set up link for sgmii
1610 * @hw: pointer to hardware structure
1612 STATIC s32 ixgbe_setup_sgmii(struct ixgbe_hw *hw, ixgbe_link_speed speed,
1615 struct ixgbe_mac_info *mac = &hw->mac;
1619 rc = mac->ops.read_iosf_sb_reg(hw,
1620 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1621 IXGBE_SB_IOSF_TARGET_KR_PHY, &lval);
1625 lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
1626 lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK;
1627 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_SGMII_EN;
1628 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CLAUSE_37_EN;
1629 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_1G;
1630 rc = mac->ops.write_iosf_sb_reg(hw,
1631 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1632 IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
1636 rc = mac->ops.read_iosf_sb_reg(hw,
1637 IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
1638 IXGBE_SB_IOSF_TARGET_KR_PHY, &sval);
1642 sval |= IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_10_D;
1643 sval |= IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_100_D;
1644 rc = mac->ops.write_iosf_sb_reg(hw,
1645 IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
1646 IXGBE_SB_IOSF_TARGET_KR_PHY, sval);
1650 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
1651 rc = mac->ops.write_iosf_sb_reg(hw,
1652 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1653 IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
1657 return hw->phy.ops.setup_link_speed(hw, speed, autoneg_wait);
1661 * ixgbe_setup_sgmii_m88 - Set up link for sgmii with Marvell PHYs
1662 * @hw: pointer to hardware structure
1664 STATIC s32 ixgbe_setup_sgmii_m88(struct ixgbe_hw *hw, ixgbe_link_speed speed,
1667 struct ixgbe_mac_info *mac = &hw->mac;
1671 rc = mac->ops.read_iosf_sb_reg(hw,
1672 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1673 IXGBE_SB_IOSF_TARGET_KR_PHY, &lval);
1677 lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
1678 lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK;
1679 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_SGMII_EN;
1680 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CLAUSE_37_EN;
1681 lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_1G;
1682 rc = mac->ops.write_iosf_sb_reg(hw,
1683 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1684 IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
1688 rc = mac->ops.read_iosf_sb_reg(hw,
1689 IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
1690 IXGBE_SB_IOSF_TARGET_KR_PHY, &sval);
1694 sval &= ~IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_10_D;
1695 sval &= ~IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_100_D;
1696 rc = mac->ops.write_iosf_sb_reg(hw,
1697 IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
1698 IXGBE_SB_IOSF_TARGET_KR_PHY, sval);
1702 lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
1703 rc = mac->ops.write_iosf_sb_reg(hw,
1704 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
1705 IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
1709 return hw->phy.ops.setup_link_speed(hw, speed, autoneg_wait);
1713 * ixgbe_check_link_m88 - Poll PHY for link
1714 * @hw: pointer to hardware structure
1715 * @speed: pointer to link speed
1716 * @link_up: true when link is up
1717 * @link_up_wait: bool indicating whether to wait for link
1719 * Check that both the MAC and PHY have link.
1722 ixgbe_check_link_m88(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
1723 bool *link_up, bool link_up_wait)
1729 rc = ixgbe_check_mac_link_generic(hw, speed, link_up, link_up_wait);
1730 if (rc || !*link_up)
1733 rc = hw->phy.ops.read_reg(hw, IXGBE_M88E1500_PHY_SPEC_STATUS, 0, ®);
1735 /* MAC link is up, so check external PHY link */
1736 *link_up = !!(reg & IXGBE_M88E1500_PHY_SPEC_STATUS_LINK);
1739 for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) {
1741 (reg & IXGBE_M88E1500_PHY_SPEC_STATUS_LINK)) {
1747 rc = hw->phy.ops.read_reg(hw,
1748 IXGBE_M88E1500_PHY_SPEC_STATUS,
1753 #define M88_SPEED(x) (IXGBE_M88E1500_PHY_SPEC_STATUS_RESOLVED | \
1754 IXGBE_M88E1500_PHY_SPEC_STATUS_DUPLEX | \
1755 ((IXGBE_M88E1500_PHY_SPEC_STATUS_SPEED_##x) <<\
1756 IXGBE_M88E1500_PHY_SPEC_STATUS_SPEED_SHIFT))
1758 reg &= M88_SPEED(MASK);
1761 *speed = IXGBE_LINK_SPEED_10_FULL;
1763 case M88_SPEED(100):
1764 *speed = IXGBE_LINK_SPEED_100_FULL;
1766 case M88_SPEED(1000):
1767 *speed = IXGBE_LINK_SPEED_1GB_FULL;
1770 *speed = IXGBE_LINK_SPEED_UNKNOWN;
1779 * ixgbe_init_mac_link_ops_X550em - init mac link function pointers
1780 * @hw: pointer to hardware structure
1782 void ixgbe_init_mac_link_ops_X550em(struct ixgbe_hw *hw)
1784 struct ixgbe_mac_info *mac = &hw->mac;
1786 DEBUGFUNC("ixgbe_init_mac_link_ops_X550em");
1788 switch (hw->mac.ops.get_media_type(hw)) {
1789 case ixgbe_media_type_fiber:
1790 /* CS4227 does not support autoneg, so disable the laser control
1791 * functions for SFP+ fiber
1793 mac->ops.disable_tx_laser = NULL;
1794 mac->ops.enable_tx_laser = NULL;
1795 mac->ops.flap_tx_laser = NULL;
1796 mac->ops.setup_link = ixgbe_setup_mac_link_multispeed_fiber;
1797 mac->ops.set_rate_select_speed =
1798 ixgbe_set_soft_rate_select_speed;
1799 if ((hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N) ||
1800 (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP))
1801 mac->ops.setup_mac_link =
1802 ixgbe_setup_mac_link_sfp_x550a;
1804 mac->ops.setup_mac_link =
1805 ixgbe_setup_mac_link_sfp_x550em;
1807 case ixgbe_media_type_copper:
1808 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T ||
1809 hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L) {
1810 mac->ops.setup_link = ixgbe_setup_sgmii_m88;
1811 mac->ops.check_link = ixgbe_check_link_m88;
1813 mac->ops.setup_link = ixgbe_setup_mac_link_t_X550em;
1814 mac->ops.check_link = ixgbe_check_link_t_X550em;
1817 case ixgbe_media_type_backplane:
1818 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII ||
1819 hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII_L)
1820 mac->ops.setup_link = ixgbe_setup_sgmii;
1828 * ixgbe_get_link_capabilities_x550em - Determines link capabilities
1829 * @hw: pointer to hardware structure
1830 * @speed: pointer to link speed
1831 * @autoneg: true when autoneg or autotry is enabled
1833 s32 ixgbe_get_link_capabilities_X550em(struct ixgbe_hw *hw,
1834 ixgbe_link_speed *speed,
1837 DEBUGFUNC("ixgbe_get_link_capabilities_X550em");
1840 if (hw->phy.media_type == ixgbe_media_type_fiber) {
1842 /* CS4227 SFP must not enable auto-negotiation */
1845 /* Check if 1G SFP module. */
1846 if (hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core0 ||
1847 hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core1
1848 || hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core0 ||
1849 hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core1) {
1850 *speed = IXGBE_LINK_SPEED_1GB_FULL;
1851 return IXGBE_SUCCESS;
1854 /* Link capabilities are based on SFP */
1855 if (hw->phy.multispeed_fiber)
1856 *speed = IXGBE_LINK_SPEED_10GB_FULL |
1857 IXGBE_LINK_SPEED_1GB_FULL;
1859 *speed = IXGBE_LINK_SPEED_10GB_FULL;
1861 switch (hw->phy.type) {
1863 *speed = IXGBE_LINK_SPEED_1GB_FULL |
1864 IXGBE_LINK_SPEED_100_FULL |
1865 IXGBE_LINK_SPEED_10_FULL;
1867 case ixgbe_phy_sgmii:
1868 *speed = IXGBE_LINK_SPEED_1GB_FULL;
1871 *speed = IXGBE_LINK_SPEED_10GB_FULL |
1872 IXGBE_LINK_SPEED_1GB_FULL;
1878 return IXGBE_SUCCESS;
1882 * ixgbe_get_lasi_ext_t_x550em - Determime external Base T PHY interrupt cause
1883 * @hw: pointer to hardware structure
1884 * @lsc: pointer to boolean flag which indicates whether external Base T
1885 * PHY interrupt is lsc
1887 * Determime if external Base T PHY interrupt cause is high temperature
1888 * failure alarm or link status change.
1890 * Return IXGBE_ERR_OVERTEMP if interrupt is high temperature
1891 * failure alarm, else return PHY access status.
1893 STATIC s32 ixgbe_get_lasi_ext_t_x550em(struct ixgbe_hw *hw, bool *lsc)
1900 /* Vendor alarm triggered */
1901 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_CHIP_STD_INT_FLAG,
1902 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
1905 if (status != IXGBE_SUCCESS ||
1906 !(reg & IXGBE_MDIO_GLOBAL_VEN_ALM_INT_EN))
1909 /* Vendor Auto-Neg alarm triggered or Global alarm 1 triggered */
1910 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_INT_CHIP_VEN_FLAG,
1911 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
1914 if (status != IXGBE_SUCCESS ||
1915 !(reg & (IXGBE_MDIO_GLOBAL_AN_VEN_ALM_INT_EN |
1916 IXGBE_MDIO_GLOBAL_ALARM_1_INT)))
1919 /* Global alarm triggered */
1920 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_ALARM_1,
1921 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
1924 if (status != IXGBE_SUCCESS)
1927 /* If high temperature failure, then return over temp error and exit */
1928 if (reg & IXGBE_MDIO_GLOBAL_ALM_1_HI_TMP_FAIL) {
1929 /* power down the PHY in case the PHY FW didn't already */
1930 ixgbe_set_copper_phy_power(hw, false);
1931 return IXGBE_ERR_OVERTEMP;
1932 } else if (reg & IXGBE_MDIO_GLOBAL_ALM_1_DEV_FAULT) {
1933 /* device fault alarm triggered */
1934 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_FAULT_MSG,
1935 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
1938 if (status != IXGBE_SUCCESS)
1941 /* if device fault was due to high temp alarm handle and exit */
1942 if (reg == IXGBE_MDIO_GLOBAL_FAULT_MSG_HI_TMP) {
1943 /* power down the PHY in case the PHY FW didn't */
1944 ixgbe_set_copper_phy_power(hw, false);
1945 return IXGBE_ERR_OVERTEMP;
1949 /* Vendor alarm 2 triggered */
1950 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_CHIP_STD_INT_FLAG,
1951 IXGBE_MDIO_AUTO_NEG_DEV_TYPE, ®);
1953 if (status != IXGBE_SUCCESS ||
1954 !(reg & IXGBE_MDIO_GLOBAL_STD_ALM2_INT))
1957 /* link connect/disconnect event occurred */
1958 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_VENDOR_TX_ALARM2,
1959 IXGBE_MDIO_AUTO_NEG_DEV_TYPE, ®);
1961 if (status != IXGBE_SUCCESS)
1965 if (reg & IXGBE_MDIO_AUTO_NEG_VEN_LSC)
1968 return IXGBE_SUCCESS;
1972 * ixgbe_enable_lasi_ext_t_x550em - Enable external Base T PHY interrupts
1973 * @hw: pointer to hardware structure
1975 * Enable link status change and temperature failure alarm for the external
1978 * Returns PHY access status
1980 STATIC s32 ixgbe_enable_lasi_ext_t_x550em(struct ixgbe_hw *hw)
1986 /* Clear interrupt flags */
1987 status = ixgbe_get_lasi_ext_t_x550em(hw, &lsc);
1989 /* Enable link status change alarm */
1990 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_PMA_TX_VEN_LASI_INT_MASK,
1991 IXGBE_MDIO_AUTO_NEG_DEV_TYPE, ®);
1993 if (status != IXGBE_SUCCESS)
1996 reg |= IXGBE_MDIO_PMA_TX_VEN_LASI_INT_EN;
1998 status = hw->phy.ops.write_reg(hw, IXGBE_MDIO_PMA_TX_VEN_LASI_INT_MASK,
1999 IXGBE_MDIO_AUTO_NEG_DEV_TYPE, reg);
2001 if (status != IXGBE_SUCCESS)
2004 /* Enable high temperature failure and global fault alarms */
2005 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_INT_MASK,
2006 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2009 if (status != IXGBE_SUCCESS)
2012 reg |= (IXGBE_MDIO_GLOBAL_INT_HI_TEMP_EN |
2013 IXGBE_MDIO_GLOBAL_INT_DEV_FAULT_EN);
2015 status = hw->phy.ops.write_reg(hw, IXGBE_MDIO_GLOBAL_INT_MASK,
2016 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2019 if (status != IXGBE_SUCCESS)
2022 /* Enable vendor Auto-Neg alarm and Global Interrupt Mask 1 alarm */
2023 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_INT_CHIP_VEN_MASK,
2024 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2027 if (status != IXGBE_SUCCESS)
2030 reg |= (IXGBE_MDIO_GLOBAL_AN_VEN_ALM_INT_EN |
2031 IXGBE_MDIO_GLOBAL_ALARM_1_INT);
2033 status = hw->phy.ops.write_reg(hw, IXGBE_MDIO_GLOBAL_INT_CHIP_VEN_MASK,
2034 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2037 if (status != IXGBE_SUCCESS)
2040 /* Enable chip-wide vendor alarm */
2041 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_GLOBAL_INT_CHIP_STD_MASK,
2042 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2045 if (status != IXGBE_SUCCESS)
2048 reg |= IXGBE_MDIO_GLOBAL_VEN_ALM_INT_EN;
2050 status = hw->phy.ops.write_reg(hw, IXGBE_MDIO_GLOBAL_INT_CHIP_STD_MASK,
2051 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2058 * ixgbe_setup_kr_speed_x550em - Configure the KR PHY for link speed.
2059 * @hw: pointer to hardware structure
2060 * @speed: link speed
2062 * Configures the integrated KR PHY.
2064 STATIC s32 ixgbe_setup_kr_speed_x550em(struct ixgbe_hw *hw,
2065 ixgbe_link_speed speed)
2070 status = hw->mac.ops.read_iosf_sb_reg(hw,
2071 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2072 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2076 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
2077 reg_val &= ~(IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KR |
2078 IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KX);
2080 /* Advertise 10G support. */
2081 if (speed & IXGBE_LINK_SPEED_10GB_FULL)
2082 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KR;
2084 /* Advertise 1G support. */
2085 if (speed & IXGBE_LINK_SPEED_1GB_FULL)
2086 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KX;
2088 /* Restart auto-negotiation. */
2089 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
2090 status = hw->mac.ops.write_iosf_sb_reg(hw,
2091 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2092 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2098 * ixgbe_setup_m88 - setup m88 PHY
2099 * @hw: pointer to hardware structure
2101 STATIC s32 ixgbe_setup_m88(struct ixgbe_hw *hw)
2103 u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
2107 if (hw->phy.reset_disable || ixgbe_check_reset_blocked(hw))
2108 return IXGBE_SUCCESS;
2110 rc = hw->mac.ops.acquire_swfw_sync(hw, mask);
2114 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, ®);
2117 if (reg & IXGBE_M88E1500_COPPER_CTRL_POWER_DOWN) {
2118 reg &= ~IXGBE_M88E1500_COPPER_CTRL_POWER_DOWN;
2119 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0,
2123 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_MAC_CTRL_1, 0, ®);
2126 if (reg & IXGBE_M88E1500_MAC_CTRL_1_POWER_DOWN) {
2127 reg &= ~IXGBE_M88E1500_MAC_CTRL_1_POWER_DOWN;
2128 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_MAC_CTRL_1, 0,
2132 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 2);
2136 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_MAC_SPEC_CTRL, 0,
2140 if (reg & IXGBE_M88E1500_MAC_SPEC_CTRL_POWER_DOWN) {
2141 reg &= ~IXGBE_M88E1500_MAC_SPEC_CTRL_POWER_DOWN;
2142 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_MAC_SPEC_CTRL, 0,
2144 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0,
2148 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0,
2152 reg |= IXGBE_M88E1500_COPPER_CTRL_RESET;
2153 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0,
2157 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0,
2163 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, ®);
2167 if (!(reg & IXGBE_M88E1500_COPPER_CTRL_AN_EN)) {
2168 reg |= IXGBE_M88E1500_COPPER_CTRL_AN_EN;
2169 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0,
2173 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_1000T_CTRL, 0, ®);
2176 reg &= ~IXGBE_M88E1500_1000T_CTRL_HALF_DUPLEX;
2177 reg &= ~IXGBE_M88E1500_1000T_CTRL_FULL_DUPLEX;
2178 if (hw->phy.autoneg_advertised & IXGBE_LINK_SPEED_1GB_FULL)
2179 reg |= IXGBE_M88E1500_1000T_CTRL_FULL_DUPLEX;
2180 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_1000T_CTRL, 0, reg);
2182 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_AN, 0, ®);
2185 reg &= ~IXGBE_M88E1500_COPPER_AN_AS_PAUSE;
2186 reg &= ~IXGBE_M88E1500_COPPER_AN_PAUSE;
2187 reg &= ~IXGBE_M88E1500_COPPER_AN_T4;
2188 reg &= ~IXGBE_M88E1500_COPPER_AN_100TX_FD;
2189 reg &= ~IXGBE_M88E1500_COPPER_AN_100TX_HD;
2190 reg &= ~IXGBE_M88E1500_COPPER_AN_10TX_FD;
2191 reg &= ~IXGBE_M88E1500_COPPER_AN_10TX_HD;
2192 switch (hw->fc.current_mode) {
2194 reg |= IXGBE_M88E1500_COPPER_AN_PAUSE;
2196 case ixgbe_fc_rx_pause:
2197 reg |= IXGBE_M88E1500_COPPER_AN_PAUSE;
2198 reg |= IXGBE_M88E1500_COPPER_AN_AS_PAUSE;
2200 case ixgbe_fc_tx_pause:
2201 reg |= IXGBE_M88E1500_COPPER_AN_AS_PAUSE;
2207 if (hw->phy.autoneg_advertised & IXGBE_LINK_SPEED_100_FULL)
2208 reg |= IXGBE_M88E1500_COPPER_AN_100TX_FD;
2209 if (hw->phy.autoneg_advertised & IXGBE_LINK_SPEED_10_FULL)
2210 reg |= IXGBE_M88E1500_COPPER_AN_10TX_FD;
2211 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_AN, 0, reg);
2213 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, ®);
2216 reg |= IXGBE_M88E1500_COPPER_CTRL_RESTART_AN;
2217 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, reg);
2220 hw->mac.ops.release_swfw_sync(hw, mask);
2224 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 0);
2225 hw->mac.ops.release_swfw_sync(hw, mask);
2230 * ixgbe_reset_phy_m88e1500 - Reset m88e1500 PHY
2231 * @hw: pointer to hardware structure
2233 * The PHY token must be held when calling this function.
2235 static s32 ixgbe_reset_phy_m88e1500(struct ixgbe_hw *hw)
2240 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 0);
2244 rc = hw->phy.ops.read_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, ®);
2248 reg |= IXGBE_M88E1500_COPPER_CTRL_RESET;
2249 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, reg);
2257 * ixgbe_reset_phy_m88e1543 - Reset m88e1543 PHY
2258 * @hw: pointer to hardware structure
2260 * The PHY token must be held when calling this function.
2262 static s32 ixgbe_reset_phy_m88e1543(struct ixgbe_hw *hw)
2264 return hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 0);
2268 * ixgbe_reset_phy_m88 - Reset m88 PHY
2269 * @hw: pointer to hardware structure
2271 STATIC s32 ixgbe_reset_phy_m88(struct ixgbe_hw *hw)
2273 u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
2277 if (hw->phy.reset_disable || ixgbe_check_reset_blocked(hw))
2278 return IXGBE_SUCCESS;
2280 rc = hw->mac.ops.acquire_swfw_sync(hw, mask);
2284 switch (hw->phy.id) {
2285 case IXGBE_M88E1500_E_PHY_ID:
2286 rc = ixgbe_reset_phy_m88e1500(hw);
2288 case IXGBE_M88E1543_E_PHY_ID:
2289 rc = ixgbe_reset_phy_m88e1543(hw);
2296 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 1);
2300 reg = IXGBE_M88E1500_FIBER_CTRL_RESET |
2301 IXGBE_M88E1500_FIBER_CTRL_DUPLEX_FULL |
2302 IXGBE_M88E1500_FIBER_CTRL_SPEED_MSB;
2303 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_FIBER_CTRL, 0, reg);
2307 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 18);
2311 reg = IXGBE_M88E1500_GEN_CTRL_RESET |
2312 IXGBE_M88E1500_GEN_CTRL_MODE_SGMII_COPPER;
2313 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_GEN_CTRL, 0, reg);
2317 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 1);
2321 reg = IXGBE_M88E1500_FIBER_CTRL_RESET |
2322 IXGBE_M88E1500_FIBER_CTRL_AN_EN |
2323 IXGBE_M88E1500_FIBER_CTRL_DUPLEX_FULL |
2324 IXGBE_M88E1500_FIBER_CTRL_SPEED_MSB;
2325 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_FIBER_CTRL, 0, reg);
2329 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 0);
2333 reg = (IXGBE_M88E1500_MAC_CTRL_1_DWN_4X <<
2334 IXGBE_M88E1500_MAC_CTRL_1_DWN_SHIFT) |
2335 (IXGBE_M88E1500_MAC_CTRL_1_ED_TM <<
2336 IXGBE_M88E1500_MAC_CTRL_1_ED_SHIFT) |
2337 (IXGBE_M88E1500_MAC_CTRL_1_MDIX_AUTO <<
2338 IXGBE_M88E1500_MAC_CTRL_1_MDIX_SHIFT);
2339 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_MAC_CTRL_1, 0, reg);
2343 reg = IXGBE_M88E1500_COPPER_CTRL_RESET |
2344 IXGBE_M88E1500_COPPER_CTRL_AN_EN |
2345 IXGBE_M88E1500_COPPER_CTRL_RESTART_AN |
2346 IXGBE_M88E1500_COPPER_CTRL_FULL_DUPLEX |
2347 IXGBE_M88E1500_COPPER_CTRL_SPEED_MSB;
2348 rc = hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_COPPER_CTRL, 0, reg);
2352 hw->mac.ops.release_swfw_sync(hw, mask);
2354 return ixgbe_setup_m88(hw);
2357 hw->phy.ops.write_reg_mdi(hw, IXGBE_M88E1500_PAGE_ADDR, 0, 0);
2358 hw->mac.ops.release_swfw_sync(hw, mask);
2363 * ixgbe_read_mng_if_sel_x550em - Read NW_MNG_IF_SEL register
2364 * @hw: pointer to hardware structure
2366 * Read NW_MNG_IF_SEL register and save field values, and check for valid field
2369 STATIC s32 ixgbe_read_mng_if_sel_x550em(struct ixgbe_hw *hw)
2371 /* Save NW management interface connected on board. This is used
2372 * to determine internal PHY mode.
2374 hw->phy.nw_mng_if_sel = IXGBE_READ_REG(hw, IXGBE_NW_MNG_IF_SEL);
2376 /* If X552 (X550EM_a) and MDIO is connected to external PHY, then set
2377 * PHY address. This register field was has only been used for X552.
2379 if (hw->mac.type == ixgbe_mac_X550EM_a &&
2380 hw->phy.nw_mng_if_sel & IXGBE_NW_MNG_IF_SEL_MDIO_ACT) {
2381 hw->phy.addr = (hw->phy.nw_mng_if_sel &
2382 IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD) >>
2383 IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD_SHIFT;
2386 return IXGBE_SUCCESS;
2390 * ixgbe_init_phy_ops_X550em - PHY/SFP specific init
2391 * @hw: pointer to hardware structure
2393 * Initialize any function pointers that were not able to be
2394 * set during init_shared_code because the PHY/SFP type was
2395 * not known. Perform the SFP init if necessary.
2397 s32 ixgbe_init_phy_ops_X550em(struct ixgbe_hw *hw)
2399 struct ixgbe_phy_info *phy = &hw->phy;
2402 DEBUGFUNC("ixgbe_init_phy_ops_X550em");
2404 hw->mac.ops.set_lan_id(hw);
2406 ixgbe_read_mng_if_sel_x550em(hw);
2408 if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) {
2409 phy->phy_semaphore_mask = IXGBE_GSSR_SHARED_I2C_SM;
2410 ixgbe_setup_mux_ctl(hw);
2411 phy->ops.identify_sfp = ixgbe_identify_sfp_module_X550em;
2414 switch (hw->device_id) {
2415 case IXGBE_DEV_ID_X550EM_A_1G_T:
2416 case IXGBE_DEV_ID_X550EM_A_1G_T_L:
2417 phy->ops.read_reg_mdi = ixgbe_read_phy_reg_mdi_22;
2418 phy->ops.write_reg_mdi = ixgbe_write_phy_reg_mdi_22;
2424 /* Identify the PHY or SFP module */
2425 ret_val = phy->ops.identify(hw);
2426 if (ret_val == IXGBE_ERR_SFP_NOT_SUPPORTED)
2429 /* Setup function pointers based on detected hardware */
2430 ixgbe_init_mac_link_ops_X550em(hw);
2431 if (phy->sfp_type != ixgbe_sfp_type_unknown)
2432 phy->ops.reset = NULL;
2434 /* Set functions pointers based on phy type */
2435 switch (hw->phy.type) {
2436 case ixgbe_phy_x550em_kx4:
2437 phy->ops.setup_link = NULL;
2438 phy->ops.read_reg = ixgbe_read_phy_reg_x550em;
2439 phy->ops.write_reg = ixgbe_write_phy_reg_x550em;
2441 case ixgbe_phy_x550em_kr:
2442 phy->ops.setup_link = ixgbe_setup_kr_x550em;
2443 phy->ops.read_reg = ixgbe_read_phy_reg_x550em;
2444 phy->ops.write_reg = ixgbe_write_phy_reg_x550em;
2446 case ixgbe_phy_x550em_ext_t:
2447 /* If internal link mode is XFI, then setup iXFI internal link,
2448 * else setup KR now.
2450 phy->ops.setup_internal_link =
2451 ixgbe_setup_internal_phy_t_x550em;
2453 /* setup SW LPLU only for first revision of X550EM_x */
2454 if ((hw->mac.type == ixgbe_mac_X550EM_x) &&
2455 !(IXGBE_FUSES0_REV_MASK &
2456 IXGBE_READ_REG(hw, IXGBE_FUSES0_GROUP(0))))
2457 phy->ops.enter_lplu = ixgbe_enter_lplu_t_x550em;
2459 phy->ops.handle_lasi = ixgbe_handle_lasi_ext_t_x550em;
2460 phy->ops.reset = ixgbe_reset_phy_t_X550em;
2462 case ixgbe_phy_sgmii:
2463 phy->ops.setup_link = NULL;
2466 phy->ops.setup_link = ixgbe_setup_m88;
2467 phy->ops.reset = ixgbe_reset_phy_m88;
2476 * ixgbe_set_mdio_speed - Set MDIO clock speed
2477 * @hw: pointer to hardware structure
2479 STATIC void ixgbe_set_mdio_speed(struct ixgbe_hw *hw)
2483 switch (hw->device_id) {
2484 case IXGBE_DEV_ID_X550EM_X_10G_T:
2485 case IXGBE_DEV_ID_X550EM_A_SGMII:
2486 case IXGBE_DEV_ID_X550EM_A_SGMII_L:
2487 case IXGBE_DEV_ID_X550EM_A_1G_T:
2488 case IXGBE_DEV_ID_X550EM_A_1G_T_L:
2489 case IXGBE_DEV_ID_X550EM_A_10G_T:
2490 case IXGBE_DEV_ID_X550EM_A_SFP:
2491 case IXGBE_DEV_ID_X550EM_A_QSFP:
2492 /* Config MDIO clock speed before the first MDIO PHY access */
2493 hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
2494 hlreg0 &= ~IXGBE_HLREG0_MDCSPD;
2495 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
2503 * ixgbe_reset_hw_X550em - Perform hardware reset
2504 * @hw: pointer to hardware structure
2506 * Resets the hardware by resetting the transmit and receive units, masks
2507 * and clears all interrupts, perform a PHY reset, and perform a link (MAC)
2510 s32 ixgbe_reset_hw_X550em(struct ixgbe_hw *hw)
2512 ixgbe_link_speed link_speed;
2516 bool link_up = false;
2518 DEBUGFUNC("ixgbe_reset_hw_X550em");
2520 /* Call adapter stop to disable Tx/Rx and clear interrupts */
2521 status = hw->mac.ops.stop_adapter(hw);
2522 if (status != IXGBE_SUCCESS)
2525 /* flush pending Tx transactions */
2526 ixgbe_clear_tx_pending(hw);
2528 ixgbe_set_mdio_speed(hw);
2530 /* PHY ops must be identified and initialized prior to reset */
2531 status = hw->phy.ops.init(hw);
2533 if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
2536 /* start the external PHY */
2537 if (hw->phy.type == ixgbe_phy_x550em_ext_t) {
2538 status = ixgbe_init_ext_t_x550em(hw);
2543 /* Setup SFP module if there is one present. */
2544 if (hw->phy.sfp_setup_needed) {
2545 status = hw->mac.ops.setup_sfp(hw);
2546 hw->phy.sfp_setup_needed = false;
2549 if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
2553 if (!hw->phy.reset_disable && hw->phy.ops.reset)
2554 hw->phy.ops.reset(hw);
2557 /* Issue global reset to the MAC. Needs to be SW reset if link is up.
2558 * If link reset is used when link is up, it might reset the PHY when
2559 * mng is using it. If link is down or the flag to force full link
2560 * reset is set, then perform link reset.
2562 ctrl = IXGBE_CTRL_LNK_RST;
2563 if (!hw->force_full_reset) {
2564 hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
2566 ctrl = IXGBE_CTRL_RST;
2569 ctrl |= IXGBE_READ_REG(hw, IXGBE_CTRL);
2570 IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
2571 IXGBE_WRITE_FLUSH(hw);
2573 /* Poll for reset bit to self-clear meaning reset is complete */
2574 for (i = 0; i < 10; i++) {
2576 ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
2577 if (!(ctrl & IXGBE_CTRL_RST_MASK))
2581 if (ctrl & IXGBE_CTRL_RST_MASK) {
2582 status = IXGBE_ERR_RESET_FAILED;
2583 DEBUGOUT("Reset polling failed to complete.\n");
2588 /* Double resets are required for recovery from certain error
2589 * conditions. Between resets, it is necessary to stall to
2590 * allow time for any pending HW events to complete.
2592 if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) {
2593 hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
2597 /* Store the permanent mac address */
2598 hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
2600 /* Store MAC address from RAR0, clear receive address registers, and
2601 * clear the multicast table. Also reset num_rar_entries to 128,
2602 * since we modify this value when programming the SAN MAC address.
2604 hw->mac.num_rar_entries = 128;
2605 hw->mac.ops.init_rx_addrs(hw);
2607 ixgbe_set_mdio_speed(hw);
2609 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP)
2610 ixgbe_setup_mux_ctl(hw);
2616 * ixgbe_init_ext_t_x550em - Start (unstall) the external Base T PHY.
2617 * @hw: pointer to hardware structure
2619 s32 ixgbe_init_ext_t_x550em(struct ixgbe_hw *hw)
2624 status = hw->phy.ops.read_reg(hw,
2625 IXGBE_MDIO_TX_VENDOR_ALARMS_3,
2626 IXGBE_MDIO_PMA_PMD_DEV_TYPE,
2629 if (status != IXGBE_SUCCESS)
2632 /* If PHY FW reset completed bit is set then this is the first
2633 * SW instance after a power on so the PHY FW must be un-stalled.
2635 if (reg & IXGBE_MDIO_TX_VENDOR_ALARMS_3_RST_MASK) {
2636 status = hw->phy.ops.read_reg(hw,
2637 IXGBE_MDIO_GLOBAL_RES_PR_10,
2638 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2641 if (status != IXGBE_SUCCESS)
2644 reg &= ~IXGBE_MDIO_POWER_UP_STALL;
2646 status = hw->phy.ops.write_reg(hw,
2647 IXGBE_MDIO_GLOBAL_RES_PR_10,
2648 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE,
2651 if (status != IXGBE_SUCCESS)
2659 * ixgbe_setup_kr_x550em - Configure the KR PHY.
2660 * @hw: pointer to hardware structure
2662 * Configures the integrated KR PHY for X550EM_x.
2664 s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw)
2666 if (hw->mac.type != ixgbe_mac_X550EM_x)
2667 return IXGBE_SUCCESS;
2669 return ixgbe_setup_kr_speed_x550em(hw, hw->phy.autoneg_advertised);
2673 * ixgbe_setup_mac_link_sfp_x550em - Setup internal/external the PHY for SFP
2674 * @hw: pointer to hardware structure
2676 * Configure the external PHY and the integrated KR PHY for SFP support.
2678 s32 ixgbe_setup_mac_link_sfp_x550em(struct ixgbe_hw *hw,
2679 ixgbe_link_speed speed,
2680 bool autoneg_wait_to_complete)
2683 u16 reg_slice, reg_val;
2684 bool setup_linear = false;
2685 UNREFERENCED_1PARAMETER(autoneg_wait_to_complete);
2687 /* Check if SFP module is supported and linear */
2688 ret_val = ixgbe_supported_sfp_modules_X550em(hw, &setup_linear);
2690 /* If no SFP module present, then return success. Return success since
2691 * there is no reason to configure CS4227 and SFP not present error is
2692 * not excepted in the setup MAC link flow.
2694 if (ret_val == IXGBE_ERR_SFP_NOT_PRESENT)
2695 return IXGBE_SUCCESS;
2697 if (ret_val != IXGBE_SUCCESS)
2700 /* Configure internal PHY for KR/KX. */
2701 ixgbe_setup_kr_speed_x550em(hw, speed);
2703 /* Configure CS4227 LINE side to proper mode. */
2704 reg_slice = IXGBE_CS4227_LINE_SPARE24_LSB +
2705 (hw->bus.lan_id << 12);
2707 reg_val = (IXGBE_CS4227_EDC_MODE_CX1 << 1) | 0x1;
2709 reg_val = (IXGBE_CS4227_EDC_MODE_SR << 1) | 0x1;
2710 ret_val = hw->link.ops.write_link(hw, hw->link.addr, reg_slice,
2716 * ixgbe_setup_mac_link_sfp_x550a - Setup internal PHY for SFP
2717 * @hw: pointer to hardware structure
2719 * Configure the the integrated PHY for SFP support.
2721 s32 ixgbe_setup_mac_link_sfp_x550a(struct ixgbe_hw *hw,
2722 ixgbe_link_speed speed,
2723 bool autoneg_wait_to_complete)
2727 bool setup_linear = false;
2728 u32 reg_slice, reg_phy_int, slice_offset;
2730 UNREFERENCED_1PARAMETER(autoneg_wait_to_complete);
2732 /* Check if SFP module is supported and linear */
2733 ret_val = ixgbe_supported_sfp_modules_X550em(hw, &setup_linear);
2735 /* If no SFP module present, then return success. Return success since
2736 * SFP not present error is not excepted in the setup MAC link flow.
2738 if (ret_val == IXGBE_ERR_SFP_NOT_PRESENT)
2739 return IXGBE_SUCCESS;
2741 if (ret_val != IXGBE_SUCCESS)
2744 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N) {
2745 /* Configure internal PHY for native SFI */
2746 ret_val = hw->mac.ops.read_iosf_sb_reg(hw,
2747 IXGBE_KRM_AN_CNTL_8(hw->bus.lan_id),
2748 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_phy_int);
2750 if (ret_val != IXGBE_SUCCESS)
2754 reg_phy_int &= ~IXGBE_KRM_AN_CNTL_8_LIMITING;
2755 reg_phy_int |= IXGBE_KRM_AN_CNTL_8_LINEAR;
2757 reg_phy_int |= IXGBE_KRM_AN_CNTL_8_LIMITING;
2758 reg_phy_int &= ~IXGBE_KRM_AN_CNTL_8_LINEAR;
2761 ret_val = hw->mac.ops.write_iosf_sb_reg(hw,
2762 IXGBE_KRM_AN_CNTL_8(hw->bus.lan_id),
2763 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_phy_int);
2765 if (ret_val != IXGBE_SUCCESS)
2768 /* Setup XFI/SFI internal link. */
2769 ret_val = ixgbe_setup_ixfi_x550em(hw, &speed);
2771 /* Configure internal PHY for KR/KX. */
2772 ixgbe_setup_kr_speed_x550em(hw, speed);
2774 if (hw->phy.addr == 0x0 || hw->phy.addr == 0xFFFF) {
2776 DEBUGOUT("Invalid NW_MNG_IF_SEL.MDIO_PHY_ADD value\n");
2777 return IXGBE_ERR_PHY_ADDR_INVALID;
2780 /* Get external PHY device id */
2781 ret_val = hw->phy.ops.read_reg(hw, IXGBE_CS4227_GLOBAL_ID_MSB,
2782 IXGBE_MDIO_ZERO_DEV_TYPE, ®_phy_ext);
2784 if (ret_val != IXGBE_SUCCESS)
2787 /* When configuring quad port CS4223, the MAC instance is part
2788 * of the slice offset.
2790 if (reg_phy_ext == IXGBE_CS4223_PHY_ID)
2791 slice_offset = (hw->bus.lan_id +
2792 (hw->bus.instance_id << 1)) << 12;
2794 slice_offset = hw->bus.lan_id << 12;
2796 /* Configure CS4227/CS4223 LINE side to proper mode. */
2797 reg_slice = IXGBE_CS4227_LINE_SPARE24_LSB + slice_offset;
2799 reg_phy_ext = (IXGBE_CS4227_EDC_MODE_CX1 << 1) | 0x1;
2801 reg_phy_ext = (IXGBE_CS4227_EDC_MODE_SR << 1) | 0x1;
2802 ret_val = hw->phy.ops.write_reg(hw, reg_slice,
2803 IXGBE_MDIO_ZERO_DEV_TYPE, reg_phy_ext);
2809 * ixgbe_setup_ixfi_x550em_x - MAC specific iXFI configuration
2810 * @hw: pointer to hardware structure
2812 * iXfI configuration needed for ixgbe_mac_X550EM_x devices.
2814 STATIC s32 ixgbe_setup_ixfi_x550em_x(struct ixgbe_hw *hw)
2816 struct ixgbe_mac_info *mac = &hw->mac;
2820 /* Disable training protocol FSM. */
2821 status = mac->ops.read_iosf_sb_reg(hw,
2822 IXGBE_KRM_RX_TRN_LINKUP_CTRL(hw->bus.lan_id),
2823 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2824 if (status != IXGBE_SUCCESS)
2826 reg_val |= IXGBE_KRM_RX_TRN_LINKUP_CTRL_CONV_WO_PROTOCOL;
2827 status = mac->ops.write_iosf_sb_reg(hw,
2828 IXGBE_KRM_RX_TRN_LINKUP_CTRL(hw->bus.lan_id),
2829 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2830 if (status != IXGBE_SUCCESS)
2833 /* Disable Flex from training TXFFE. */
2834 status = mac->ops.read_iosf_sb_reg(hw,
2835 IXGBE_KRM_DSP_TXFFE_STATE_4(hw->bus.lan_id),
2836 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2837 if (status != IXGBE_SUCCESS)
2839 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_C0_EN;
2840 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_CP1_CN1_EN;
2841 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_CO_ADAPT_EN;
2842 status = mac->ops.write_iosf_sb_reg(hw,
2843 IXGBE_KRM_DSP_TXFFE_STATE_4(hw->bus.lan_id),
2844 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2845 if (status != IXGBE_SUCCESS)
2847 status = mac->ops.read_iosf_sb_reg(hw,
2848 IXGBE_KRM_DSP_TXFFE_STATE_5(hw->bus.lan_id),
2849 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2850 if (status != IXGBE_SUCCESS)
2852 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_C0_EN;
2853 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_CP1_CN1_EN;
2854 reg_val &= ~IXGBE_KRM_DSP_TXFFE_STATE_CO_ADAPT_EN;
2855 status = mac->ops.write_iosf_sb_reg(hw,
2856 IXGBE_KRM_DSP_TXFFE_STATE_5(hw->bus.lan_id),
2857 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2858 if (status != IXGBE_SUCCESS)
2861 /* Enable override for coefficients. */
2862 status = mac->ops.read_iosf_sb_reg(hw,
2863 IXGBE_KRM_TX_COEFF_CTRL_1(hw->bus.lan_id),
2864 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2865 if (status != IXGBE_SUCCESS)
2867 reg_val |= IXGBE_KRM_TX_COEFF_CTRL_1_OVRRD_EN;
2868 reg_val |= IXGBE_KRM_TX_COEFF_CTRL_1_CZERO_EN;
2869 reg_val |= IXGBE_KRM_TX_COEFF_CTRL_1_CPLUS1_OVRRD_EN;
2870 reg_val |= IXGBE_KRM_TX_COEFF_CTRL_1_CMINUS1_OVRRD_EN;
2871 status = mac->ops.write_iosf_sb_reg(hw,
2872 IXGBE_KRM_TX_COEFF_CTRL_1(hw->bus.lan_id),
2873 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2878 * ixgbe_setup_ixfi_x550em - Configure the KR PHY for iXFI mode.
2879 * @hw: pointer to hardware structure
2880 * @speed: the link speed to force
2882 * Configures the integrated KR PHY to use iXFI mode. Used to connect an
2883 * internal and external PHY at a specific speed, without autonegotiation.
2885 STATIC s32 ixgbe_setup_ixfi_x550em(struct ixgbe_hw *hw, ixgbe_link_speed *speed)
2887 struct ixgbe_mac_info *mac = &hw->mac;
2891 /* Disable AN and force speed to 10G Serial. */
2892 status = mac->ops.read_iosf_sb_reg(hw,
2893 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2894 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2895 if (status != IXGBE_SUCCESS)
2898 reg_val &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
2899 reg_val &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK;
2901 /* Select forced link speed for internal PHY. */
2903 case IXGBE_LINK_SPEED_10GB_FULL:
2904 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_10G;
2906 case IXGBE_LINK_SPEED_1GB_FULL:
2907 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_1G;
2910 /* Other link speeds are not supported by internal KR PHY. */
2911 return IXGBE_ERR_LINK_SETUP;
2914 status = mac->ops.write_iosf_sb_reg(hw,
2915 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2916 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2917 if (status != IXGBE_SUCCESS)
2920 /* Additional configuration needed for x550em_x */
2921 if (hw->mac.type == ixgbe_mac_X550EM_x) {
2922 status = ixgbe_setup_ixfi_x550em_x(hw);
2923 if (status != IXGBE_SUCCESS)
2927 /* Toggle port SW reset by AN reset. */
2928 status = mac->ops.read_iosf_sb_reg(hw,
2929 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2930 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
2931 if (status != IXGBE_SUCCESS)
2933 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
2934 status = mac->ops.write_iosf_sb_reg(hw,
2935 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
2936 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
2942 * ixgbe_ext_phy_t_x550em_get_link - Get ext phy link status
2943 * @hw: address of hardware structure
2944 * @link_up: address of boolean to indicate link status
2946 * Returns error code if unable to get link status.
2948 STATIC s32 ixgbe_ext_phy_t_x550em_get_link(struct ixgbe_hw *hw, bool *link_up)
2955 /* read this twice back to back to indicate current status */
2956 ret = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
2957 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2959 if (ret != IXGBE_SUCCESS)
2962 ret = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
2963 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2965 if (ret != IXGBE_SUCCESS)
2968 *link_up = !!(autoneg_status & IXGBE_MDIO_AUTO_NEG_LINK_STATUS);
2970 return IXGBE_SUCCESS;
2974 * ixgbe_setup_internal_phy_t_x550em - Configure KR PHY to X557 link
2975 * @hw: point to hardware structure
2977 * Configures the link between the integrated KR PHY and the external X557 PHY
2978 * The driver will call this function when it gets a link status change
2979 * interrupt from the X557 PHY. This function configures the link speed
2980 * between the PHYs to match the link speed of the BASE-T link.
2982 * A return of a non-zero value indicates an error, and the base driver should
2983 * not report link up.
2985 s32 ixgbe_setup_internal_phy_t_x550em(struct ixgbe_hw *hw)
2987 ixgbe_link_speed force_speed;
2992 if (hw->mac.ops.get_media_type(hw) != ixgbe_media_type_copper)
2993 return IXGBE_ERR_CONFIG;
2995 if (!(hw->phy.nw_mng_if_sel & IXGBE_NW_MNG_IF_SEL_INT_PHY_MODE)) {
2996 /* If link is down, there is no setup necessary so return */
2997 status = ixgbe_ext_phy_t_x550em_get_link(hw, &link_up);
2998 if (status != IXGBE_SUCCESS)
3002 return IXGBE_SUCCESS;
3004 status = hw->phy.ops.read_reg(hw,
3005 IXGBE_MDIO_AUTO_NEG_VENDOR_STAT,
3006 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3008 if (status != IXGBE_SUCCESS)
3011 /* If link is still down - no setup is required so return */
3012 status = ixgbe_ext_phy_t_x550em_get_link(hw, &link_up);
3013 if (status != IXGBE_SUCCESS)
3016 return IXGBE_SUCCESS;
3018 /* clear everything but the speed and duplex bits */
3019 speed &= IXGBE_MDIO_AUTO_NEG_VENDOR_STATUS_MASK;
3022 case IXGBE_MDIO_AUTO_NEG_VENDOR_STATUS_10GB_FULL:
3023 force_speed = IXGBE_LINK_SPEED_10GB_FULL;
3025 case IXGBE_MDIO_AUTO_NEG_VENDOR_STATUS_1GB_FULL:
3026 force_speed = IXGBE_LINK_SPEED_1GB_FULL;
3029 /* Internal PHY does not support anything else */
3030 return IXGBE_ERR_INVALID_LINK_SETTINGS;
3033 return ixgbe_setup_ixfi_x550em(hw, &force_speed);
3035 speed = IXGBE_LINK_SPEED_10GB_FULL |
3036 IXGBE_LINK_SPEED_1GB_FULL;
3037 return ixgbe_setup_kr_speed_x550em(hw, speed);
3042 * ixgbe_setup_phy_loopback_x550em - Configure the KR PHY for loopback.
3043 * @hw: pointer to hardware structure
3045 * Configures the integrated KR PHY to use internal loopback mode.
3047 s32 ixgbe_setup_phy_loopback_x550em(struct ixgbe_hw *hw)
3052 /* Disable AN and force speed to 10G Serial. */
3053 status = hw->mac.ops.read_iosf_sb_reg(hw,
3054 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
3055 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
3056 if (status != IXGBE_SUCCESS)
3058 reg_val &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
3059 reg_val &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK;
3060 reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_10G;
3061 status = hw->mac.ops.write_iosf_sb_reg(hw,
3062 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
3063 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
3064 if (status != IXGBE_SUCCESS)
3067 /* Set near-end loopback clocks. */
3068 status = hw->mac.ops.read_iosf_sb_reg(hw,
3069 IXGBE_KRM_PORT_CAR_GEN_CTRL(hw->bus.lan_id),
3070 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
3071 if (status != IXGBE_SUCCESS)
3073 reg_val |= IXGBE_KRM_PORT_CAR_GEN_CTRL_NELB_32B;
3074 reg_val |= IXGBE_KRM_PORT_CAR_GEN_CTRL_NELB_KRPCS;
3075 status = hw->mac.ops.write_iosf_sb_reg(hw,
3076 IXGBE_KRM_PORT_CAR_GEN_CTRL(hw->bus.lan_id),
3077 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
3078 if (status != IXGBE_SUCCESS)
3081 /* Set loopback enable. */
3082 status = hw->mac.ops.read_iosf_sb_reg(hw,
3083 IXGBE_KRM_PMD_DFX_BURNIN(hw->bus.lan_id),
3084 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
3085 if (status != IXGBE_SUCCESS)
3087 reg_val |= IXGBE_KRM_PMD_DFX_BURNIN_TX_RX_KR_LB_MASK;
3088 status = hw->mac.ops.write_iosf_sb_reg(hw,
3089 IXGBE_KRM_PMD_DFX_BURNIN(hw->bus.lan_id),
3090 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
3091 if (status != IXGBE_SUCCESS)
3094 /* Training bypass. */
3095 status = hw->mac.ops.read_iosf_sb_reg(hw,
3096 IXGBE_KRM_RX_TRN_LINKUP_CTRL(hw->bus.lan_id),
3097 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
3098 if (status != IXGBE_SUCCESS)
3100 reg_val |= IXGBE_KRM_RX_TRN_LINKUP_CTRL_PROTOCOL_BYPASS;
3101 status = hw->mac.ops.write_iosf_sb_reg(hw,
3102 IXGBE_KRM_RX_TRN_LINKUP_CTRL(hw->bus.lan_id),
3103 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
3109 * ixgbe_read_ee_hostif_X550 - Read EEPROM word using a host interface command
3110 * assuming that the semaphore is already obtained.
3111 * @hw: pointer to hardware structure
3112 * @offset: offset of word in the EEPROM to read
3113 * @data: word read from the EEPROM
3115 * Reads a 16 bit word from the EEPROM using the hostif.
3117 s32 ixgbe_read_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
3121 struct ixgbe_hic_read_shadow_ram buffer;
3123 DEBUGFUNC("ixgbe_read_ee_hostif_data_X550");
3124 buffer.hdr.req.cmd = FW_READ_SHADOW_RAM_CMD;
3125 buffer.hdr.req.buf_lenh = 0;
3126 buffer.hdr.req.buf_lenl = FW_READ_SHADOW_RAM_LEN;
3127 buffer.hdr.req.checksum = FW_DEFAULT_CHECKSUM;
3129 /* convert offset from words to bytes */
3130 buffer.address = IXGBE_CPU_TO_BE32(offset * 2);
3132 buffer.length = IXGBE_CPU_TO_BE16(sizeof(u16));
3134 status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
3136 IXGBE_HI_COMMAND_TIMEOUT, false);
3141 *data = (u16)IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG,
3142 FW_NVM_DATA_OFFSET);
3148 * ixgbe_read_ee_hostif_X550 - Read EEPROM word using a host interface command
3149 * @hw: pointer to hardware structure
3150 * @offset: offset of word in the EEPROM to read
3151 * @data: word read from the EEPROM
3153 * Reads a 16 bit word from the EEPROM using the hostif.
3155 s32 ixgbe_read_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset,
3158 s32 status = IXGBE_SUCCESS;
3160 DEBUGFUNC("ixgbe_read_ee_hostif_X550");
3162 if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
3164 status = ixgbe_read_ee_hostif_data_X550(hw, offset, data);
3165 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3167 status = IXGBE_ERR_SWFW_SYNC;
3174 * ixgbe_read_ee_hostif_buffer_X550- Read EEPROM word(s) using hostif
3175 * @hw: pointer to hardware structure
3176 * @offset: offset of word in the EEPROM to read
3177 * @words: number of words
3178 * @data: word(s) read from the EEPROM
3180 * Reads a 16 bit word(s) from the EEPROM using the hostif.
3182 s32 ixgbe_read_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
3183 u16 offset, u16 words, u16 *data)
3185 struct ixgbe_hic_read_shadow_ram buffer;
3186 u32 current_word = 0;
3191 DEBUGFUNC("ixgbe_read_ee_hostif_buffer_X550");
3193 /* Take semaphore for the entire operation. */
3194 status = hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3196 DEBUGOUT("EEPROM read buffer - semaphore failed\n");
3200 if (words > FW_MAX_READ_BUFFER_SIZE / 2)
3201 words_to_read = FW_MAX_READ_BUFFER_SIZE / 2;
3203 words_to_read = words;
3205 buffer.hdr.req.cmd = FW_READ_SHADOW_RAM_CMD;
3206 buffer.hdr.req.buf_lenh = 0;
3207 buffer.hdr.req.buf_lenl = FW_READ_SHADOW_RAM_LEN;
3208 buffer.hdr.req.checksum = FW_DEFAULT_CHECKSUM;
3210 /* convert offset from words to bytes */
3211 buffer.address = IXGBE_CPU_TO_BE32((offset + current_word) * 2);
3212 buffer.length = IXGBE_CPU_TO_BE16(words_to_read * 2);
3214 status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
3216 IXGBE_HI_COMMAND_TIMEOUT,
3220 DEBUGOUT("Host interface command failed\n");
3224 for (i = 0; i < words_to_read; i++) {
3225 u32 reg = IXGBE_FLEX_MNG + (FW_NVM_DATA_OFFSET << 2) +
3227 u32 value = IXGBE_READ_REG(hw, reg);
3229 data[current_word] = (u16)(value & 0xffff);
3232 if (i < words_to_read) {
3234 data[current_word] = (u16)(value & 0xffff);
3238 words -= words_to_read;
3242 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3247 * ixgbe_write_ee_hostif_X550 - Write EEPROM word using hostif
3248 * @hw: pointer to hardware structure
3249 * @offset: offset of word in the EEPROM to write
3250 * @data: word write to the EEPROM
3252 * Write a 16 bit word to the EEPROM using the hostif.
3254 s32 ixgbe_write_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
3258 struct ixgbe_hic_write_shadow_ram buffer;
3260 DEBUGFUNC("ixgbe_write_ee_hostif_data_X550");
3262 buffer.hdr.req.cmd = FW_WRITE_SHADOW_RAM_CMD;
3263 buffer.hdr.req.buf_lenh = 0;
3264 buffer.hdr.req.buf_lenl = FW_WRITE_SHADOW_RAM_LEN;
3265 buffer.hdr.req.checksum = FW_DEFAULT_CHECKSUM;
3268 buffer.length = IXGBE_CPU_TO_BE16(sizeof(u16));
3270 buffer.address = IXGBE_CPU_TO_BE32(offset * 2);
3272 status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
3274 IXGBE_HI_COMMAND_TIMEOUT, false);
3280 * ixgbe_write_ee_hostif_X550 - Write EEPROM word using hostif
3281 * @hw: pointer to hardware structure
3282 * @offset: offset of word in the EEPROM to write
3283 * @data: word write to the EEPROM
3285 * Write a 16 bit word to the EEPROM using the hostif.
3287 s32 ixgbe_write_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset,
3290 s32 status = IXGBE_SUCCESS;
3292 DEBUGFUNC("ixgbe_write_ee_hostif_X550");
3294 if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
3296 status = ixgbe_write_ee_hostif_data_X550(hw, offset, data);
3297 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3299 DEBUGOUT("write ee hostif failed to get semaphore");
3300 status = IXGBE_ERR_SWFW_SYNC;
3307 * ixgbe_write_ee_hostif_buffer_X550 - Write EEPROM word(s) using hostif
3308 * @hw: pointer to hardware structure
3309 * @offset: offset of word in the EEPROM to write
3310 * @words: number of words
3311 * @data: word(s) write to the EEPROM
3313 * Write a 16 bit word(s) to the EEPROM using the hostif.
3315 s32 ixgbe_write_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
3316 u16 offset, u16 words, u16 *data)
3318 s32 status = IXGBE_SUCCESS;
3321 DEBUGFUNC("ixgbe_write_ee_hostif_buffer_X550");
3323 /* Take semaphore for the entire operation. */
3324 status = hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3325 if (status != IXGBE_SUCCESS) {
3326 DEBUGOUT("EEPROM write buffer - semaphore failed\n");
3330 for (i = 0; i < words; i++) {
3331 status = ixgbe_write_ee_hostif_data_X550(hw, offset + i,
3334 if (status != IXGBE_SUCCESS) {
3335 DEBUGOUT("Eeprom buffered write failed\n");
3340 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
3347 * ixgbe_checksum_ptr_x550 - Checksum one pointer region
3348 * @hw: pointer to hardware structure
3349 * @ptr: pointer offset in eeprom
3350 * @size: size of section pointed by ptr, if 0 first word will be used as size
3351 * @csum: address of checksum to update
3353 * Returns error status for any failure
3355 STATIC s32 ixgbe_checksum_ptr_x550(struct ixgbe_hw *hw, u16 ptr,
3356 u16 size, u16 *csum, u16 *buffer,
3361 u16 length, bufsz, i, start;
3364 bufsz = sizeof(buf) / sizeof(buf[0]);
3366 /* Read a chunk at the pointer location */
3368 status = ixgbe_read_ee_hostif_buffer_X550(hw, ptr, bufsz, buf);
3370 DEBUGOUT("Failed to read EEPROM image\n");
3375 if (buffer_size < ptr)
3376 return IXGBE_ERR_PARAM;
3377 local_buffer = &buffer[ptr];
3385 length = local_buffer[0];
3387 /* Skip pointer section if length is invalid. */
3388 if (length == 0xFFFF || length == 0 ||
3389 (ptr + length) >= hw->eeprom.word_size)
3390 return IXGBE_SUCCESS;
3393 if (buffer && ((u32)start + (u32)length > buffer_size))
3394 return IXGBE_ERR_PARAM;
3396 for (i = start; length; i++, length--) {
3397 if (i == bufsz && !buffer) {
3403 /* Read a chunk at the pointer location */
3404 status = ixgbe_read_ee_hostif_buffer_X550(hw, ptr,
3407 DEBUGOUT("Failed to read EEPROM image\n");
3411 *csum += local_buffer[i];
3413 return IXGBE_SUCCESS;
3417 * ixgbe_calc_checksum_X550 - Calculates and returns the checksum
3418 * @hw: pointer to hardware structure
3419 * @buffer: pointer to buffer containing calculated checksum
3420 * @buffer_size: size of buffer
3422 * Returns a negative error code on error, or the 16-bit checksum
3424 s32 ixgbe_calc_checksum_X550(struct ixgbe_hw *hw, u16 *buffer, u32 buffer_size)
3426 u16 eeprom_ptrs[IXGBE_EEPROM_LAST_WORD + 1];
3430 u16 pointer, i, size;
3432 DEBUGFUNC("ixgbe_calc_eeprom_checksum_X550");
3434 hw->eeprom.ops.init_params(hw);
3437 /* Read pointer area */
3438 status = ixgbe_read_ee_hostif_buffer_X550(hw, 0,
3439 IXGBE_EEPROM_LAST_WORD + 1,
3442 DEBUGOUT("Failed to read EEPROM image\n");
3445 local_buffer = eeprom_ptrs;
3447 if (buffer_size < IXGBE_EEPROM_LAST_WORD)
3448 return IXGBE_ERR_PARAM;
3449 local_buffer = buffer;
3453 * For X550 hardware include 0x0-0x41 in the checksum, skip the
3454 * checksum word itself
3456 for (i = 0; i <= IXGBE_EEPROM_LAST_WORD; i++)
3457 if (i != IXGBE_EEPROM_CHECKSUM)
3458 checksum += local_buffer[i];
3461 * Include all data from pointers 0x3, 0x6-0xE. This excludes the
3462 * FW, PHY module, and PCIe Expansion/Option ROM pointers.
3464 for (i = IXGBE_PCIE_ANALOG_PTR_X550; i < IXGBE_FW_PTR; i++) {
3465 if (i == IXGBE_PHY_PTR || i == IXGBE_OPTION_ROM_PTR)
3468 pointer = local_buffer[i];
3470 /* Skip pointer section if the pointer is invalid. */
3471 if (pointer == 0xFFFF || pointer == 0 ||
3472 pointer >= hw->eeprom.word_size)
3476 case IXGBE_PCIE_GENERAL_PTR:
3477 size = IXGBE_IXGBE_PCIE_GENERAL_SIZE;
3479 case IXGBE_PCIE_CONFIG0_PTR:
3480 case IXGBE_PCIE_CONFIG1_PTR:
3481 size = IXGBE_PCIE_CONFIG_SIZE;
3488 status = ixgbe_checksum_ptr_x550(hw, pointer, size, &checksum,
3489 buffer, buffer_size);
3494 checksum = (u16)IXGBE_EEPROM_SUM - checksum;
3496 return (s32)checksum;
3500 * ixgbe_calc_eeprom_checksum_X550 - Calculates and returns the checksum
3501 * @hw: pointer to hardware structure
3503 * Returns a negative error code on error, or the 16-bit checksum
3505 s32 ixgbe_calc_eeprom_checksum_X550(struct ixgbe_hw *hw)
3507 return ixgbe_calc_checksum_X550(hw, NULL, 0);
3511 * ixgbe_validate_eeprom_checksum_X550 - Validate EEPROM checksum
3512 * @hw: pointer to hardware structure
3513 * @checksum_val: calculated checksum
3515 * Performs checksum calculation and validates the EEPROM checksum. If the
3516 * caller does not need checksum_val, the value can be NULL.
3518 s32 ixgbe_validate_eeprom_checksum_X550(struct ixgbe_hw *hw, u16 *checksum_val)
3522 u16 read_checksum = 0;
3524 DEBUGFUNC("ixgbe_validate_eeprom_checksum_X550");
3526 /* Read the first word from the EEPROM. If this times out or fails, do
3527 * not continue or we could be in for a very long wait while every
3530 status = hw->eeprom.ops.read(hw, 0, &checksum);
3532 DEBUGOUT("EEPROM read failed\n");
3536 status = hw->eeprom.ops.calc_checksum(hw);
3540 checksum = (u16)(status & 0xffff);
3542 status = ixgbe_read_ee_hostif_X550(hw, IXGBE_EEPROM_CHECKSUM,
3547 /* Verify read checksum from EEPROM is the same as
3548 * calculated checksum
3550 if (read_checksum != checksum) {
3551 status = IXGBE_ERR_EEPROM_CHECKSUM;
3552 ERROR_REPORT1(IXGBE_ERROR_INVALID_STATE,
3553 "Invalid EEPROM checksum");
3556 /* If the user cares, return the calculated checksum */
3558 *checksum_val = checksum;
3564 * ixgbe_update_eeprom_checksum_X550 - Updates the EEPROM checksum and flash
3565 * @hw: pointer to hardware structure
3567 * After writing EEPROM to shadow RAM using EEWR register, software calculates
3568 * checksum and updates the EEPROM and instructs the hardware to update
3571 s32 ixgbe_update_eeprom_checksum_X550(struct ixgbe_hw *hw)
3576 DEBUGFUNC("ixgbe_update_eeprom_checksum_X550");
3578 /* Read the first word from the EEPROM. If this times out or fails, do
3579 * not continue or we could be in for a very long wait while every
3582 status = ixgbe_read_ee_hostif_X550(hw, 0, &checksum);
3584 DEBUGOUT("EEPROM read failed\n");
3588 status = ixgbe_calc_eeprom_checksum_X550(hw);
3592 checksum = (u16)(status & 0xffff);
3594 status = ixgbe_write_ee_hostif_X550(hw, IXGBE_EEPROM_CHECKSUM,
3599 status = ixgbe_update_flash_X550(hw);
3605 * ixgbe_update_flash_X550 - Instruct HW to copy EEPROM to Flash device
3606 * @hw: pointer to hardware structure
3608 * Issue a shadow RAM dump to FW to copy EEPROM from shadow RAM to the flash.
3610 s32 ixgbe_update_flash_X550(struct ixgbe_hw *hw)
3612 s32 status = IXGBE_SUCCESS;
3613 union ixgbe_hic_hdr2 buffer;
3615 DEBUGFUNC("ixgbe_update_flash_X550");
3617 buffer.req.cmd = FW_SHADOW_RAM_DUMP_CMD;
3618 buffer.req.buf_lenh = 0;
3619 buffer.req.buf_lenl = FW_SHADOW_RAM_DUMP_LEN;
3620 buffer.req.checksum = FW_DEFAULT_CHECKSUM;
3622 status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
3624 IXGBE_HI_COMMAND_TIMEOUT, false);
3630 * ixgbe_get_supported_physical_layer_X550em - Returns physical layer type
3631 * @hw: pointer to hardware structure
3633 * Determines physical layer capabilities of the current configuration.
3635 u32 ixgbe_get_supported_physical_layer_X550em(struct ixgbe_hw *hw)
3637 u32 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
3638 u16 ext_ability = 0;
3640 DEBUGFUNC("ixgbe_get_supported_physical_layer_X550em");
3642 hw->phy.ops.identify(hw);
3644 switch (hw->phy.type) {
3645 case ixgbe_phy_x550em_kr:
3646 physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KR |
3647 IXGBE_PHYSICAL_LAYER_1000BASE_KX;
3649 case ixgbe_phy_x550em_kx4:
3650 physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4 |
3651 IXGBE_PHYSICAL_LAYER_1000BASE_KX;
3653 case ixgbe_phy_x550em_ext_t:
3654 hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
3655 IXGBE_MDIO_PMA_PMD_DEV_TYPE,
3657 if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
3658 physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
3659 if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
3660 physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
3666 if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber)
3667 physical_layer = ixgbe_get_supported_phy_sfp_layer_generic(hw);
3669 return physical_layer;
3673 * ixgbe_get_bus_info_x550em - Set PCI bus info
3674 * @hw: pointer to hardware structure
3676 * Sets bus link width and speed to unknown because X550em is
3679 s32 ixgbe_get_bus_info_X550em(struct ixgbe_hw *hw)
3682 DEBUGFUNC("ixgbe_get_bus_info_x550em");
3684 hw->bus.width = ixgbe_bus_width_unknown;
3685 hw->bus.speed = ixgbe_bus_speed_unknown;
3687 hw->mac.ops.set_lan_id(hw);
3689 return IXGBE_SUCCESS;
3693 * ixgbe_disable_rx_x550 - Disable RX unit
3695 * Enables the Rx DMA unit for x550
3697 void ixgbe_disable_rx_x550(struct ixgbe_hw *hw)
3699 u32 rxctrl, pfdtxgswc;
3701 struct ixgbe_hic_disable_rxen fw_cmd;
3703 DEBUGFUNC("ixgbe_enable_rx_dma_x550");
3705 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
3706 if (rxctrl & IXGBE_RXCTRL_RXEN) {
3707 pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
3708 if (pfdtxgswc & IXGBE_PFDTXGSWC_VT_LBEN) {
3709 pfdtxgswc &= ~IXGBE_PFDTXGSWC_VT_LBEN;
3710 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc);
3711 hw->mac.set_lben = true;
3713 hw->mac.set_lben = false;
3716 fw_cmd.hdr.cmd = FW_DISABLE_RXEN_CMD;
3717 fw_cmd.hdr.buf_len = FW_DISABLE_RXEN_LEN;
3718 fw_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
3719 fw_cmd.port_number = (u8)hw->bus.lan_id;
3721 status = ixgbe_host_interface_command(hw, (u32 *)&fw_cmd,
3722 sizeof(struct ixgbe_hic_disable_rxen),
3723 IXGBE_HI_COMMAND_TIMEOUT, true);
3725 /* If we fail - disable RX using register write */
3727 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
3728 if (rxctrl & IXGBE_RXCTRL_RXEN) {
3729 rxctrl &= ~IXGBE_RXCTRL_RXEN;
3730 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl);
3737 * ixgbe_enter_lplu_x550em - Transition to low power states
3738 * @hw: pointer to hardware structure
3740 * Configures Low Power Link Up on transition to low power states
3741 * (from D0 to non-D0). Link is required to enter LPLU so avoid resetting the
3742 * X557 PHY immediately prior to entering LPLU.
3744 s32 ixgbe_enter_lplu_t_x550em(struct ixgbe_hw *hw)
3746 u16 an_10g_cntl_reg, autoneg_reg, speed;
3748 ixgbe_link_speed lcd_speed;
3752 /* SW LPLU not required on later HW revisions. */
3753 if ((hw->mac.type == ixgbe_mac_X550EM_x) &&
3754 (IXGBE_FUSES0_REV_MASK &
3755 IXGBE_READ_REG(hw, IXGBE_FUSES0_GROUP(0))))
3756 return IXGBE_SUCCESS;
3758 /* If blocked by MNG FW, then don't restart AN */
3759 if (ixgbe_check_reset_blocked(hw))
3760 return IXGBE_SUCCESS;
3762 status = ixgbe_ext_phy_t_x550em_get_link(hw, &link_up);
3763 if (status != IXGBE_SUCCESS)
3766 status = ixgbe_read_eeprom(hw, NVM_INIT_CTRL_3, &hw->eeprom.ctrl_word_3);
3768 if (status != IXGBE_SUCCESS)
3771 /* If link is down, LPLU disabled in NVM, WoL disabled, or manageability
3772 * disabled, then force link down by entering low power mode.
3774 if (!link_up || !(hw->eeprom.ctrl_word_3 & NVM_INIT_CTRL_3_LPLU) ||
3775 !(hw->wol_enabled || ixgbe_mng_present(hw)))
3776 return ixgbe_set_copper_phy_power(hw, FALSE);
3779 status = ixgbe_get_lcd_t_x550em(hw, &lcd_speed);
3781 if (status != IXGBE_SUCCESS)
3784 /* If no valid LCD link speed, then force link down and exit. */
3785 if (lcd_speed == IXGBE_LINK_SPEED_UNKNOWN)
3786 return ixgbe_set_copper_phy_power(hw, FALSE);
3788 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_VENDOR_STAT,
3789 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3792 if (status != IXGBE_SUCCESS)
3795 /* If no link now, speed is invalid so take link down */
3796 status = ixgbe_ext_phy_t_x550em_get_link(hw, &link_up);
3797 if (status != IXGBE_SUCCESS)
3798 return ixgbe_set_copper_phy_power(hw, false);
3800 /* clear everything but the speed bits */
3801 speed &= IXGBE_MDIO_AUTO_NEG_VEN_STAT_SPEED_MASK;
3803 /* If current speed is already LCD, then exit. */
3804 if (((speed == IXGBE_MDIO_AUTO_NEG_VENDOR_STATUS_1GB) &&
3805 (lcd_speed == IXGBE_LINK_SPEED_1GB_FULL)) ||
3806 ((speed == IXGBE_MDIO_AUTO_NEG_VENDOR_STATUS_10GB) &&
3807 (lcd_speed == IXGBE_LINK_SPEED_10GB_FULL)))
3810 /* Clear AN completed indication */
3811 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_VENDOR_TX_ALARM,
3812 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3815 if (status != IXGBE_SUCCESS)
3818 status = hw->phy.ops.read_reg(hw, IXGBE_MII_10GBASE_T_AUTONEG_CTRL_REG,
3819 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3822 if (status != IXGBE_SUCCESS)
3825 status = hw->phy.ops.read_reg(hw,
3826 IXGBE_MII_AUTONEG_VENDOR_PROVISION_1_REG,
3827 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3830 if (status != IXGBE_SUCCESS)
3833 save_autoneg = hw->phy.autoneg_advertised;
3835 /* Setup link at least common link speed */
3836 status = hw->mac.ops.setup_link(hw, lcd_speed, false);
3838 /* restore autoneg from before setting lplu speed */
3839 hw->phy.autoneg_advertised = save_autoneg;
3845 * ixgbe_get_lcd_x550em - Determine lowest common denominator
3846 * @hw: pointer to hardware structure
3847 * @lcd_speed: pointer to lowest common link speed
3849 * Determine lowest common link speed with link partner.
3851 s32 ixgbe_get_lcd_t_x550em(struct ixgbe_hw *hw, ixgbe_link_speed *lcd_speed)
3855 u16 word = hw->eeprom.ctrl_word_3;
3857 *lcd_speed = IXGBE_LINK_SPEED_UNKNOWN;
3859 status = hw->phy.ops.read_reg(hw, IXGBE_AUTO_NEG_LP_STATUS,
3860 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
3863 if (status != IXGBE_SUCCESS)
3866 /* If link partner advertised 1G, return 1G */
3867 if (an_lp_status & IXGBE_AUTO_NEG_LP_1000BASE_CAP) {
3868 *lcd_speed = IXGBE_LINK_SPEED_1GB_FULL;
3872 /* If 10G disabled for LPLU via NVM D10GMP, then return no valid LCD */
3873 if ((hw->bus.lan_id && (word & NVM_INIT_CTRL_3_D10GMP_PORT1)) ||
3874 (word & NVM_INIT_CTRL_3_D10GMP_PORT0))
3877 /* Link partner not capable of lower speeds, return 10G */
3878 *lcd_speed = IXGBE_LINK_SPEED_10GB_FULL;
3883 * ixgbe_setup_fc_X550em - Set up flow control
3884 * @hw: pointer to hardware structure
3886 * Called at init time to set up flow control.
3888 s32 ixgbe_setup_fc_X550em(struct ixgbe_hw *hw)
3890 s32 ret_val = IXGBE_SUCCESS;
3891 u32 pause, asm_dir, reg_val;
3893 DEBUGFUNC("ixgbe_setup_fc_X550em");
3895 /* Validate the requested mode */
3896 if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
3897 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
3898 "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
3899 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
3903 /* 10gig parts do not have a word in the EEPROM to determine the
3904 * default flow control setting, so we explicitly set it to full.
3906 if (hw->fc.requested_mode == ixgbe_fc_default)
3907 hw->fc.requested_mode = ixgbe_fc_full;
3909 /* Determine PAUSE and ASM_DIR bits. */
3910 switch (hw->fc.requested_mode) {
3915 case ixgbe_fc_tx_pause:
3919 case ixgbe_fc_rx_pause:
3920 /* Rx Flow control is enabled and Tx Flow control is
3921 * disabled by software override. Since there really
3922 * isn't a way to advertise that we are capable of RX
3923 * Pause ONLY, we will advertise that we support both
3924 * symmetric and asymmetric Rx PAUSE, as such we fall
3925 * through to the fc_full statement. Later, we will
3926 * disable the adapter's ability to send PAUSE frames.
3933 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT,
3934 "Flow control param set incorrectly\n");
3935 ret_val = IXGBE_ERR_CONFIG;
3939 switch (hw->device_id) {
3940 case IXGBE_DEV_ID_X550EM_X_KR:
3941 case IXGBE_DEV_ID_X550EM_A_KR:
3942 case IXGBE_DEV_ID_X550EM_A_KR_L:
3943 ret_val = hw->mac.ops.read_iosf_sb_reg(hw,
3944 IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
3945 IXGBE_SB_IOSF_TARGET_KR_PHY, ®_val);
3946 if (ret_val != IXGBE_SUCCESS)
3948 reg_val &= ~(IXGBE_KRM_AN_CNTL_1_SYM_PAUSE |
3949 IXGBE_KRM_AN_CNTL_1_ASM_PAUSE);
3951 reg_val |= IXGBE_KRM_AN_CNTL_1_SYM_PAUSE;
3953 reg_val |= IXGBE_KRM_AN_CNTL_1_ASM_PAUSE;
3954 ret_val = hw->mac.ops.write_iosf_sb_reg(hw,
3955 IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
3956 IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
3958 /* This device does not fully support AN. */
3959 hw->fc.disable_fc_autoneg = true;
3970 * ixgbe_fc_autoneg_backplane_x550em_a - Enable flow control IEEE clause 37
3971 * @hw: pointer to hardware structure
3973 * Enable flow control according to IEEE clause 37.
3975 void ixgbe_fc_autoneg_backplane_x550em_a(struct ixgbe_hw *hw)
3977 u32 link_s1, lp_an_page_low, an_cntl_1;
3978 s32 status = IXGBE_ERR_FC_NOT_NEGOTIATED;
3979 ixgbe_link_speed speed;
3982 /* AN should have completed when the cable was plugged in.
3983 * Look for reasons to bail out. Bail out if:
3984 * - FC autoneg is disabled, or if
3987 if (hw->fc.disable_fc_autoneg) {
3988 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
3989 "Flow control autoneg is disabled");
3993 hw->mac.ops.check_link(hw, &speed, &link_up, false);
3995 ERROR_REPORT1(IXGBE_ERROR_SOFTWARE, "The link is down");
3999 /* Check at auto-negotiation has completed */
4000 status = hw->mac.ops.read_iosf_sb_reg(hw,
4001 IXGBE_KRM_LINK_S1(hw->bus.lan_id),
4002 IXGBE_SB_IOSF_TARGET_KR_PHY, &link_s1);
4004 if (status != IXGBE_SUCCESS ||
4005 (link_s1 & IXGBE_KRM_LINK_S1_MAC_AN_COMPLETE) == 0) {
4006 DEBUGOUT("Auto-Negotiation did not complete\n");
4007 status = IXGBE_ERR_FC_NOT_NEGOTIATED;
4011 /* Read the 10g AN autoc and LP ability registers and resolve
4012 * local flow control settings accordingly
4014 status = hw->mac.ops.read_iosf_sb_reg(hw,
4015 IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
4016 IXGBE_SB_IOSF_TARGET_KR_PHY, &an_cntl_1);
4018 if (status != IXGBE_SUCCESS) {
4019 DEBUGOUT("Auto-Negotiation did not complete\n");
4023 status = hw->mac.ops.read_iosf_sb_reg(hw,
4024 IXGBE_KRM_LP_BASE_PAGE_HIGH(hw->bus.lan_id),
4025 IXGBE_SB_IOSF_TARGET_KR_PHY, &lp_an_page_low);
4027 if (status != IXGBE_SUCCESS) {
4028 DEBUGOUT("Auto-Negotiation did not complete\n");
4032 status = ixgbe_negotiate_fc(hw, an_cntl_1, lp_an_page_low,
4033 IXGBE_KRM_AN_CNTL_1_SYM_PAUSE,
4034 IXGBE_KRM_AN_CNTL_1_ASM_PAUSE,
4035 IXGBE_KRM_LP_BASE_PAGE_HIGH_SYM_PAUSE,
4036 IXGBE_KRM_LP_BASE_PAGE_HIGH_ASM_PAUSE);
4039 if (status == IXGBE_SUCCESS) {
4040 hw->fc.fc_was_autonegged = true;
4042 hw->fc.fc_was_autonegged = false;
4043 hw->fc.current_mode = hw->fc.requested_mode;
4048 * ixgbe_fc_autoneg_fiber_x550em_a - Enable flow control IEEE clause 37
4049 * @hw: pointer to hardware structure
4051 * Enable flow control according to IEEE clause 37.
4053 void ixgbe_fc_autoneg_fiber_x550em_a(struct ixgbe_hw *hw)
4055 u32 link_s1, pcs_an_lp, pcs_an;
4056 s32 status = IXGBE_ERR_FC_NOT_NEGOTIATED;
4057 ixgbe_link_speed speed;
4060 /* AN should have completed when the cable was plugged in.
4061 * Look for reasons to bail out. Bail out if:
4062 * - FC autoneg is disabled, or if
4065 if (hw->fc.disable_fc_autoneg) {
4066 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
4067 "Flow control autoneg is disabled");
4071 hw->mac.ops.check_link(hw, &speed, &link_up, false);
4073 ERROR_REPORT1(IXGBE_ERROR_SOFTWARE, "The link is down");
4077 /* Check if auto-negotiation has completed */
4078 status = hw->mac.ops.read_iosf_sb_reg(hw,
4079 IXGBE_KRM_LINK_S1(hw->bus.lan_id),
4080 IXGBE_SB_IOSF_TARGET_KR_PHY, &link_s1);
4082 if (status != IXGBE_SUCCESS ||
4083 (link_s1 & IXGBE_KRM_LINK_S1_MAC_AN_COMPLETE) == 0) {
4084 DEBUGOUT("Auto-Negotiation did not complete\n");
4085 status = IXGBE_ERR_FC_NOT_NEGOTIATED;
4089 /* Determine advertised flow control */
4090 status = hw->mac.ops.read_iosf_sb_reg(hw,
4091 IXGBE_KRM_PCS_KX_AN(hw->bus.lan_id),
4092 IXGBE_SB_IOSF_TARGET_KR_PHY, &pcs_an);
4094 if (status != IXGBE_SUCCESS) {
4095 DEBUGOUT("Auto-Negotiation did not complete\n");
4099 /* Determine link parter flow control */
4100 status = hw->mac.ops.read_iosf_sb_reg(hw,
4101 IXGBE_KRM_PCS_KX_AN_LP(hw->bus.lan_id),
4102 IXGBE_SB_IOSF_TARGET_KR_PHY, &pcs_an_lp);
4104 if (status != IXGBE_SUCCESS) {
4105 DEBUGOUT("Auto-Negotiation did not complete\n");
4109 status = ixgbe_negotiate_fc(hw, pcs_an, pcs_an_lp,
4110 IXGBE_KRM_PCS_KX_AN_SYM_PAUSE,
4111 IXGBE_KRM_PCS_KX_AN_ASM_PAUSE,
4112 IXGBE_KRM_PCS_KX_AN_LP_SYM_PAUSE,
4113 IXGBE_KRM_PCS_KX_AN_LP_ASM_PAUSE);
4116 if (status == IXGBE_SUCCESS) {
4117 hw->fc.fc_was_autonegged = true;
4119 hw->fc.fc_was_autonegged = false;
4120 hw->fc.current_mode = hw->fc.requested_mode;
4125 * ixgbe_setup_fc_backplane_x550em_a - Set up flow control
4126 * @hw: pointer to hardware structure
4128 * Called at init time to set up flow control.
4130 s32 ixgbe_setup_fc_backplane_x550em_a(struct ixgbe_hw *hw)
4132 s32 status = IXGBE_SUCCESS;
4133 u32 an_cntl, link_ctrl = 0;
4135 DEBUGFUNC("ixgbe_setup_fc_backplane_x550em_a");
4137 /* Validate the requested mode */
4138 if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
4139 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
4140 "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
4141 return IXGBE_ERR_INVALID_LINK_SETTINGS;
4144 if (hw->fc.requested_mode == ixgbe_fc_default)
4145 hw->fc.requested_mode = ixgbe_fc_full;
4147 /* Set up the 1G and 10G flow control advertisement registers so the
4148 * HW will be able to do FC autoneg once the cable is plugged in. If
4149 * we link at 10G, the 1G advertisement is harmless and vice versa.
4151 status = hw->mac.ops.read_iosf_sb_reg(hw,
4152 IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
4153 IXGBE_SB_IOSF_TARGET_KR_PHY, &an_cntl);
4155 if (status != IXGBE_SUCCESS) {
4156 DEBUGOUT("Auto-Negotiation did not complete\n");
4160 /* The possible values of fc.requested_mode are:
4161 * 0: Flow control is completely disabled
4162 * 1: Rx flow control is enabled (we can receive pause frames,
4163 * but not send pause frames).
4164 * 2: Tx flow control is enabled (we can send pause frames but
4165 * we do not support receiving pause frames).
4166 * 3: Both Rx and Tx flow control (symmetric) are enabled.
4169 switch (hw->fc.requested_mode) {
4171 /* Flow control completely disabled by software override. */
4172 an_cntl &= ~(IXGBE_KRM_AN_CNTL_1_SYM_PAUSE |
4173 IXGBE_KRM_AN_CNTL_1_ASM_PAUSE);
4175 case ixgbe_fc_tx_pause:
4176 /* Tx Flow control is enabled, and Rx Flow control is
4177 * disabled by software override.
4179 an_cntl |= IXGBE_KRM_AN_CNTL_1_ASM_PAUSE;
4180 an_cntl &= ~IXGBE_KRM_AN_CNTL_1_SYM_PAUSE;
4182 case ixgbe_fc_rx_pause:
4183 /* Rx Flow control is enabled and Tx Flow control is
4184 * disabled by software override. Since there really
4185 * isn't a way to advertise that we are capable of RX
4186 * Pause ONLY, we will advertise that we support both
4187 * symmetric and asymmetric Rx PAUSE, as such we fall
4188 * through to the fc_full statement. Later, we will
4189 * disable the adapter's ability to send PAUSE frames.
4192 /* Flow control (both Rx and Tx) is enabled by SW override. */
4193 an_cntl |= IXGBE_KRM_AN_CNTL_1_SYM_PAUSE |
4194 IXGBE_KRM_AN_CNTL_1_ASM_PAUSE;
4197 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT,
4198 "Flow control param set incorrectly\n");
4199 return IXGBE_ERR_CONFIG;
4202 status = hw->mac.ops.write_iosf_sb_reg(hw,
4203 IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
4204 IXGBE_SB_IOSF_TARGET_KR_PHY, an_cntl);
4206 /* Restart auto-negotiation. */
4207 status = hw->mac.ops.read_iosf_sb_reg(hw,
4208 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4209 IXGBE_SB_IOSF_TARGET_KR_PHY, &link_ctrl);
4211 if (status != IXGBE_SUCCESS) {
4212 DEBUGOUT("Auto-Negotiation did not complete\n");
4216 link_ctrl |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
4217 status = hw->mac.ops.write_iosf_sb_reg(hw,
4218 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4219 IXGBE_SB_IOSF_TARGET_KR_PHY, link_ctrl);
4225 * ixgbe_setup_fc_fiber_x550em_a - Set up flow control
4226 * @hw: pointer to hardware structure
4228 * Called at init time to set up flow control.
4230 s32 ixgbe_setup_fc_fiber_x550em_a(struct ixgbe_hw *hw)
4232 struct ixgbe_mac_info *mac = &hw->mac;
4233 s32 rc = IXGBE_SUCCESS;
4234 u32 an_cntl4, lctrl, pcs_an;
4236 DEBUGFUNC("ixgbe_setup_fc_fiber_x550em_a");
4238 /* Validate the requested mode */
4239 if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
4240 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
4241 "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
4242 return IXGBE_ERR_INVALID_LINK_SETTINGS;
4245 /* Enable clause 37 auto-negotiation in KRM_LINK_CTRL_1 */
4246 if (hw->fc.requested_mode == ixgbe_fc_default)
4247 hw->fc.requested_mode = ixgbe_fc_full;
4249 rc = mac->ops.read_iosf_sb_reg(hw,
4250 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4251 IXGBE_SB_IOSF_TARGET_KR_PHY, &lctrl);
4255 lctrl |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
4256 lctrl |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CLAUSE_37_EN;
4258 rc = mac->ops.write_iosf_sb_reg(hw,
4259 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4260 IXGBE_SB_IOSF_TARGET_KR_PHY, lctrl);
4264 /* Enable clause 37 over 73 in KRM_AN_CNTL_4 */
4265 rc = mac->ops.read_iosf_sb_reg(hw,
4266 IXGBE_KRM_AN_CNTL_4(hw->bus.lan_id),
4267 IXGBE_SB_IOSF_TARGET_KR_PHY, &an_cntl4);
4271 an_cntl4 |= IXGBE_KRM_AN_CNTL_4_ECSR_AN37_OVER_73;
4273 rc = mac->ops.write_iosf_sb_reg(hw,
4274 IXGBE_KRM_AN_CNTL_4(hw->bus.lan_id),
4275 IXGBE_SB_IOSF_TARGET_KR_PHY, an_cntl4);
4279 rc = hw->mac.ops.read_iosf_sb_reg(hw,
4280 IXGBE_KRM_PCS_KX_AN(hw->bus.lan_id),
4281 IXGBE_SB_IOSF_TARGET_KR_PHY, &pcs_an);
4286 /* The possible values of fc.requested_mode are:
4287 * 0: Flow control is completely disabled
4288 * 1: Rx flow control is enabled (we can receive pause frames,
4289 * but not send pause frames).
4290 * 2: Tx flow control is enabled (we can send pause frames but
4291 * we do not support receiving pause frames).
4292 * 3: Both Rx and Tx flow control (symmetric) are enabled.
4295 switch (hw->fc.requested_mode) {
4297 /* Flow control completely disabled by software override. */
4298 pcs_an &= ~(IXGBE_KRM_AN_CNTL_1_SYM_PAUSE |
4299 IXGBE_KRM_AN_CNTL_1_ASM_PAUSE);
4301 case ixgbe_fc_tx_pause:
4302 /* Tx Flow control is enabled, and Rx Flow control is
4303 * disabled by software override.
4305 pcs_an |= IXGBE_KRM_PCS_KX_AN_ASM_PAUSE;
4306 pcs_an &= ~IXGBE_KRM_PCS_KX_AN_SYM_PAUSE;
4308 case ixgbe_fc_rx_pause:
4309 /* Rx Flow control is enabled and Tx Flow control is
4310 * disabled by software override. Since there really
4311 * isn't a way to advertise that we are capable of RX
4312 * Pause ONLY, we will advertise that we support both
4313 * symmetric and asymmetric Rx PAUSE, as such we fall
4314 * through to the fc_full statement. Later, we will
4315 * disable the adapter's ability to send PAUSE frames.
4318 /* Flow control (both Rx and Tx) is enabled by SW override. */
4319 pcs_an |= IXGBE_KRM_PCS_KX_AN_SYM_PAUSE |
4320 IXGBE_KRM_PCS_KX_AN_ASM_PAUSE;
4323 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT,
4324 "Flow control param set incorrectly\n");
4325 return IXGBE_ERR_CONFIG;
4328 rc = hw->mac.ops.write_iosf_sb_reg(hw,
4329 IXGBE_KRM_PCS_KX_AN(hw->bus.lan_id),
4330 IXGBE_SB_IOSF_TARGET_KR_PHY, pcs_an);
4332 /* Restart auto-negotiation. */
4333 rc = hw->mac.ops.read_iosf_sb_reg(hw,
4334 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4335 IXGBE_SB_IOSF_TARGET_KR_PHY, &lctrl);
4338 DEBUGOUT("Auto-Negotiation did not complete\n");
4342 lctrl |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
4343 rc = hw->mac.ops.write_iosf_sb_reg(hw,
4344 IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
4345 IXGBE_SB_IOSF_TARGET_KR_PHY, lctrl);
4351 * ixgbe_set_mux - Set mux for port 1 access with CS4227
4352 * @hw: pointer to hardware structure
4353 * @state: set mux if 1, clear if 0
4355 STATIC void ixgbe_set_mux(struct ixgbe_hw *hw, u8 state)
4359 if (!hw->bus.lan_id)
4361 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
4363 esdp |= IXGBE_ESDP_SDP1;
4365 esdp &= ~IXGBE_ESDP_SDP1;
4366 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
4367 IXGBE_WRITE_FLUSH(hw);
4371 * ixgbe_acquire_swfw_sync_X550em - Acquire SWFW semaphore
4372 * @hw: pointer to hardware structure
4373 * @mask: Mask to specify which semaphore to acquire
4375 * Acquires the SWFW semaphore and sets the I2C MUX
4377 s32 ixgbe_acquire_swfw_sync_X550em(struct ixgbe_hw *hw, u32 mask)
4381 DEBUGFUNC("ixgbe_acquire_swfw_sync_X550em");
4383 status = ixgbe_acquire_swfw_sync_X540(hw, mask);
4387 if (mask & IXGBE_GSSR_I2C_MASK)
4388 ixgbe_set_mux(hw, 1);
4390 return IXGBE_SUCCESS;
4394 * ixgbe_release_swfw_sync_X550em - Release SWFW semaphore
4395 * @hw: pointer to hardware structure
4396 * @mask: Mask to specify which semaphore to release
4398 * Releases the SWFW semaphore and sets the I2C MUX
4400 void ixgbe_release_swfw_sync_X550em(struct ixgbe_hw *hw, u32 mask)
4402 DEBUGFUNC("ixgbe_release_swfw_sync_X550em");
4404 if (mask & IXGBE_GSSR_I2C_MASK)
4405 ixgbe_set_mux(hw, 0);
4407 ixgbe_release_swfw_sync_X540(hw, mask);
4411 * ixgbe_acquire_swfw_sync_X550a - Acquire SWFW semaphore
4412 * @hw: pointer to hardware structure
4413 * @mask: Mask to specify which semaphore to acquire
4415 * Acquires the SWFW semaphore and get the shared phy token as needed
4417 STATIC s32 ixgbe_acquire_swfw_sync_X550a(struct ixgbe_hw *hw, u32 mask)
4419 u32 hmask = mask & ~IXGBE_GSSR_TOKEN_SM;
4420 int retries = FW_PHY_TOKEN_RETRIES;
4421 s32 status = IXGBE_SUCCESS;
4423 DEBUGFUNC("ixgbe_acquire_swfw_sync_X550a");
4426 status = IXGBE_SUCCESS;
4428 status = ixgbe_acquire_swfw_sync_X540(hw, hmask);
4431 if (!(mask & IXGBE_GSSR_TOKEN_SM))
4432 return IXGBE_SUCCESS;
4434 status = ixgbe_get_phy_token(hw);
4435 if (status == IXGBE_SUCCESS)
4436 return IXGBE_SUCCESS;
4439 ixgbe_release_swfw_sync_X540(hw, hmask);
4440 if (status != IXGBE_ERR_TOKEN_RETRY)
4442 msec_delay(FW_PHY_TOKEN_DELAY);
4449 * ixgbe_release_swfw_sync_X550a - Release SWFW semaphore
4450 * @hw: pointer to hardware structure
4451 * @mask: Mask to specify which semaphore to release
4453 * Releases the SWFW semaphore and puts the shared phy token as needed
4455 STATIC void ixgbe_release_swfw_sync_X550a(struct ixgbe_hw *hw, u32 mask)
4457 u32 hmask = mask & ~IXGBE_GSSR_TOKEN_SM;
4459 DEBUGFUNC("ixgbe_release_swfw_sync_X550a");
4461 if (mask & IXGBE_GSSR_TOKEN_SM)
4462 ixgbe_put_phy_token(hw);
4465 ixgbe_release_swfw_sync_X540(hw, hmask);
4469 * ixgbe_read_phy_reg_x550a - Reads specified PHY register
4470 * @hw: pointer to hardware structure
4471 * @reg_addr: 32 bit address of PHY register to read
4472 * @phy_data: Pointer to read data from PHY register
4474 * Reads a value from a specified PHY register using the SWFW lock and PHY
4475 * Token. The PHY Token is needed since the MDIO is shared between to MAC
4478 s32 ixgbe_read_phy_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
4479 u32 device_type, u16 *phy_data)
4482 u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
4484 DEBUGFUNC("ixgbe_read_phy_reg_x550a");
4486 if (hw->mac.ops.acquire_swfw_sync(hw, mask))
4487 return IXGBE_ERR_SWFW_SYNC;
4489 status = hw->phy.ops.read_reg_mdi(hw, reg_addr, device_type, phy_data);
4491 hw->mac.ops.release_swfw_sync(hw, mask);
4497 * ixgbe_write_phy_reg_x550a - Writes specified PHY register
4498 * @hw: pointer to hardware structure
4499 * @reg_addr: 32 bit PHY register to write
4500 * @device_type: 5 bit device type
4501 * @phy_data: Data to write to the PHY register
4503 * Writes a value to specified PHY register using the SWFW lock and PHY Token.
4504 * The PHY Token is needed since the MDIO is shared between to MAC instances.
4506 s32 ixgbe_write_phy_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
4507 u32 device_type, u16 phy_data)
4510 u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
4512 DEBUGFUNC("ixgbe_write_phy_reg_x550a");
4514 if (hw->mac.ops.acquire_swfw_sync(hw, mask) == IXGBE_SUCCESS) {
4515 status = hw->phy.ops.write_reg_mdi(hw, reg_addr, device_type,
4517 hw->mac.ops.release_swfw_sync(hw, mask);
4519 status = IXGBE_ERR_SWFW_SYNC;
4526 * ixgbe_handle_lasi_ext_t_x550em - Handle external Base T PHY interrupt
4527 * @hw: pointer to hardware structure
4529 * Handle external Base T PHY interrupt. If high temperature
4530 * failure alarm then return error, else if link status change
4531 * then setup internal/external PHY link
4533 * Return IXGBE_ERR_OVERTEMP if interrupt is high temperature
4534 * failure alarm, else return PHY access status.
4536 s32 ixgbe_handle_lasi_ext_t_x550em(struct ixgbe_hw *hw)
4541 status = ixgbe_get_lasi_ext_t_x550em(hw, &lsc);
4543 if (status != IXGBE_SUCCESS)
4547 return ixgbe_setup_internal_phy(hw);
4549 return IXGBE_SUCCESS;
4553 * ixgbe_setup_mac_link_t_X550em - Sets the auto advertised link speed
4554 * @hw: pointer to hardware structure
4555 * @speed: new link speed
4556 * @autoneg_wait_to_complete: true when waiting for completion is needed
4558 * Setup internal/external PHY link speed based on link speed, then set
4559 * external PHY auto advertised link speed.
4561 * Returns error status for any failure
4563 s32 ixgbe_setup_mac_link_t_X550em(struct ixgbe_hw *hw,
4564 ixgbe_link_speed speed,
4565 bool autoneg_wait_to_complete)
4568 ixgbe_link_speed force_speed;
4570 DEBUGFUNC("ixgbe_setup_mac_link_t_X550em");
4572 /* Setup internal/external PHY link speed to iXFI (10G), unless
4573 * only 1G is auto advertised then setup KX link.
4575 if (speed & IXGBE_LINK_SPEED_10GB_FULL)
4576 force_speed = IXGBE_LINK_SPEED_10GB_FULL;
4578 force_speed = IXGBE_LINK_SPEED_1GB_FULL;
4580 /* If internal link mode is XFI, then setup XFI internal link. */
4581 if (!(hw->phy.nw_mng_if_sel & IXGBE_NW_MNG_IF_SEL_INT_PHY_MODE)) {
4582 status = ixgbe_setup_ixfi_x550em(hw, &force_speed);
4584 if (status != IXGBE_SUCCESS)
4588 return hw->phy.ops.setup_link_speed(hw, speed, autoneg_wait_to_complete);
4592 * ixgbe_check_link_t_X550em - Determine link and speed status
4593 * @hw: pointer to hardware structure
4594 * @speed: pointer to link speed
4595 * @link_up: true when link is up
4596 * @link_up_wait_to_complete: bool used to wait for link up or not
4598 * Check that both the MAC and X557 external PHY have link.
4600 s32 ixgbe_check_link_t_X550em(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
4601 bool *link_up, bool link_up_wait_to_complete)
4606 if (hw->mac.ops.get_media_type(hw) != ixgbe_media_type_copper)
4607 return IXGBE_ERR_CONFIG;
4609 status = ixgbe_check_mac_link_generic(hw, speed, link_up,
4610 link_up_wait_to_complete);
4612 /* If check link fails or MAC link is not up, then return */
4613 if (status != IXGBE_SUCCESS || !(*link_up))
4616 /* MAC link is up, so check external PHY link.
4617 * Read this twice back to back to indicate current status.
4619 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
4620 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
4623 if (status != IXGBE_SUCCESS)
4626 status = hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
4627 IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
4630 if (status != IXGBE_SUCCESS)
4633 /* If external PHY link is not up, then indicate link not up */
4634 if (!(autoneg_status & IXGBE_MDIO_AUTO_NEG_LINK_STATUS))
4637 return IXGBE_SUCCESS;
4641 * ixgbe_reset_phy_t_X550em - Performs X557 PHY reset and enables LASI
4642 * @hw: pointer to hardware structure
4644 s32 ixgbe_reset_phy_t_X550em(struct ixgbe_hw *hw)
4648 status = ixgbe_reset_phy_generic(hw);
4650 if (status != IXGBE_SUCCESS)
4653 /* Configure Link Status Alarm and Temperature Threshold interrupts */
4654 return ixgbe_enable_lasi_ext_t_x550em(hw);
4658 * ixgbe_led_on_t_X550em - Turns on the software controllable LEDs.
4659 * @hw: pointer to hardware structure
4660 * @led_idx: led number to turn on
4662 s32 ixgbe_led_on_t_X550em(struct ixgbe_hw *hw, u32 led_idx)
4666 DEBUGFUNC("ixgbe_led_on_t_X550em");
4668 if (led_idx >= IXGBE_X557_MAX_LED_INDEX)
4669 return IXGBE_ERR_PARAM;
4671 /* To turn on the LED, set mode to ON. */
4672 ixgbe_read_phy_reg(hw, IXGBE_X557_LED_PROVISIONING + led_idx,
4673 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, &phy_data);
4674 phy_data |= IXGBE_X557_LED_MANUAL_SET_MASK;
4675 ixgbe_write_phy_reg(hw, IXGBE_X557_LED_PROVISIONING + led_idx,
4676 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, phy_data);
4678 return IXGBE_SUCCESS;
4682 * ixgbe_led_off_t_X550em - Turns off the software controllable LEDs.
4683 * @hw: pointer to hardware structure
4684 * @led_idx: led number to turn off
4686 s32 ixgbe_led_off_t_X550em(struct ixgbe_hw *hw, u32 led_idx)
4690 DEBUGFUNC("ixgbe_led_off_t_X550em");
4692 if (led_idx >= IXGBE_X557_MAX_LED_INDEX)
4693 return IXGBE_ERR_PARAM;
4695 /* To turn on the LED, set mode to ON. */
4696 ixgbe_read_phy_reg(hw, IXGBE_X557_LED_PROVISIONING + led_idx,
4697 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, &phy_data);
4698 phy_data &= ~IXGBE_X557_LED_MANUAL_SET_MASK;
4699 ixgbe_write_phy_reg(hw, IXGBE_X557_LED_PROVISIONING + led_idx,
4700 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, phy_data);
4702 return IXGBE_SUCCESS;