1 /******************************************************************************
2
3 Copyright (c) 2001-2016, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
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.
15
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.
19
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.
31
32 ******************************************************************************/
33 /*$FreeBSD$*/
34
35 /*
36 * 82575EB Gigabit Network Connection
37 * 82575EB Gigabit Backplane Connection
38 * 82575GB Gigabit Network Connection
39 * 82576 Gigabit Network Connection
40 * 82576 Quad Port Gigabit Mezzanine Adapter
41 * 82580 Gigabit Network Connection
42 * I350 Gigabit Network Connection
43 */
44
45 #include "e1000_api.h"
46 #include "e1000_i210.h"
47
48 static s32 e1000_init_phy_params_82575(struct e1000_hw *hw);
49 static s32 e1000_init_mac_params_82575(struct e1000_hw *hw);
50 static s32 e1000_acquire_phy_82575(struct e1000_hw *hw);
51 static void e1000_release_phy_82575(struct e1000_hw *hw);
52 static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw);
53 static void e1000_release_nvm_82575(struct e1000_hw *hw);
54 static s32 e1000_check_for_link_82575(struct e1000_hw *hw);
55 static s32 e1000_check_for_link_media_swap(struct e1000_hw *hw);
56 static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw);
57 static s32 e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
58 u16 *duplex);
59 static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw);
60 static s32 e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
61 u16 *data);
62 static s32 e1000_reset_hw_82575(struct e1000_hw *hw);
63 static s32 e1000_reset_hw_82580(struct e1000_hw *hw);
64 static s32 e1000_read_phy_reg_82580(struct e1000_hw *hw,
65 u32 offset, u16 *data);
66 static s32 e1000_write_phy_reg_82580(struct e1000_hw *hw,
67 u32 offset, u16 data);
68 static s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw,
69 bool active);
70 static s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw,
71 bool active);
72 static s32 e1000_set_d0_lplu_state_82575(struct e1000_hw *hw,
73 bool active);
74 static s32 e1000_setup_copper_link_82575(struct e1000_hw *hw);
75 static s32 e1000_setup_serdes_link_82575(struct e1000_hw *hw);
76 static s32 e1000_get_media_type_82575(struct e1000_hw *hw);
77 static s32 e1000_set_sfp_media_type_82575(struct e1000_hw *hw);
78 static s32 e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data);
79 static s32 e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw,
80 u32 offset, u16 data);
81 static void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw);
82 static s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
83 static s32 e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
84 u16 *speed, u16 *duplex);
85 static s32 e1000_get_phy_id_82575(struct e1000_hw *hw);
86 static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
87 static bool e1000_sgmii_active_82575(struct e1000_hw *hw);
88 static s32 e1000_reset_init_script_82575(struct e1000_hw *hw);
89 static s32 e1000_read_mac_addr_82575(struct e1000_hw *hw);
90 static void e1000_config_collision_dist_82575(struct e1000_hw *hw);
91 static void e1000_power_down_phy_copper_82575(struct e1000_hw *hw);
92 static void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw);
93 static void e1000_power_up_serdes_link_82575(struct e1000_hw *hw);
94 static s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw);
95 static s32 e1000_reset_mdicnfg_82580(struct e1000_hw *hw);
96 static s32 e1000_validate_nvm_checksum_82580(struct e1000_hw *hw);
97 static s32 e1000_update_nvm_checksum_82580(struct e1000_hw *hw);
98 static s32 e1000_update_nvm_checksum_with_offset(struct e1000_hw *hw,
99 u16 offset);
100 static s32 e1000_validate_nvm_checksum_with_offset(struct e1000_hw *hw,
101 u16 offset);
102 static s32 e1000_validate_nvm_checksum_i350(struct e1000_hw *hw);
103 static s32 e1000_update_nvm_checksum_i350(struct e1000_hw *hw);
104 static void e1000_clear_vfta_i350(struct e1000_hw *hw);
105
106 static void e1000_i2c_start(struct e1000_hw *hw);
107 static void e1000_i2c_stop(struct e1000_hw *hw);
108 static s32 e1000_clock_in_i2c_byte(struct e1000_hw *hw, u8 *data);
109 static s32 e1000_clock_out_i2c_byte(struct e1000_hw *hw, u8 data);
110 static s32 e1000_get_i2c_ack(struct e1000_hw *hw);
111 static s32 e1000_clock_in_i2c_bit(struct e1000_hw *hw, bool *data);
112 static s32 e1000_clock_out_i2c_bit(struct e1000_hw *hw, bool data);
113 static void e1000_raise_i2c_clk(struct e1000_hw *hw, u32 *i2cctl);
114 static void e1000_lower_i2c_clk(struct e1000_hw *hw, u32 *i2cctl);
115 static s32 e1000_set_i2c_data(struct e1000_hw *hw, u32 *i2cctl, bool data);
116 static bool e1000_get_i2c_data(u32 *i2cctl);
117
118 static const u16 e1000_82580_rxpbs_table[] = {
119 36, 72, 144, 1, 2, 4, 8, 16, 35, 70, 140 };
120 #define E1000_82580_RXPBS_TABLE_SIZE \
121 (sizeof(e1000_82580_rxpbs_table) / \
122 sizeof(e1000_82580_rxpbs_table[0]))
123
124
125 /**
126 * e1000_sgmii_uses_mdio_82575 - Determine if I2C pins are for external MDIO
127 * @hw: pointer to the HW structure
128 *
129 * Called to determine if the I2C pins are being used for I2C or as an
130 * external MDIO interface since the two options are mutually exclusive.
131 **/
e1000_sgmii_uses_mdio_82575(struct e1000_hw * hw)132 static bool e1000_sgmii_uses_mdio_82575(struct e1000_hw *hw)
133 {
134 u32 reg = 0;
135 bool ext_mdio = FALSE;
136
137 DEBUGFUNC("e1000_sgmii_uses_mdio_82575");
138
139 switch (hw->mac.type) {
140 case e1000_82575:
141 case e1000_82576:
142 reg = E1000_READ_REG(hw, E1000_MDIC);
143 ext_mdio = !!(reg & E1000_MDIC_DEST);
144 break;
145 case e1000_82580:
146 case e1000_i350:
147 case e1000_i354:
148 case e1000_i210:
149 case e1000_i211:
150 reg = E1000_READ_REG(hw, E1000_MDICNFG);
151 ext_mdio = !!(reg & E1000_MDICNFG_EXT_MDIO);
152 break;
153 default:
154 break;
155 }
156 return ext_mdio;
157 }
158
159 /**
160 * e1000_init_phy_params_82575 - Init PHY func ptrs.
161 * @hw: pointer to the HW structure
162 **/
e1000_init_phy_params_82575(struct e1000_hw * hw)163 static s32 e1000_init_phy_params_82575(struct e1000_hw *hw)
164 {
165 struct e1000_phy_info *phy = &hw->phy;
166 s32 ret_val = E1000_SUCCESS;
167 u32 ctrl_ext;
168
169 DEBUGFUNC("e1000_init_phy_params_82575");
170
171 phy->ops.read_i2c_byte = e1000_read_i2c_byte_generic;
172 phy->ops.write_i2c_byte = e1000_write_i2c_byte_generic;
173
174 if (hw->phy.media_type != e1000_media_type_copper) {
175 phy->type = e1000_phy_none;
176 goto out;
177 }
178
179 phy->ops.power_up = e1000_power_up_phy_copper;
180 phy->ops.power_down = e1000_power_down_phy_copper_82575;
181
182 phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
183 phy->reset_delay_us = 100;
184
185 phy->ops.acquire = e1000_acquire_phy_82575;
186 phy->ops.check_reset_block = e1000_check_reset_block_generic;
187 phy->ops.commit = e1000_phy_sw_reset_generic;
188 phy->ops.get_cfg_done = e1000_get_cfg_done_82575;
189 phy->ops.release = e1000_release_phy_82575;
190
191 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
192
193 if (e1000_sgmii_active_82575(hw)) {
194 phy->ops.reset = e1000_phy_hw_reset_sgmii_82575;
195 ctrl_ext |= E1000_CTRL_I2C_ENA;
196 } else {
197 phy->ops.reset = e1000_phy_hw_reset_generic;
198 ctrl_ext &= ~E1000_CTRL_I2C_ENA;
199 }
200
201 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
202 e1000_reset_mdicnfg_82580(hw);
203
204 if (e1000_sgmii_active_82575(hw) && !e1000_sgmii_uses_mdio_82575(hw)) {
205 phy->ops.read_reg = e1000_read_phy_reg_sgmii_82575;
206 phy->ops.write_reg = e1000_write_phy_reg_sgmii_82575;
207 } else {
208 switch (hw->mac.type) {
209 case e1000_82580:
210 case e1000_i350:
211 case e1000_i354:
212 phy->ops.read_reg = e1000_read_phy_reg_82580;
213 phy->ops.write_reg = e1000_write_phy_reg_82580;
214 break;
215 case e1000_i210:
216 case e1000_i211:
217 phy->ops.read_reg = e1000_read_phy_reg_gs40g;
218 phy->ops.write_reg = e1000_write_phy_reg_gs40g;
219 break;
220 default:
221 phy->ops.read_reg = e1000_read_phy_reg_igp;
222 phy->ops.write_reg = e1000_write_phy_reg_igp;
223 }
224 }
225
226 /* Set phy->phy_addr and phy->id. */
227 ret_val = e1000_get_phy_id_82575(hw);
228
229 /* Verify phy id and set remaining function pointers */
230 switch (phy->id) {
231 case M88E1543_E_PHY_ID:
232 case M88E1512_E_PHY_ID:
233 case I347AT4_E_PHY_ID:
234 case M88E1112_E_PHY_ID:
235 case M88E1340M_E_PHY_ID:
236 case M88E1111_I_PHY_ID:
237 phy->type = e1000_phy_m88;
238 phy->ops.check_polarity = e1000_check_polarity_m88;
239 phy->ops.get_info = e1000_get_phy_info_m88;
240 if (phy->id == I347AT4_E_PHY_ID ||
241 phy->id == M88E1112_E_PHY_ID ||
242 phy->id == M88E1340M_E_PHY_ID)
243 phy->ops.get_cable_length =
244 e1000_get_cable_length_m88_gen2;
245 else if (phy->id == M88E1543_E_PHY_ID ||
246 phy->id == M88E1512_E_PHY_ID)
247 phy->ops.get_cable_length =
248 e1000_get_cable_length_m88_gen2;
249 else
250 phy->ops.get_cable_length = e1000_get_cable_length_m88;
251 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
252 /* Check if this PHY is confgured for media swap. */
253 if (phy->id == M88E1112_E_PHY_ID) {
254 u16 data;
255
256 ret_val = phy->ops.write_reg(hw,
257 E1000_M88E1112_PAGE_ADDR,
258 2);
259 if (ret_val)
260 goto out;
261
262 ret_val = phy->ops.read_reg(hw,
263 E1000_M88E1112_MAC_CTRL_1,
264 &data);
265 if (ret_val)
266 goto out;
267
268 data = (data & E1000_M88E1112_MAC_CTRL_1_MODE_MASK) >>
269 E1000_M88E1112_MAC_CTRL_1_MODE_SHIFT;
270 if (data == E1000_M88E1112_AUTO_COPPER_SGMII ||
271 data == E1000_M88E1112_AUTO_COPPER_BASEX)
272 hw->mac.ops.check_for_link =
273 e1000_check_for_link_media_swap;
274 }
275 if (phy->id == M88E1512_E_PHY_ID) {
276 ret_val = e1000_initialize_M88E1512_phy(hw);
277 if (ret_val)
278 goto out;
279 }
280 if (phy->id == M88E1543_E_PHY_ID) {
281 ret_val = e1000_initialize_M88E1543_phy(hw);
282 if (ret_val)
283 goto out;
284 }
285 break;
286 case IGP03E1000_E_PHY_ID:
287 case IGP04E1000_E_PHY_ID:
288 phy->type = e1000_phy_igp_3;
289 phy->ops.check_polarity = e1000_check_polarity_igp;
290 phy->ops.get_info = e1000_get_phy_info_igp;
291 phy->ops.get_cable_length = e1000_get_cable_length_igp_2;
292 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_igp;
293 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82575;
294 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_generic;
295 break;
296 case I82580_I_PHY_ID:
297 case I350_I_PHY_ID:
298 phy->type = e1000_phy_82580;
299 phy->ops.check_polarity = e1000_check_polarity_82577;
300 phy->ops.force_speed_duplex =
301 e1000_phy_force_speed_duplex_82577;
302 phy->ops.get_cable_length = e1000_get_cable_length_82577;
303 phy->ops.get_info = e1000_get_phy_info_82577;
304 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82580;
305 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_82580;
306 break;
307 case I210_I_PHY_ID:
308 phy->type = e1000_phy_i210;
309 phy->ops.check_polarity = e1000_check_polarity_m88;
310 phy->ops.get_info = e1000_get_phy_info_m88;
311 phy->ops.get_cable_length = e1000_get_cable_length_m88_gen2;
312 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82580;
313 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_82580;
314 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
315 break;
316 default:
317 ret_val = -E1000_ERR_PHY;
318 goto out;
319 }
320
321 out:
322 return ret_val;
323 }
324
325 /**
326 * e1000_init_nvm_params_82575 - Init NVM func ptrs.
327 * @hw: pointer to the HW structure
328 **/
e1000_init_nvm_params_82575(struct e1000_hw * hw)329 s32 e1000_init_nvm_params_82575(struct e1000_hw *hw)
330 {
331 struct e1000_nvm_info *nvm = &hw->nvm;
332 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
333 u16 size;
334
335 DEBUGFUNC("e1000_init_nvm_params_82575");
336
337 size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
338 E1000_EECD_SIZE_EX_SHIFT);
339 /*
340 * Added to a constant, "size" becomes the left-shift value
341 * for setting word_size.
342 */
343 size += NVM_WORD_SIZE_BASE_SHIFT;
344
345 /* Just in case size is out of range, cap it to the largest
346 * EEPROM size supported
347 */
348 if (size > 15)
349 size = 15;
350
351 nvm->word_size = 1 << size;
352 if (hw->mac.type < e1000_i210) {
353 nvm->opcode_bits = 8;
354 nvm->delay_usec = 1;
355
356 switch (nvm->override) {
357 case e1000_nvm_override_spi_large:
358 nvm->page_size = 32;
359 nvm->address_bits = 16;
360 break;
361 case e1000_nvm_override_spi_small:
362 nvm->page_size = 8;
363 nvm->address_bits = 8;
364 break;
365 default:
366 nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
367 nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ?
368 16 : 8;
369 break;
370 }
371 if (nvm->word_size == (1 << 15))
372 nvm->page_size = 128;
373
374 nvm->type = e1000_nvm_eeprom_spi;
375 } else {
376 nvm->type = e1000_nvm_flash_hw;
377 }
378
379 /* Function Pointers */
380 nvm->ops.acquire = e1000_acquire_nvm_82575;
381 nvm->ops.release = e1000_release_nvm_82575;
382 if (nvm->word_size < (1 << 15))
383 nvm->ops.read = e1000_read_nvm_eerd;
384 else
385 nvm->ops.read = e1000_read_nvm_spi;
386
387 nvm->ops.write = e1000_write_nvm_spi;
388 nvm->ops.validate = e1000_validate_nvm_checksum_generic;
389 nvm->ops.update = e1000_update_nvm_checksum_generic;
390 nvm->ops.valid_led_default = e1000_valid_led_default_82575;
391
392 /* override generic family function pointers for specific descendants */
393 switch (hw->mac.type) {
394 case e1000_82580:
395 nvm->ops.validate = e1000_validate_nvm_checksum_82580;
396 nvm->ops.update = e1000_update_nvm_checksum_82580;
397 break;
398 case e1000_i350:
399 case e1000_i354:
400 nvm->ops.validate = e1000_validate_nvm_checksum_i350;
401 nvm->ops.update = e1000_update_nvm_checksum_i350;
402 break;
403 default:
404 break;
405 }
406
407 return E1000_SUCCESS;
408 }
409
410 /**
411 * e1000_init_mac_params_82575 - Init MAC func ptrs.
412 * @hw: pointer to the HW structure
413 **/
e1000_init_mac_params_82575(struct e1000_hw * hw)414 static s32 e1000_init_mac_params_82575(struct e1000_hw *hw)
415 {
416 struct e1000_mac_info *mac = &hw->mac;
417 struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
418
419 DEBUGFUNC("e1000_init_mac_params_82575");
420
421 /* Derives media type */
422 e1000_get_media_type_82575(hw);
423 /* Set mta register count */
424 mac->mta_reg_count = 128;
425 /* Set uta register count */
426 mac->uta_reg_count = (hw->mac.type == e1000_82575) ? 0 : 128;
427 /* Set rar entry count */
428 mac->rar_entry_count = E1000_RAR_ENTRIES_82575;
429 if (mac->type == e1000_82576)
430 mac->rar_entry_count = E1000_RAR_ENTRIES_82576;
431 if (mac->type == e1000_82580)
432 mac->rar_entry_count = E1000_RAR_ENTRIES_82580;
433 if (mac->type == e1000_i350 || mac->type == e1000_i354)
434 mac->rar_entry_count = E1000_RAR_ENTRIES_I350;
435
436 /* Enable EEE default settings for EEE supported devices */
437 if (mac->type >= e1000_i350)
438 dev_spec->eee_disable = FALSE;
439
440 /* Allow a single clear of the SW semaphore on I210 and newer */
441 if (mac->type >= e1000_i210)
442 dev_spec->clear_semaphore_once = TRUE;
443
444 /* Set if part includes ASF firmware */
445 mac->asf_firmware_present = TRUE;
446 /* FWSM register */
447 mac->has_fwsm = TRUE;
448 /* ARC supported; valid only if manageability features are enabled. */
449 mac->arc_subsystem_valid =
450 !!(E1000_READ_REG(hw, E1000_FWSM) & E1000_FWSM_MODE_MASK);
451
452 /* Function pointers */
453
454 /* bus type/speed/width */
455 mac->ops.get_bus_info = e1000_get_bus_info_pcie_generic;
456 /* reset */
457 if (mac->type >= e1000_82580)
458 mac->ops.reset_hw = e1000_reset_hw_82580;
459 else
460 mac->ops.reset_hw = e1000_reset_hw_82575;
461 /* hw initialization */
462 if ((mac->type == e1000_i210) || (mac->type == e1000_i211))
463 mac->ops.init_hw = e1000_init_hw_i210;
464 else
465 mac->ops.init_hw = e1000_init_hw_82575;
466 /* link setup */
467 mac->ops.setup_link = e1000_setup_link_generic;
468 /* physical interface link setup */
469 mac->ops.setup_physical_interface =
470 (hw->phy.media_type == e1000_media_type_copper)
471 ? e1000_setup_copper_link_82575 : e1000_setup_serdes_link_82575;
472 /* physical interface shutdown */
473 mac->ops.shutdown_serdes = e1000_shutdown_serdes_link_82575;
474 /* physical interface power up */
475 mac->ops.power_up_serdes = e1000_power_up_serdes_link_82575;
476 /* check for link */
477 mac->ops.check_for_link = e1000_check_for_link_82575;
478 /* read mac address */
479 mac->ops.read_mac_addr = e1000_read_mac_addr_82575;
480 /* configure collision distance */
481 mac->ops.config_collision_dist = e1000_config_collision_dist_82575;
482 /* multicast address update */
483 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_generic;
484 if (hw->mac.type == e1000_i350 || mac->type == e1000_i354) {
485 /* writing VFTA */
486 mac->ops.write_vfta = e1000_write_vfta_i350;
487 /* clearing VFTA */
488 mac->ops.clear_vfta = e1000_clear_vfta_i350;
489 } else {
490 /* writing VFTA */
491 mac->ops.write_vfta = e1000_write_vfta_generic;
492 /* clearing VFTA */
493 mac->ops.clear_vfta = e1000_clear_vfta_generic;
494 }
495 if (hw->mac.type >= e1000_82580)
496 mac->ops.validate_mdi_setting =
497 e1000_validate_mdi_setting_crossover_generic;
498 /* ID LED init */
499 mac->ops.id_led_init = e1000_id_led_init_generic;
500 /* blink LED */
501 mac->ops.blink_led = e1000_blink_led_generic;
502 /* setup LED */
503 mac->ops.setup_led = e1000_setup_led_generic;
504 /* cleanup LED */
505 mac->ops.cleanup_led = e1000_cleanup_led_generic;
506 /* turn on/off LED */
507 mac->ops.led_on = e1000_led_on_generic;
508 mac->ops.led_off = e1000_led_off_generic;
509 /* clear hardware counters */
510 mac->ops.clear_hw_cntrs = e1000_clear_hw_cntrs_82575;
511 /* link info */
512 mac->ops.get_link_up_info = e1000_get_link_up_info_82575;
513 /* acquire SW_FW sync */
514 mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_82575;
515 mac->ops.release_swfw_sync = e1000_release_swfw_sync_82575;
516 if (mac->type >= e1000_i210) {
517 mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_i210;
518 mac->ops.release_swfw_sync = e1000_release_swfw_sync_i210;
519 }
520
521 /* set lan id for port to determine which phy lock to use */
522 hw->mac.ops.set_lan_id(hw);
523
524 return E1000_SUCCESS;
525 }
526
527 /**
528 * e1000_init_function_pointers_82575 - Init func ptrs.
529 * @hw: pointer to the HW structure
530 *
531 * Called to initialize all function pointers and parameters.
532 **/
e1000_init_function_pointers_82575(struct e1000_hw * hw)533 void e1000_init_function_pointers_82575(struct e1000_hw *hw)
534 {
535 DEBUGFUNC("e1000_init_function_pointers_82575");
536
537 hw->mac.ops.init_params = e1000_init_mac_params_82575;
538 hw->nvm.ops.init_params = e1000_init_nvm_params_82575;
539 hw->phy.ops.init_params = e1000_init_phy_params_82575;
540 hw->mbx.ops.init_params = e1000_init_mbx_params_pf;
541 }
542
543 /**
544 * e1000_acquire_phy_82575 - Acquire rights to access PHY
545 * @hw: pointer to the HW structure
546 *
547 * Acquire access rights to the correct PHY.
548 **/
e1000_acquire_phy_82575(struct e1000_hw * hw)549 static s32 e1000_acquire_phy_82575(struct e1000_hw *hw)
550 {
551 u16 mask = E1000_SWFW_PHY0_SM;
552
553 DEBUGFUNC("e1000_acquire_phy_82575");
554
555 if (hw->bus.func == E1000_FUNC_1)
556 mask = E1000_SWFW_PHY1_SM;
557 else if (hw->bus.func == E1000_FUNC_2)
558 mask = E1000_SWFW_PHY2_SM;
559 else if (hw->bus.func == E1000_FUNC_3)
560 mask = E1000_SWFW_PHY3_SM;
561
562 return hw->mac.ops.acquire_swfw_sync(hw, mask);
563 }
564
565 /**
566 * e1000_release_phy_82575 - Release rights to access PHY
567 * @hw: pointer to the HW structure
568 *
569 * A wrapper to release access rights to the correct PHY.
570 **/
e1000_release_phy_82575(struct e1000_hw * hw)571 static void e1000_release_phy_82575(struct e1000_hw *hw)
572 {
573 u16 mask = E1000_SWFW_PHY0_SM;
574
575 DEBUGFUNC("e1000_release_phy_82575");
576
577 if (hw->bus.func == E1000_FUNC_1)
578 mask = E1000_SWFW_PHY1_SM;
579 else if (hw->bus.func == E1000_FUNC_2)
580 mask = E1000_SWFW_PHY2_SM;
581 else if (hw->bus.func == E1000_FUNC_3)
582 mask = E1000_SWFW_PHY3_SM;
583
584 hw->mac.ops.release_swfw_sync(hw, mask);
585 }
586
587 /**
588 * e1000_read_phy_reg_sgmii_82575 - Read PHY register using sgmii
589 * @hw: pointer to the HW structure
590 * @offset: register offset to be read
591 * @data: pointer to the read data
592 *
593 * Reads the PHY register at offset using the serial gigabit media independent
594 * interface and stores the retrieved information in data.
595 **/
e1000_read_phy_reg_sgmii_82575(struct e1000_hw * hw,u32 offset,u16 * data)596 static s32 e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
597 u16 *data)
598 {
599 s32 ret_val = -E1000_ERR_PARAM;
600
601 DEBUGFUNC("e1000_read_phy_reg_sgmii_82575");
602
603 if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
604 DEBUGOUT1("PHY Address %u is out of range\n", offset);
605 goto out;
606 }
607
608 ret_val = hw->phy.ops.acquire(hw);
609 if (ret_val)
610 goto out;
611
612 ret_val = e1000_read_phy_reg_i2c(hw, offset, data);
613
614 hw->phy.ops.release(hw);
615
616 out:
617 return ret_val;
618 }
619
620 /**
621 * e1000_write_phy_reg_sgmii_82575 - Write PHY register using sgmii
622 * @hw: pointer to the HW structure
623 * @offset: register offset to write to
624 * @data: data to write at register offset
625 *
626 * Writes the data to PHY register at the offset using the serial gigabit
627 * media independent interface.
628 **/
e1000_write_phy_reg_sgmii_82575(struct e1000_hw * hw,u32 offset,u16 data)629 static s32 e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
630 u16 data)
631 {
632 s32 ret_val = -E1000_ERR_PARAM;
633
634 DEBUGFUNC("e1000_write_phy_reg_sgmii_82575");
635
636 if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
637 DEBUGOUT1("PHY Address %d is out of range\n", offset);
638 goto out;
639 }
640
641 ret_val = hw->phy.ops.acquire(hw);
642 if (ret_val)
643 goto out;
644
645 ret_val = e1000_write_phy_reg_i2c(hw, offset, data);
646
647 hw->phy.ops.release(hw);
648
649 out:
650 return ret_val;
651 }
652
653 /**
654 * e1000_get_phy_id_82575 - Retrieve PHY addr and id
655 * @hw: pointer to the HW structure
656 *
657 * Retrieves the PHY address and ID for both PHY's which do and do not use
658 * sgmi interface.
659 **/
e1000_get_phy_id_82575(struct e1000_hw * hw)660 static s32 e1000_get_phy_id_82575(struct e1000_hw *hw)
661 {
662 struct e1000_phy_info *phy = &hw->phy;
663 s32 ret_val = E1000_SUCCESS;
664 u16 phy_id;
665 u32 ctrl_ext;
666 u32 mdic;
667
668 DEBUGFUNC("e1000_get_phy_id_82575");
669
670 /* some i354 devices need an extra read for phy id */
671 if (hw->mac.type == e1000_i354)
672 e1000_get_phy_id(hw);
673
674 /*
675 * For SGMII PHYs, we try the list of possible addresses until
676 * we find one that works. For non-SGMII PHYs
677 * (e.g. integrated copper PHYs), an address of 1 should
678 * work. The result of this function should mean phy->phy_addr
679 * and phy->id are set correctly.
680 */
681 if (!e1000_sgmii_active_82575(hw)) {
682 phy->addr = 1;
683 ret_val = e1000_get_phy_id(hw);
684 goto out;
685 }
686
687 if (e1000_sgmii_uses_mdio_82575(hw)) {
688 switch (hw->mac.type) {
689 case e1000_82575:
690 case e1000_82576:
691 mdic = E1000_READ_REG(hw, E1000_MDIC);
692 mdic &= E1000_MDIC_PHY_MASK;
693 phy->addr = mdic >> E1000_MDIC_PHY_SHIFT;
694 break;
695 case e1000_82580:
696 case e1000_i350:
697 case e1000_i354:
698 case e1000_i210:
699 case e1000_i211:
700 mdic = E1000_READ_REG(hw, E1000_MDICNFG);
701 mdic &= E1000_MDICNFG_PHY_MASK;
702 phy->addr = mdic >> E1000_MDICNFG_PHY_SHIFT;
703 break;
704 default:
705 ret_val = -E1000_ERR_PHY;
706 goto out;
707 break;
708 }
709 ret_val = e1000_get_phy_id(hw);
710 goto out;
711 }
712
713 /* Power on sgmii phy if it is disabled */
714 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
715 E1000_WRITE_REG(hw, E1000_CTRL_EXT,
716 ctrl_ext & ~E1000_CTRL_EXT_SDP3_DATA);
717 E1000_WRITE_FLUSH(hw);
718 msec_delay(300);
719
720 /*
721 * The address field in the I2CCMD register is 3 bits and 0 is invalid.
722 * Therefore, we need to test 1-7
723 */
724 for (phy->addr = 1; phy->addr < 8; phy->addr++) {
725 ret_val = e1000_read_phy_reg_sgmii_82575(hw, PHY_ID1, &phy_id);
726 if (ret_val == E1000_SUCCESS) {
727 DEBUGOUT2("Vendor ID 0x%08X read at address %u\n",
728 phy_id, phy->addr);
729 /*
730 * At the time of this writing, The M88 part is
731 * the only supported SGMII PHY product.
732 */
733 if (phy_id == M88_VENDOR)
734 break;
735 } else {
736 DEBUGOUT1("PHY address %u was unreadable\n",
737 phy->addr);
738 }
739 }
740
741 /* A valid PHY type couldn't be found. */
742 if (phy->addr == 8) {
743 phy->addr = 0;
744 ret_val = -E1000_ERR_PHY;
745 } else {
746 ret_val = e1000_get_phy_id(hw);
747 }
748
749 /* restore previous sfp cage power state */
750 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
751
752 out:
753 return ret_val;
754 }
755
756 /**
757 * e1000_phy_hw_reset_sgmii_82575 - Performs a PHY reset
758 * @hw: pointer to the HW structure
759 *
760 * Resets the PHY using the serial gigabit media independent interface.
761 **/
e1000_phy_hw_reset_sgmii_82575(struct e1000_hw * hw)762 static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
763 {
764 s32 ret_val = E1000_SUCCESS;
765 struct e1000_phy_info *phy = &hw->phy;
766
767 DEBUGFUNC("e1000_phy_hw_reset_sgmii_82575");
768
769 /*
770 * This isn't a TRUE "hard" reset, but is the only reset
771 * available to us at this time.
772 */
773
774 DEBUGOUT("Soft resetting SGMII attached PHY...\n");
775
776 if (!(hw->phy.ops.write_reg))
777 goto out;
778
779 /*
780 * SFP documentation requires the following to configure the SPF module
781 * to work on SGMII. No further documentation is given.
782 */
783 ret_val = hw->phy.ops.write_reg(hw, 0x1B, 0x8084);
784 if (ret_val)
785 goto out;
786
787 ret_val = hw->phy.ops.commit(hw);
788 if (ret_val)
789 goto out;
790
791 if (phy->id == M88E1512_E_PHY_ID)
792 ret_val = e1000_initialize_M88E1512_phy(hw);
793 out:
794 return ret_val;
795 }
796
797 /**
798 * e1000_set_d0_lplu_state_82575 - Set Low Power Linkup D0 state
799 * @hw: pointer to the HW structure
800 * @active: TRUE to enable LPLU, FALSE to disable
801 *
802 * Sets the LPLU D0 state according to the active flag. When
803 * activating LPLU this function also disables smart speed
804 * and vice versa. LPLU will not be activated unless the
805 * device autonegotiation advertisement meets standards of
806 * either 10 or 10/100 or 10/100/1000 at all duplexes.
807 * This is a function pointer entry point only called by
808 * PHY setup routines.
809 **/
e1000_set_d0_lplu_state_82575(struct e1000_hw * hw,bool active)810 static s32 e1000_set_d0_lplu_state_82575(struct e1000_hw *hw, bool active)
811 {
812 struct e1000_phy_info *phy = &hw->phy;
813 s32 ret_val = E1000_SUCCESS;
814 u16 data;
815
816 DEBUGFUNC("e1000_set_d0_lplu_state_82575");
817
818 if (!(hw->phy.ops.read_reg))
819 goto out;
820
821 ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
822 if (ret_val)
823 goto out;
824
825 if (active) {
826 data |= IGP02E1000_PM_D0_LPLU;
827 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
828 data);
829 if (ret_val)
830 goto out;
831
832 /* When LPLU is enabled, we should disable SmartSpeed */
833 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
834 &data);
835 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
836 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
837 data);
838 if (ret_val)
839 goto out;
840 } else {
841 data &= ~IGP02E1000_PM_D0_LPLU;
842 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
843 data);
844 /*
845 * LPLU and SmartSpeed are mutually exclusive. LPLU is used
846 * during Dx states where the power conservation is most
847 * important. During driver activity we should enable
848 * SmartSpeed, so performance is maintained.
849 */
850 if (phy->smart_speed == e1000_smart_speed_on) {
851 ret_val = phy->ops.read_reg(hw,
852 IGP01E1000_PHY_PORT_CONFIG,
853 &data);
854 if (ret_val)
855 goto out;
856
857 data |= IGP01E1000_PSCFR_SMART_SPEED;
858 ret_val = phy->ops.write_reg(hw,
859 IGP01E1000_PHY_PORT_CONFIG,
860 data);
861 if (ret_val)
862 goto out;
863 } else if (phy->smart_speed == e1000_smart_speed_off) {
864 ret_val = phy->ops.read_reg(hw,
865 IGP01E1000_PHY_PORT_CONFIG,
866 &data);
867 if (ret_val)
868 goto out;
869
870 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
871 ret_val = phy->ops.write_reg(hw,
872 IGP01E1000_PHY_PORT_CONFIG,
873 data);
874 if (ret_val)
875 goto out;
876 }
877 }
878
879 out:
880 return ret_val;
881 }
882
883 /**
884 * e1000_set_d0_lplu_state_82580 - Set Low Power Linkup D0 state
885 * @hw: pointer to the HW structure
886 * @active: TRUE to enable LPLU, FALSE to disable
887 *
888 * Sets the LPLU D0 state according to the active flag. When
889 * activating LPLU this function also disables smart speed
890 * and vice versa. LPLU will not be activated unless the
891 * device autonegotiation advertisement meets standards of
892 * either 10 or 10/100 or 10/100/1000 at all duplexes.
893 * This is a function pointer entry point only called by
894 * PHY setup routines.
895 **/
e1000_set_d0_lplu_state_82580(struct e1000_hw * hw,bool active)896 static s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw, bool active)
897 {
898 struct e1000_phy_info *phy = &hw->phy;
899 u32 data;
900
901 DEBUGFUNC("e1000_set_d0_lplu_state_82580");
902
903 data = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
904
905 if (active) {
906 data |= E1000_82580_PM_D0_LPLU;
907
908 /* When LPLU is enabled, we should disable SmartSpeed */
909 data &= ~E1000_82580_PM_SPD;
910 } else {
911 data &= ~E1000_82580_PM_D0_LPLU;
912
913 /*
914 * LPLU and SmartSpeed are mutually exclusive. LPLU is used
915 * during Dx states where the power conservation is most
916 * important. During driver activity we should enable
917 * SmartSpeed, so performance is maintained.
918 */
919 if (phy->smart_speed == e1000_smart_speed_on)
920 data |= E1000_82580_PM_SPD;
921 else if (phy->smart_speed == e1000_smart_speed_off)
922 data &= ~E1000_82580_PM_SPD;
923 }
924
925 E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
926 return E1000_SUCCESS;
927 }
928
929 /**
930 * e1000_set_d3_lplu_state_82580 - Sets low power link up state for D3
931 * @hw: pointer to the HW structure
932 * @active: boolean used to enable/disable lplu
933 *
934 * Success returns 0, Failure returns 1
935 *
936 * The low power link up (lplu) state is set to the power management level D3
937 * and SmartSpeed is disabled when active is TRUE, else clear lplu for D3
938 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU
939 * is used during Dx states where the power conservation is most important.
940 * During driver activity, SmartSpeed should be enabled so performance is
941 * maintained.
942 **/
e1000_set_d3_lplu_state_82580(struct e1000_hw * hw,bool active)943 s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw, bool active)
944 {
945 struct e1000_phy_info *phy = &hw->phy;
946 u32 data;
947
948 DEBUGFUNC("e1000_set_d3_lplu_state_82580");
949
950 data = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
951
952 if (!active) {
953 data &= ~E1000_82580_PM_D3_LPLU;
954 /*
955 * LPLU and SmartSpeed are mutually exclusive. LPLU is used
956 * during Dx states where the power conservation is most
957 * important. During driver activity we should enable
958 * SmartSpeed, so performance is maintained.
959 */
960 if (phy->smart_speed == e1000_smart_speed_on)
961 data |= E1000_82580_PM_SPD;
962 else if (phy->smart_speed == e1000_smart_speed_off)
963 data &= ~E1000_82580_PM_SPD;
964 } else if ((phy->autoneg_advertised == E1000_ALL_SPEED_DUPLEX) ||
965 (phy->autoneg_advertised == E1000_ALL_NOT_GIG) ||
966 (phy->autoneg_advertised == E1000_ALL_10_SPEED)) {
967 data |= E1000_82580_PM_D3_LPLU;
968 /* When LPLU is enabled, we should disable SmartSpeed */
969 data &= ~E1000_82580_PM_SPD;
970 }
971
972 E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
973 return E1000_SUCCESS;
974 }
975
976 /**
977 * e1000_acquire_nvm_82575 - Request for access to EEPROM
978 * @hw: pointer to the HW structure
979 *
980 * Acquire the necessary semaphores for exclusive access to the EEPROM.
981 * Set the EEPROM access request bit and wait for EEPROM access grant bit.
982 * Return successful if access grant bit set, else clear the request for
983 * EEPROM access and return -E1000_ERR_NVM (-1).
984 **/
e1000_acquire_nvm_82575(struct e1000_hw * hw)985 static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
986 {
987 s32 ret_val = E1000_SUCCESS;
988
989 DEBUGFUNC("e1000_acquire_nvm_82575");
990
991 ret_val = e1000_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
992 if (ret_val)
993 goto out;
994
995 /*
996 * Check if there is some access
997 * error this access may hook on
998 */
999 if (hw->mac.type == e1000_i350) {
1000 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
1001 if (eecd & (E1000_EECD_BLOCKED | E1000_EECD_ABORT |
1002 E1000_EECD_TIMEOUT)) {
1003 /* Clear all access error flags */
1004 E1000_WRITE_REG(hw, E1000_EECD, eecd |
1005 E1000_EECD_ERROR_CLR);
1006 DEBUGOUT("Nvm bit banging access error detected and cleared.\n");
1007 }
1008 }
1009
1010 if (hw->mac.type == e1000_82580) {
1011 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
1012 if (eecd & E1000_EECD_BLOCKED) {
1013 /* Clear access error flag */
1014 E1000_WRITE_REG(hw, E1000_EECD, eecd |
1015 E1000_EECD_BLOCKED);
1016 DEBUGOUT("Nvm bit banging access error detected and cleared.\n");
1017 }
1018 }
1019
1020 ret_val = e1000_acquire_nvm_generic(hw);
1021 if (ret_val)
1022 e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
1023
1024 out:
1025 return ret_val;
1026 }
1027
1028 /**
1029 * e1000_release_nvm_82575 - Release exclusive access to EEPROM
1030 * @hw: pointer to the HW structure
1031 *
1032 * Stop any current commands to the EEPROM and clear the EEPROM request bit,
1033 * then release the semaphores acquired.
1034 **/
e1000_release_nvm_82575(struct e1000_hw * hw)1035 static void e1000_release_nvm_82575(struct e1000_hw *hw)
1036 {
1037 DEBUGFUNC("e1000_release_nvm_82575");
1038
1039 e1000_release_nvm_generic(hw);
1040
1041 e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
1042 }
1043
1044 /**
1045 * e1000_acquire_swfw_sync_82575 - Acquire SW/FW semaphore
1046 * @hw: pointer to the HW structure
1047 * @mask: specifies which semaphore to acquire
1048 *
1049 * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
1050 * will also specify which port we're acquiring the lock for.
1051 **/
e1000_acquire_swfw_sync_82575(struct e1000_hw * hw,u16 mask)1052 static s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
1053 {
1054 u32 swfw_sync;
1055 u32 swmask = mask;
1056 u32 fwmask = mask << 16;
1057 s32 ret_val = E1000_SUCCESS;
1058 s32 i = 0, timeout = 200;
1059
1060 DEBUGFUNC("e1000_acquire_swfw_sync_82575");
1061
1062 while (i < timeout) {
1063 if (e1000_get_hw_semaphore_generic(hw)) {
1064 ret_val = -E1000_ERR_SWFW_SYNC;
1065 goto out;
1066 }
1067
1068 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
1069 if (!(swfw_sync & (fwmask | swmask)))
1070 break;
1071
1072 /*
1073 * Firmware currently using resource (fwmask)
1074 * or other software thread using resource (swmask)
1075 */
1076 e1000_put_hw_semaphore_generic(hw);
1077 msec_delay_irq(5);
1078 i++;
1079 }
1080
1081 if (i == timeout) {
1082 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
1083 ret_val = -E1000_ERR_SWFW_SYNC;
1084 goto out;
1085 }
1086
1087 swfw_sync |= swmask;
1088 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
1089
1090 e1000_put_hw_semaphore_generic(hw);
1091
1092 out:
1093 return ret_val;
1094 }
1095
1096 /**
1097 * e1000_release_swfw_sync_82575 - Release SW/FW semaphore
1098 * @hw: pointer to the HW structure
1099 * @mask: specifies which semaphore to acquire
1100 *
1101 * Release the SW/FW semaphore used to access the PHY or NVM. The mask
1102 * will also specify which port we're releasing the lock for.
1103 **/
e1000_release_swfw_sync_82575(struct e1000_hw * hw,u16 mask)1104 static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
1105 {
1106 u32 swfw_sync;
1107
1108 DEBUGFUNC("e1000_release_swfw_sync_82575");
1109
1110 while (e1000_get_hw_semaphore_generic(hw) != E1000_SUCCESS)
1111 ; /* Empty */
1112
1113 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
1114 swfw_sync &= ~mask;
1115 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
1116
1117 e1000_put_hw_semaphore_generic(hw);
1118 }
1119
1120 /**
1121 * e1000_get_cfg_done_82575 - Read config done bit
1122 * @hw: pointer to the HW structure
1123 *
1124 * Read the management control register for the config done bit for
1125 * completion status. NOTE: silicon which is EEPROM-less will fail trying
1126 * to read the config done bit, so an error is *ONLY* logged and returns
1127 * E1000_SUCCESS. If we were to return with error, EEPROM-less silicon
1128 * would not be able to be reset or change link.
1129 **/
e1000_get_cfg_done_82575(struct e1000_hw * hw)1130 static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw)
1131 {
1132 s32 timeout = PHY_CFG_TIMEOUT;
1133 u32 mask = E1000_NVM_CFG_DONE_PORT_0;
1134
1135 DEBUGFUNC("e1000_get_cfg_done_82575");
1136
1137 if (hw->bus.func == E1000_FUNC_1)
1138 mask = E1000_NVM_CFG_DONE_PORT_1;
1139 else if (hw->bus.func == E1000_FUNC_2)
1140 mask = E1000_NVM_CFG_DONE_PORT_2;
1141 else if (hw->bus.func == E1000_FUNC_3)
1142 mask = E1000_NVM_CFG_DONE_PORT_3;
1143 while (timeout) {
1144 if (E1000_READ_REG(hw, E1000_EEMNGCTL) & mask)
1145 break;
1146 msec_delay(1);
1147 timeout--;
1148 }
1149 if (!timeout)
1150 DEBUGOUT("MNG configuration cycle has not completed.\n");
1151
1152 /* If EEPROM is not marked present, init the PHY manually */
1153 if (!(E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) &&
1154 (hw->phy.type == e1000_phy_igp_3))
1155 e1000_phy_init_script_igp3(hw);
1156
1157 return E1000_SUCCESS;
1158 }
1159
1160 /**
1161 * e1000_get_link_up_info_82575 - Get link speed/duplex info
1162 * @hw: pointer to the HW structure
1163 * @speed: stores the current speed
1164 * @duplex: stores the current duplex
1165 *
1166 * This is a wrapper function, if using the serial gigabit media independent
1167 * interface, use PCS to retrieve the link speed and duplex information.
1168 * Otherwise, use the generic function to get the link speed and duplex info.
1169 **/
e1000_get_link_up_info_82575(struct e1000_hw * hw,u16 * speed,u16 * duplex)1170 static s32 e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
1171 u16 *duplex)
1172 {
1173 s32 ret_val;
1174
1175 DEBUGFUNC("e1000_get_link_up_info_82575");
1176
1177 if (hw->phy.media_type != e1000_media_type_copper)
1178 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, speed,
1179 duplex);
1180 else
1181 ret_val = e1000_get_speed_and_duplex_copper_generic(hw, speed,
1182 duplex);
1183
1184 return ret_val;
1185 }
1186
1187 /**
1188 * e1000_check_for_link_82575 - Check for link
1189 * @hw: pointer to the HW structure
1190 *
1191 * If sgmii is enabled, then use the pcs register to determine link, otherwise
1192 * use the generic interface for determining link.
1193 **/
e1000_check_for_link_82575(struct e1000_hw * hw)1194 static s32 e1000_check_for_link_82575(struct e1000_hw *hw)
1195 {
1196 s32 ret_val;
1197 u16 speed, duplex;
1198
1199 DEBUGFUNC("e1000_check_for_link_82575");
1200
1201 if (hw->phy.media_type != e1000_media_type_copper) {
1202 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, &speed,
1203 &duplex);
1204 /*
1205 * Use this flag to determine if link needs to be checked or
1206 * not. If we have link clear the flag so that we do not
1207 * continue to check for link.
1208 */
1209 hw->mac.get_link_status = !hw->mac.serdes_has_link;
1210
1211 /*
1212 * Configure Flow Control now that Auto-Neg has completed.
1213 * First, we need to restore the desired flow control
1214 * settings because we may have had to re-autoneg with a
1215 * different link partner.
1216 */
1217 ret_val = e1000_config_fc_after_link_up_generic(hw);
1218 if (ret_val)
1219 DEBUGOUT("Error configuring flow control\n");
1220 } else {
1221 ret_val = e1000_check_for_copper_link_generic(hw);
1222 }
1223
1224 return ret_val;
1225 }
1226
1227 /**
1228 * e1000_check_for_link_media_swap - Check which M88E1112 interface linked
1229 * @hw: pointer to the HW structure
1230 *
1231 * Poll the M88E1112 interfaces to see which interface achieved link.
1232 */
e1000_check_for_link_media_swap(struct e1000_hw * hw)1233 static s32 e1000_check_for_link_media_swap(struct e1000_hw *hw)
1234 {
1235 struct e1000_phy_info *phy = &hw->phy;
1236 s32 ret_val;
1237 u16 data;
1238 u8 port = 0;
1239
1240 DEBUGFUNC("e1000_check_for_link_media_swap");
1241
1242 /* Check for copper. */
1243 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1244 if (ret_val)
1245 return ret_val;
1246
1247 ret_val = phy->ops.read_reg(hw, E1000_M88E1112_STATUS, &data);
1248 if (ret_val)
1249 return ret_val;
1250
1251 if (data & E1000_M88E1112_STATUS_LINK)
1252 port = E1000_MEDIA_PORT_COPPER;
1253
1254 /* Check for other. */
1255 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 1);
1256 if (ret_val)
1257 return ret_val;
1258
1259 ret_val = phy->ops.read_reg(hw, E1000_M88E1112_STATUS, &data);
1260 if (ret_val)
1261 return ret_val;
1262
1263 if (data & E1000_M88E1112_STATUS_LINK)
1264 port = E1000_MEDIA_PORT_OTHER;
1265
1266 /* Determine if a swap needs to happen. */
1267 if (port && (hw->dev_spec._82575.media_port != port)) {
1268 hw->dev_spec._82575.media_port = port;
1269 hw->dev_spec._82575.media_changed = TRUE;
1270 }
1271
1272 if (port == E1000_MEDIA_PORT_COPPER) {
1273 /* reset page to 0 */
1274 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1275 if (ret_val)
1276 return ret_val;
1277 e1000_check_for_link_82575(hw);
1278 } else {
1279 e1000_check_for_link_82575(hw);
1280 /* reset page to 0 */
1281 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1282 if (ret_val)
1283 return ret_val;
1284 }
1285
1286 return E1000_SUCCESS;
1287 }
1288
1289 /**
1290 * e1000_power_up_serdes_link_82575 - Power up the serdes link after shutdown
1291 * @hw: pointer to the HW structure
1292 **/
e1000_power_up_serdes_link_82575(struct e1000_hw * hw)1293 static void e1000_power_up_serdes_link_82575(struct e1000_hw *hw)
1294 {
1295 u32 reg;
1296
1297 DEBUGFUNC("e1000_power_up_serdes_link_82575");
1298
1299 if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1300 !e1000_sgmii_active_82575(hw))
1301 return;
1302
1303 /* Enable PCS to turn on link */
1304 reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1305 reg |= E1000_PCS_CFG_PCS_EN;
1306 E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1307
1308 /* Power up the laser */
1309 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1310 reg &= ~E1000_CTRL_EXT_SDP3_DATA;
1311 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1312
1313 /* flush the write to verify completion */
1314 E1000_WRITE_FLUSH(hw);
1315 msec_delay(1);
1316 }
1317
1318 /**
1319 * e1000_get_pcs_speed_and_duplex_82575 - Retrieve current speed/duplex
1320 * @hw: pointer to the HW structure
1321 * @speed: stores the current speed
1322 * @duplex: stores the current duplex
1323 *
1324 * Using the physical coding sub-layer (PCS), retrieve the current speed and
1325 * duplex, then store the values in the pointers provided.
1326 **/
e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw * hw,u16 * speed,u16 * duplex)1327 static s32 e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
1328 u16 *speed, u16 *duplex)
1329 {
1330 struct e1000_mac_info *mac = &hw->mac;
1331 u32 pcs;
1332 u32 status;
1333
1334 DEBUGFUNC("e1000_get_pcs_speed_and_duplex_82575");
1335
1336 /*
1337 * Read the PCS Status register for link state. For non-copper mode,
1338 * the status register is not accurate. The PCS status register is
1339 * used instead.
1340 */
1341 pcs = E1000_READ_REG(hw, E1000_PCS_LSTAT);
1342
1343 /*
1344 * The link up bit determines when link is up on autoneg.
1345 */
1346 if (pcs & E1000_PCS_LSTS_LINK_OK) {
1347 mac->serdes_has_link = TRUE;
1348
1349 /* Detect and store PCS speed */
1350 if (pcs & E1000_PCS_LSTS_SPEED_1000)
1351 *speed = SPEED_1000;
1352 else if (pcs & E1000_PCS_LSTS_SPEED_100)
1353 *speed = SPEED_100;
1354 else
1355 *speed = SPEED_10;
1356
1357 /* Detect and store PCS duplex */
1358 if (pcs & E1000_PCS_LSTS_DUPLEX_FULL)
1359 *duplex = FULL_DUPLEX;
1360 else
1361 *duplex = HALF_DUPLEX;
1362
1363 /* Check if it is an I354 2.5Gb backplane connection. */
1364 if (mac->type == e1000_i354) {
1365 status = E1000_READ_REG(hw, E1000_STATUS);
1366 if ((status & E1000_STATUS_2P5_SKU) &&
1367 !(status & E1000_STATUS_2P5_SKU_OVER)) {
1368 *speed = SPEED_2500;
1369 *duplex = FULL_DUPLEX;
1370 DEBUGOUT("2500 Mbs, ");
1371 DEBUGOUT("Full Duplex\n");
1372 }
1373 }
1374
1375 } else {
1376 mac->serdes_has_link = FALSE;
1377 *speed = 0;
1378 *duplex = 0;
1379 }
1380
1381 return E1000_SUCCESS;
1382 }
1383
1384 /**
1385 * e1000_shutdown_serdes_link_82575 - Remove link during power down
1386 * @hw: pointer to the HW structure
1387 *
1388 * In the case of serdes shut down sfp and PCS on driver unload
1389 * when management pass thru is not enabled.
1390 **/
e1000_shutdown_serdes_link_82575(struct e1000_hw * hw)1391 void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw)
1392 {
1393 u32 reg;
1394
1395 DEBUGFUNC("e1000_shutdown_serdes_link_82575");
1396
1397 if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1398 !e1000_sgmii_active_82575(hw))
1399 return;
1400
1401 if (!e1000_enable_mng_pass_thru(hw)) {
1402 /* Disable PCS to turn off link */
1403 reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1404 reg &= ~E1000_PCS_CFG_PCS_EN;
1405 E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1406
1407 /* shutdown the laser */
1408 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1409 reg |= E1000_CTRL_EXT_SDP3_DATA;
1410 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1411
1412 /* flush the write to verify completion */
1413 E1000_WRITE_FLUSH(hw);
1414 msec_delay(1);
1415 }
1416
1417 return;
1418 }
1419
1420 /**
1421 * e1000_reset_hw_82575 - Reset hardware
1422 * @hw: pointer to the HW structure
1423 *
1424 * This resets the hardware into a known state.
1425 **/
e1000_reset_hw_82575(struct e1000_hw * hw)1426 static s32 e1000_reset_hw_82575(struct e1000_hw *hw)
1427 {
1428 u32 ctrl;
1429 s32 ret_val;
1430
1431 DEBUGFUNC("e1000_reset_hw_82575");
1432
1433 /*
1434 * Prevent the PCI-E bus from sticking if there is no TLP connection
1435 * on the last TLP read/write transaction when MAC is reset.
1436 */
1437 ret_val = e1000_disable_pcie_master_generic(hw);
1438 if (ret_val)
1439 DEBUGOUT("PCI-E Master disable polling has failed.\n");
1440
1441 /* set the completion timeout for interface */
1442 ret_val = e1000_set_pcie_completion_timeout(hw);
1443 if (ret_val)
1444 DEBUGOUT("PCI-E Set completion timeout has failed.\n");
1445
1446 DEBUGOUT("Masking off all interrupts\n");
1447 E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1448
1449 E1000_WRITE_REG(hw, E1000_RCTL, 0);
1450 E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
1451 E1000_WRITE_FLUSH(hw);
1452
1453 msec_delay(10);
1454
1455 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1456
1457 DEBUGOUT("Issuing a global reset to MAC\n");
1458 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
1459
1460 ret_val = e1000_get_auto_rd_done_generic(hw);
1461 if (ret_val) {
1462 /*
1463 * When auto config read does not complete, do not
1464 * return with an error. This can happen in situations
1465 * where there is no eeprom and prevents getting link.
1466 */
1467 DEBUGOUT("Auto Read Done did not complete\n");
1468 }
1469
1470 /* If EEPROM is not present, run manual init scripts */
1471 if (!(E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES))
1472 e1000_reset_init_script_82575(hw);
1473
1474 /* Clear any pending interrupt events. */
1475 E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1476 E1000_READ_REG(hw, E1000_ICR);
1477
1478 /* Install any alternate MAC address into RAR0 */
1479 ret_val = e1000_check_alt_mac_addr_generic(hw);
1480
1481 return ret_val;
1482 }
1483
1484 /**
1485 * e1000_init_hw_82575 - Initialize hardware
1486 * @hw: pointer to the HW structure
1487 *
1488 * This inits the hardware readying it for operation.
1489 **/
e1000_init_hw_82575(struct e1000_hw * hw)1490 s32 e1000_init_hw_82575(struct e1000_hw *hw)
1491 {
1492 struct e1000_mac_info *mac = &hw->mac;
1493 s32 ret_val;
1494 u16 i, rar_count = mac->rar_entry_count;
1495
1496 DEBUGFUNC("e1000_init_hw_82575");
1497
1498 /* Initialize identification LED */
1499 ret_val = mac->ops.id_led_init(hw);
1500 if (ret_val) {
1501 DEBUGOUT("Error initializing identification LED\n");
1502 /* This is not fatal and we should not stop init due to this */
1503 }
1504
1505 /* Disabling VLAN filtering */
1506 DEBUGOUT("Initializing the IEEE VLAN\n");
1507 mac->ops.clear_vfta(hw);
1508
1509 /* Setup the receive address */
1510 e1000_init_rx_addrs_generic(hw, rar_count);
1511
1512 /* Zero out the Multicast HASH table */
1513 DEBUGOUT("Zeroing the MTA\n");
1514 for (i = 0; i < mac->mta_reg_count; i++)
1515 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
1516
1517 /* Zero out the Unicast HASH table */
1518 DEBUGOUT("Zeroing the UTA\n");
1519 for (i = 0; i < mac->uta_reg_count; i++)
1520 E1000_WRITE_REG_ARRAY(hw, E1000_UTA, i, 0);
1521
1522 /* Setup link and flow control */
1523 ret_val = mac->ops.setup_link(hw);
1524
1525 /* Set the default MTU size */
1526 hw->dev_spec._82575.mtu = 1500;
1527
1528 /*
1529 * Clear all of the statistics registers (clear on read). It is
1530 * important that we do this after we have tried to establish link
1531 * because the symbol error count will increment wildly if there
1532 * is no link.
1533 */
1534 e1000_clear_hw_cntrs_82575(hw);
1535
1536 return ret_val;
1537 }
1538
1539 /**
1540 * e1000_setup_copper_link_82575 - Configure copper link settings
1541 * @hw: pointer to the HW structure
1542 *
1543 * Configures the link for auto-neg or forced speed and duplex. Then we check
1544 * for link, once link is established calls to configure collision distance
1545 * and flow control are called.
1546 **/
e1000_setup_copper_link_82575(struct e1000_hw * hw)1547 static s32 e1000_setup_copper_link_82575(struct e1000_hw *hw)
1548 {
1549 u32 ctrl;
1550 s32 ret_val;
1551 u32 phpm_reg;
1552
1553 DEBUGFUNC("e1000_setup_copper_link_82575");
1554
1555 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1556 ctrl |= E1000_CTRL_SLU;
1557 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1558 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1559
1560 /* Clear Go Link Disconnect bit on supported devices */
1561 switch (hw->mac.type) {
1562 case e1000_82580:
1563 case e1000_i350:
1564 case e1000_i210:
1565 case e1000_i211:
1566 phpm_reg = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
1567 phpm_reg &= ~E1000_82580_PM_GO_LINKD;
1568 E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, phpm_reg);
1569 break;
1570 default:
1571 break;
1572 }
1573
1574 ret_val = e1000_setup_serdes_link_82575(hw);
1575 if (ret_val)
1576 goto out;
1577
1578 if (e1000_sgmii_active_82575(hw)) {
1579 /* allow time for SFP cage time to power up phy */
1580 msec_delay(300);
1581
1582 ret_val = hw->phy.ops.reset(hw);
1583 if (ret_val) {
1584 DEBUGOUT("Error resetting the PHY.\n");
1585 goto out;
1586 }
1587 }
1588 switch (hw->phy.type) {
1589 case e1000_phy_i210:
1590 case e1000_phy_m88:
1591 switch (hw->phy.id) {
1592 case I347AT4_E_PHY_ID:
1593 case M88E1112_E_PHY_ID:
1594 case M88E1340M_E_PHY_ID:
1595 case M88E1543_E_PHY_ID:
1596 case M88E1512_E_PHY_ID:
1597 case I210_I_PHY_ID:
1598 ret_val = e1000_copper_link_setup_m88_gen2(hw);
1599 break;
1600 default:
1601 ret_val = e1000_copper_link_setup_m88(hw);
1602 break;
1603 }
1604 break;
1605 case e1000_phy_igp_3:
1606 ret_val = e1000_copper_link_setup_igp(hw);
1607 break;
1608 case e1000_phy_82580:
1609 ret_val = e1000_copper_link_setup_82577(hw);
1610 break;
1611 default:
1612 ret_val = -E1000_ERR_PHY;
1613 break;
1614 }
1615
1616 if (ret_val)
1617 goto out;
1618
1619 ret_val = e1000_setup_copper_link_generic(hw);
1620 out:
1621 return ret_val;
1622 }
1623
1624 /**
1625 * e1000_setup_serdes_link_82575 - Setup link for serdes
1626 * @hw: pointer to the HW structure
1627 *
1628 * Configure the physical coding sub-layer (PCS) link. The PCS link is
1629 * used on copper connections where the serialized gigabit media independent
1630 * interface (sgmii), or serdes fiber is being used. Configures the link
1631 * for auto-negotiation or forces speed/duplex.
1632 **/
e1000_setup_serdes_link_82575(struct e1000_hw * hw)1633 static s32 e1000_setup_serdes_link_82575(struct e1000_hw *hw)
1634 {
1635 u32 ctrl_ext, ctrl_reg, reg, anadv_reg;
1636 bool pcs_autoneg;
1637 s32 ret_val = E1000_SUCCESS;
1638 u16 data;
1639
1640 DEBUGFUNC("e1000_setup_serdes_link_82575");
1641
1642 if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1643 !e1000_sgmii_active_82575(hw))
1644 return ret_val;
1645
1646 /*
1647 * On the 82575, SerDes loopback mode persists until it is
1648 * explicitly turned off or a power cycle is performed. A read to
1649 * the register does not indicate its status. Therefore, we ensure
1650 * loopback mode is disabled during initialization.
1651 */
1652 E1000_WRITE_REG(hw, E1000_SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1653
1654 /* power on the sfp cage if present */
1655 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1656 ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
1657 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1658
1659 ctrl_reg = E1000_READ_REG(hw, E1000_CTRL);
1660 ctrl_reg |= E1000_CTRL_SLU;
1661
1662 /* set both sw defined pins on 82575/82576*/
1663 if (hw->mac.type == e1000_82575 || hw->mac.type == e1000_82576)
1664 ctrl_reg |= E1000_CTRL_SWDPIN0 | E1000_CTRL_SWDPIN1;
1665
1666 reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1667
1668 /* default pcs_autoneg to the same setting as mac autoneg */
1669 pcs_autoneg = hw->mac.autoneg;
1670
1671 switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
1672 case E1000_CTRL_EXT_LINK_MODE_SGMII:
1673 /* sgmii mode lets the phy handle forcing speed/duplex */
1674 pcs_autoneg = TRUE;
1675 /* autoneg time out should be disabled for SGMII mode */
1676 reg &= ~(E1000_PCS_LCTL_AN_TIMEOUT);
1677 break;
1678 case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
1679 /* disable PCS autoneg and support parallel detect only */
1680 pcs_autoneg = FALSE;
1681 /* fall through to default case */
1682 default:
1683 if (hw->mac.type == e1000_82575 ||
1684 hw->mac.type == e1000_82576) {
1685 ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &data);
1686 if (ret_val) {
1687 DEBUGOUT("NVM Read Error\n");
1688 return ret_val;
1689 }
1690
1691 if (data & E1000_EEPROM_PCS_AUTONEG_DISABLE_BIT)
1692 pcs_autoneg = FALSE;
1693 }
1694
1695 /*
1696 * non-SGMII modes only supports a speed of 1000/Full for the
1697 * link so it is best to just force the MAC and let the pcs
1698 * link either autoneg or be forced to 1000/Full
1699 */
1700 ctrl_reg |= E1000_CTRL_SPD_1000 | E1000_CTRL_FRCSPD |
1701 E1000_CTRL_FD | E1000_CTRL_FRCDPX;
1702
1703 /* set speed of 1000/Full if speed/duplex is forced */
1704 reg |= E1000_PCS_LCTL_FSV_1000 | E1000_PCS_LCTL_FDV_FULL;
1705 break;
1706 }
1707
1708 E1000_WRITE_REG(hw, E1000_CTRL, ctrl_reg);
1709
1710 /*
1711 * New SerDes mode allows for forcing speed or autonegotiating speed
1712 * at 1gb. Autoneg should be default set by most drivers. This is the
1713 * mode that will be compatible with older link partners and switches.
1714 * However, both are supported by the hardware and some drivers/tools.
1715 */
1716 reg &= ~(E1000_PCS_LCTL_AN_ENABLE | E1000_PCS_LCTL_FLV_LINK_UP |
1717 E1000_PCS_LCTL_FSD | E1000_PCS_LCTL_FORCE_LINK);
1718
1719 if (pcs_autoneg) {
1720 /* Set PCS register for autoneg */
1721 reg |= E1000_PCS_LCTL_AN_ENABLE | /* Enable Autoneg */
1722 E1000_PCS_LCTL_AN_RESTART; /* Restart autoneg */
1723
1724 /* Disable force flow control for autoneg */
1725 reg &= ~E1000_PCS_LCTL_FORCE_FCTRL;
1726
1727 /* Configure flow control advertisement for autoneg */
1728 anadv_reg = E1000_READ_REG(hw, E1000_PCS_ANADV);
1729 anadv_reg &= ~(E1000_TXCW_ASM_DIR | E1000_TXCW_PAUSE);
1730
1731 switch (hw->fc.requested_mode) {
1732 case e1000_fc_full:
1733 case e1000_fc_rx_pause:
1734 anadv_reg |= E1000_TXCW_ASM_DIR;
1735 anadv_reg |= E1000_TXCW_PAUSE;
1736 break;
1737 case e1000_fc_tx_pause:
1738 anadv_reg |= E1000_TXCW_ASM_DIR;
1739 break;
1740 default:
1741 break;
1742 }
1743
1744 E1000_WRITE_REG(hw, E1000_PCS_ANADV, anadv_reg);
1745
1746 DEBUGOUT1("Configuring Autoneg:PCS_LCTL=0x%08X\n", reg);
1747 } else {
1748 /* Set PCS register for forced link */
1749 reg |= E1000_PCS_LCTL_FSD; /* Force Speed */
1750
1751 /* Force flow control for forced link */
1752 reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1753
1754 DEBUGOUT1("Configuring Forced Link:PCS_LCTL=0x%08X\n", reg);
1755 }
1756
1757 E1000_WRITE_REG(hw, E1000_PCS_LCTL, reg);
1758
1759 if (!pcs_autoneg && !e1000_sgmii_active_82575(hw))
1760 e1000_force_mac_fc_generic(hw);
1761
1762 return ret_val;
1763 }
1764
1765 /**
1766 * e1000_get_media_type_82575 - derives current media type.
1767 * @hw: pointer to the HW structure
1768 *
1769 * The media type is chosen reflecting few settings.
1770 * The following are taken into account:
1771 * - link mode set in the current port Init Control Word #3
1772 * - current link mode settings in CSR register
1773 * - MDIO vs. I2C PHY control interface chosen
1774 * - SFP module media type
1775 **/
e1000_get_media_type_82575(struct e1000_hw * hw)1776 static s32 e1000_get_media_type_82575(struct e1000_hw *hw)
1777 {
1778 struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1779 s32 ret_val = E1000_SUCCESS;
1780 u32 ctrl_ext = 0;
1781 u32 link_mode = 0;
1782
1783 /* Set internal phy as default */
1784 dev_spec->sgmii_active = FALSE;
1785 dev_spec->module_plugged = FALSE;
1786
1787 /* Get CSR setting */
1788 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1789
1790 /* extract link mode setting */
1791 link_mode = ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK;
1792
1793 switch (link_mode) {
1794 case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
1795 hw->phy.media_type = e1000_media_type_internal_serdes;
1796 break;
1797 case E1000_CTRL_EXT_LINK_MODE_GMII:
1798 hw->phy.media_type = e1000_media_type_copper;
1799 break;
1800 case E1000_CTRL_EXT_LINK_MODE_SGMII:
1801 /* Get phy control interface type set (MDIO vs. I2C)*/
1802 if (e1000_sgmii_uses_mdio_82575(hw)) {
1803 hw->phy.media_type = e1000_media_type_copper;
1804 dev_spec->sgmii_active = TRUE;
1805 break;
1806 }
1807 /* fall through for I2C based SGMII */
1808 case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
1809 /* read media type from SFP EEPROM */
1810 ret_val = e1000_set_sfp_media_type_82575(hw);
1811 if ((ret_val != E1000_SUCCESS) ||
1812 (hw->phy.media_type == e1000_media_type_unknown)) {
1813 /*
1814 * If media type was not identified then return media
1815 * type defined by the CTRL_EXT settings.
1816 */
1817 hw->phy.media_type = e1000_media_type_internal_serdes;
1818
1819 if (link_mode == E1000_CTRL_EXT_LINK_MODE_SGMII) {
1820 hw->phy.media_type = e1000_media_type_copper;
1821 dev_spec->sgmii_active = TRUE;
1822 }
1823
1824 break;
1825 }
1826
1827 /* do not change link mode for 100BaseFX */
1828 if (dev_spec->eth_flags.e100_base_fx)
1829 break;
1830
1831 /* change current link mode setting */
1832 ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
1833
1834 if (hw->phy.media_type == e1000_media_type_copper)
1835 ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_SGMII;
1836 else
1837 ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1838
1839 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1840
1841 break;
1842 }
1843
1844 return ret_val;
1845 }
1846
1847 /**
1848 * e1000_set_sfp_media_type_82575 - derives SFP module media type.
1849 * @hw: pointer to the HW structure
1850 *
1851 * The media type is chosen based on SFP module.
1852 * compatibility flags retrieved from SFP ID EEPROM.
1853 **/
e1000_set_sfp_media_type_82575(struct e1000_hw * hw)1854 static s32 e1000_set_sfp_media_type_82575(struct e1000_hw *hw)
1855 {
1856 s32 ret_val = E1000_ERR_CONFIG;
1857 u32 ctrl_ext = 0;
1858 struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1859 struct sfp_e1000_flags *eth_flags = &dev_spec->eth_flags;
1860 u8 tranceiver_type = 0;
1861 s32 timeout = 3;
1862
1863 /* Turn I2C interface ON and power on sfp cage */
1864 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1865 ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
1866 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext | E1000_CTRL_I2C_ENA);
1867
1868 E1000_WRITE_FLUSH(hw);
1869
1870 /* Read SFP module data */
1871 while (timeout) {
1872 ret_val = e1000_read_sfp_data_byte(hw,
1873 E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_IDENTIFIER_OFFSET),
1874 &tranceiver_type);
1875 if (ret_val == E1000_SUCCESS)
1876 break;
1877 msec_delay(100);
1878 timeout--;
1879 }
1880 if (ret_val != E1000_SUCCESS)
1881 goto out;
1882
1883 ret_val = e1000_read_sfp_data_byte(hw,
1884 E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_ETH_FLAGS_OFFSET),
1885 (u8 *)eth_flags);
1886 if (ret_val != E1000_SUCCESS)
1887 goto out;
1888
1889 /* Check if there is some SFP module plugged and powered */
1890 if ((tranceiver_type == E1000_SFF_IDENTIFIER_SFP) ||
1891 (tranceiver_type == E1000_SFF_IDENTIFIER_SFF)) {
1892 dev_spec->module_plugged = TRUE;
1893 if (eth_flags->e1000_base_lx || eth_flags->e1000_base_sx) {
1894 hw->phy.media_type = e1000_media_type_internal_serdes;
1895 } else if (eth_flags->e100_base_fx) {
1896 dev_spec->sgmii_active = TRUE;
1897 hw->phy.media_type = e1000_media_type_internal_serdes;
1898 } else if (eth_flags->e1000_base_t) {
1899 dev_spec->sgmii_active = TRUE;
1900 hw->phy.media_type = e1000_media_type_copper;
1901 } else {
1902 hw->phy.media_type = e1000_media_type_unknown;
1903 DEBUGOUT("PHY module has not been recognized\n");
1904 goto out;
1905 }
1906 } else {
1907 hw->phy.media_type = e1000_media_type_unknown;
1908 }
1909 ret_val = E1000_SUCCESS;
1910 out:
1911 /* Restore I2C interface setting */
1912 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1913 return ret_val;
1914 }
1915
1916 /**
1917 * e1000_valid_led_default_82575 - Verify a valid default LED config
1918 * @hw: pointer to the HW structure
1919 * @data: pointer to the NVM (EEPROM)
1920 *
1921 * Read the EEPROM for the current default LED configuration. If the
1922 * LED configuration is not valid, set to a valid LED configuration.
1923 **/
e1000_valid_led_default_82575(struct e1000_hw * hw,u16 * data)1924 static s32 e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data)
1925 {
1926 s32 ret_val;
1927
1928 DEBUGFUNC("e1000_valid_led_default_82575");
1929
1930 ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1931 if (ret_val) {
1932 DEBUGOUT("NVM Read Error\n");
1933 goto out;
1934 }
1935
1936 if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
1937 switch (hw->phy.media_type) {
1938 case e1000_media_type_internal_serdes:
1939 *data = ID_LED_DEFAULT_82575_SERDES;
1940 break;
1941 case e1000_media_type_copper:
1942 default:
1943 *data = ID_LED_DEFAULT;
1944 break;
1945 }
1946 }
1947 out:
1948 return ret_val;
1949 }
1950
1951 /**
1952 * e1000_sgmii_active_82575 - Return sgmii state
1953 * @hw: pointer to the HW structure
1954 *
1955 * 82575 silicon has a serialized gigabit media independent interface (sgmii)
1956 * which can be enabled for use in the embedded applications. Simply
1957 * return the current state of the sgmii interface.
1958 **/
e1000_sgmii_active_82575(struct e1000_hw * hw)1959 static bool e1000_sgmii_active_82575(struct e1000_hw *hw)
1960 {
1961 struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1962 return dev_spec->sgmii_active;
1963 }
1964
1965 /**
1966 * e1000_reset_init_script_82575 - Inits HW defaults after reset
1967 * @hw: pointer to the HW structure
1968 *
1969 * Inits recommended HW defaults after a reset when there is no EEPROM
1970 * detected. This is only for the 82575.
1971 **/
e1000_reset_init_script_82575(struct e1000_hw * hw)1972 static s32 e1000_reset_init_script_82575(struct e1000_hw *hw)
1973 {
1974 DEBUGFUNC("e1000_reset_init_script_82575");
1975
1976 if (hw->mac.type == e1000_82575) {
1977 DEBUGOUT("Running reset init script for 82575\n");
1978 /* SerDes configuration via SERDESCTRL */
1979 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x00, 0x0C);
1980 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x01, 0x78);
1981 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x1B, 0x23);
1982 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x23, 0x15);
1983
1984 /* CCM configuration via CCMCTL register */
1985 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x14, 0x00);
1986 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x10, 0x00);
1987
1988 /* PCIe lanes configuration */
1989 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x00, 0xEC);
1990 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x61, 0xDF);
1991 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x34, 0x05);
1992 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x2F, 0x81);
1993
1994 /* PCIe PLL Configuration */
1995 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x02, 0x47);
1996 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x14, 0x00);
1997 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x10, 0x00);
1998 }
1999
2000 return E1000_SUCCESS;
2001 }
2002
2003 /**
2004 * e1000_read_mac_addr_82575 - Read device MAC address
2005 * @hw: pointer to the HW structure
2006 **/
e1000_read_mac_addr_82575(struct e1000_hw * hw)2007 static s32 e1000_read_mac_addr_82575(struct e1000_hw *hw)
2008 {
2009 s32 ret_val;
2010
2011 DEBUGFUNC("e1000_read_mac_addr_82575");
2012
2013 /*
2014 * If there's an alternate MAC address place it in RAR0
2015 * so that it will override the Si installed default perm
2016 * address.
2017 */
2018 ret_val = e1000_check_alt_mac_addr_generic(hw);
2019 if (ret_val)
2020 goto out;
2021
2022 ret_val = e1000_read_mac_addr_generic(hw);
2023
2024 out:
2025 return ret_val;
2026 }
2027
2028 /**
2029 * e1000_config_collision_dist_82575 - Configure collision distance
2030 * @hw: pointer to the HW structure
2031 *
2032 * Configures the collision distance to the default value and is used
2033 * during link setup.
2034 **/
e1000_config_collision_dist_82575(struct e1000_hw * hw)2035 static void e1000_config_collision_dist_82575(struct e1000_hw *hw)
2036 {
2037 u32 tctl_ext;
2038
2039 DEBUGFUNC("e1000_config_collision_dist_82575");
2040
2041 tctl_ext = E1000_READ_REG(hw, E1000_TCTL_EXT);
2042
2043 tctl_ext &= ~E1000_TCTL_EXT_COLD;
2044 tctl_ext |= E1000_COLLISION_DISTANCE << E1000_TCTL_EXT_COLD_SHIFT;
2045
2046 E1000_WRITE_REG(hw, E1000_TCTL_EXT, tctl_ext);
2047 E1000_WRITE_FLUSH(hw);
2048 }
2049
2050 /**
2051 * e1000_power_down_phy_copper_82575 - Remove link during PHY power down
2052 * @hw: pointer to the HW structure
2053 *
2054 * In the case of a PHY power down to save power, or to turn off link during a
2055 * driver unload, or wake on lan is not enabled, remove the link.
2056 **/
e1000_power_down_phy_copper_82575(struct e1000_hw * hw)2057 static void e1000_power_down_phy_copper_82575(struct e1000_hw *hw)
2058 {
2059 struct e1000_phy_info *phy = &hw->phy;
2060
2061 if (!(phy->ops.check_reset_block))
2062 return;
2063
2064 /* If the management interface is not enabled, then power down */
2065 if (!(e1000_enable_mng_pass_thru(hw) || phy->ops.check_reset_block(hw)))
2066 e1000_power_down_phy_copper(hw);
2067
2068 return;
2069 }
2070
2071 /**
2072 * e1000_clear_hw_cntrs_82575 - Clear device specific hardware counters
2073 * @hw: pointer to the HW structure
2074 *
2075 * Clears the hardware counters by reading the counter registers.
2076 **/
e1000_clear_hw_cntrs_82575(struct e1000_hw * hw)2077 static void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw)
2078 {
2079 DEBUGFUNC("e1000_clear_hw_cntrs_82575");
2080
2081 e1000_clear_hw_cntrs_base_generic(hw);
2082
2083 E1000_READ_REG(hw, E1000_PRC64);
2084 E1000_READ_REG(hw, E1000_PRC127);
2085 E1000_READ_REG(hw, E1000_PRC255);
2086 E1000_READ_REG(hw, E1000_PRC511);
2087 E1000_READ_REG(hw, E1000_PRC1023);
2088 E1000_READ_REG(hw, E1000_PRC1522);
2089 E1000_READ_REG(hw, E1000_PTC64);
2090 E1000_READ_REG(hw, E1000_PTC127);
2091 E1000_READ_REG(hw, E1000_PTC255);
2092 E1000_READ_REG(hw, E1000_PTC511);
2093 E1000_READ_REG(hw, E1000_PTC1023);
2094 E1000_READ_REG(hw, E1000_PTC1522);
2095
2096 E1000_READ_REG(hw, E1000_ALGNERRC);
2097 E1000_READ_REG(hw, E1000_RXERRC);
2098 E1000_READ_REG(hw, E1000_TNCRS);
2099 E1000_READ_REG(hw, E1000_CEXTERR);
2100 E1000_READ_REG(hw, E1000_TSCTC);
2101 E1000_READ_REG(hw, E1000_TSCTFC);
2102
2103 E1000_READ_REG(hw, E1000_MGTPRC);
2104 E1000_READ_REG(hw, E1000_MGTPDC);
2105 E1000_READ_REG(hw, E1000_MGTPTC);
2106
2107 E1000_READ_REG(hw, E1000_IAC);
2108 E1000_READ_REG(hw, E1000_ICRXOC);
2109
2110 E1000_READ_REG(hw, E1000_ICRXPTC);
2111 E1000_READ_REG(hw, E1000_ICRXATC);
2112 E1000_READ_REG(hw, E1000_ICTXPTC);
2113 E1000_READ_REG(hw, E1000_ICTXATC);
2114 E1000_READ_REG(hw, E1000_ICTXQEC);
2115 E1000_READ_REG(hw, E1000_ICTXQMTC);
2116 E1000_READ_REG(hw, E1000_ICRXDMTC);
2117
2118 E1000_READ_REG(hw, E1000_CBTMPC);
2119 E1000_READ_REG(hw, E1000_HTDPMC);
2120 E1000_READ_REG(hw, E1000_CBRMPC);
2121 E1000_READ_REG(hw, E1000_RPTHC);
2122 E1000_READ_REG(hw, E1000_HGPTC);
2123 E1000_READ_REG(hw, E1000_HTCBDPC);
2124 E1000_READ_REG(hw, E1000_HGORCL);
2125 E1000_READ_REG(hw, E1000_HGORCH);
2126 E1000_READ_REG(hw, E1000_HGOTCL);
2127 E1000_READ_REG(hw, E1000_HGOTCH);
2128 E1000_READ_REG(hw, E1000_LENERRS);
2129
2130 /* This register should not be read in copper configurations */
2131 if ((hw->phy.media_type == e1000_media_type_internal_serdes) ||
2132 e1000_sgmii_active_82575(hw))
2133 E1000_READ_REG(hw, E1000_SCVPC);
2134 }
2135
2136 /**
2137 * e1000_rx_fifo_flush_82575 - Clean rx fifo after Rx enable
2138 * @hw: pointer to the HW structure
2139 *
2140 * After Rx enable, if manageability is enabled then there is likely some
2141 * bad data at the start of the fifo and possibly in the DMA fifo. This
2142 * function clears the fifos and flushes any packets that came in as rx was
2143 * being enabled.
2144 **/
e1000_rx_fifo_flush_82575(struct e1000_hw * hw)2145 void e1000_rx_fifo_flush_82575(struct e1000_hw *hw)
2146 {
2147 u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
2148 int i, ms_wait;
2149
2150 DEBUGFUNC("e1000_rx_fifo_flush_82575");
2151
2152 /* disable IPv6 options as per hardware errata */
2153 rfctl = E1000_READ_REG(hw, E1000_RFCTL);
2154 rfctl |= E1000_RFCTL_IPV6_EX_DIS;
2155 E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
2156
2157 if (hw->mac.type != e1000_82575 ||
2158 !(E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_RCV_TCO_EN))
2159 return;
2160
2161 /* Disable all Rx queues */
2162 for (i = 0; i < 4; i++) {
2163 rxdctl[i] = E1000_READ_REG(hw, E1000_RXDCTL(i));
2164 E1000_WRITE_REG(hw, E1000_RXDCTL(i),
2165 rxdctl[i] & ~E1000_RXDCTL_QUEUE_ENABLE);
2166 }
2167 /* Poll all queues to verify they have shut down */
2168 for (ms_wait = 0; ms_wait < 10; ms_wait++) {
2169 msec_delay(1);
2170 rx_enabled = 0;
2171 for (i = 0; i < 4; i++)
2172 rx_enabled |= E1000_READ_REG(hw, E1000_RXDCTL(i));
2173 if (!(rx_enabled & E1000_RXDCTL_QUEUE_ENABLE))
2174 break;
2175 }
2176
2177 if (ms_wait == 10)
2178 DEBUGOUT("Queue disable timed out after 10ms\n");
2179
2180 /* Clear RLPML, RCTL.SBP, RFCTL.LEF, and set RCTL.LPE so that all
2181 * incoming packets are rejected. Set enable and wait 2ms so that
2182 * any packet that was coming in as RCTL.EN was set is flushed
2183 */
2184 E1000_WRITE_REG(hw, E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
2185
2186 rlpml = E1000_READ_REG(hw, E1000_RLPML);
2187 E1000_WRITE_REG(hw, E1000_RLPML, 0);
2188
2189 rctl = E1000_READ_REG(hw, E1000_RCTL);
2190 temp_rctl = rctl & ~(E1000_RCTL_EN | E1000_RCTL_SBP);
2191 temp_rctl |= E1000_RCTL_LPE;
2192
2193 E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl);
2194 E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl | E1000_RCTL_EN);
2195 E1000_WRITE_FLUSH(hw);
2196 msec_delay(2);
2197
2198 /* Enable Rx queues that were previously enabled and restore our
2199 * previous state
2200 */
2201 for (i = 0; i < 4; i++)
2202 E1000_WRITE_REG(hw, E1000_RXDCTL(i), rxdctl[i]);
2203 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
2204 E1000_WRITE_FLUSH(hw);
2205
2206 E1000_WRITE_REG(hw, E1000_RLPML, rlpml);
2207 E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
2208
2209 /* Flush receive errors generated by workaround */
2210 E1000_READ_REG(hw, E1000_ROC);
2211 E1000_READ_REG(hw, E1000_RNBC);
2212 E1000_READ_REG(hw, E1000_MPC);
2213 }
2214
2215 /**
2216 * e1000_set_pcie_completion_timeout - set pci-e completion timeout
2217 * @hw: pointer to the HW structure
2218 *
2219 * The defaults for 82575 and 82576 should be in the range of 50us to 50ms,
2220 * however the hardware default for these parts is 500us to 1ms which is less
2221 * than the 10ms recommended by the pci-e spec. To address this we need to
2222 * increase the value to either 10ms to 200ms for capability version 1 config,
2223 * or 16ms to 55ms for version 2.
2224 **/
e1000_set_pcie_completion_timeout(struct e1000_hw * hw)2225 static s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw)
2226 {
2227 u32 gcr = E1000_READ_REG(hw, E1000_GCR);
2228 s32 ret_val = E1000_SUCCESS;
2229 u16 pcie_devctl2;
2230
2231 /* only take action if timeout value is defaulted to 0 */
2232 if (gcr & E1000_GCR_CMPL_TMOUT_MASK)
2233 goto out;
2234
2235 /*
2236 * if capababilities version is type 1 we can write the
2237 * timeout of 10ms to 200ms through the GCR register
2238 */
2239 if (!(gcr & E1000_GCR_CAP_VER2)) {
2240 gcr |= E1000_GCR_CMPL_TMOUT_10ms;
2241 goto out;
2242 }
2243
2244 /*
2245 * for version 2 capabilities we need to write the config space
2246 * directly in order to set the completion timeout value for
2247 * 16ms to 55ms
2248 */
2249 ret_val = e1000_read_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
2250 &pcie_devctl2);
2251 if (ret_val)
2252 goto out;
2253
2254 pcie_devctl2 |= PCIE_DEVICE_CONTROL2_16ms;
2255
2256 ret_val = e1000_write_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
2257 &pcie_devctl2);
2258 out:
2259 /* disable completion timeout resend */
2260 gcr &= ~E1000_GCR_CMPL_TMOUT_RESEND;
2261
2262 E1000_WRITE_REG(hw, E1000_GCR, gcr);
2263 return ret_val;
2264 }
2265
2266 /**
2267 * e1000_vmdq_set_anti_spoofing_pf - enable or disable anti-spoofing
2268 * @hw: pointer to the hardware struct
2269 * @enable: state to enter, either enabled or disabled
2270 * @pf: Physical Function pool - do not set anti-spoofing for the PF
2271 *
2272 * enables/disables L2 switch anti-spoofing functionality.
2273 **/
e1000_vmdq_set_anti_spoofing_pf(struct e1000_hw * hw,bool enable,int pf)2274 void e1000_vmdq_set_anti_spoofing_pf(struct e1000_hw *hw, bool enable, int pf)
2275 {
2276 u32 reg_val, reg_offset;
2277
2278 switch (hw->mac.type) {
2279 case e1000_82576:
2280 reg_offset = E1000_DTXSWC;
2281 break;
2282 case e1000_i350:
2283 case e1000_i354:
2284 reg_offset = E1000_TXSWC;
2285 break;
2286 default:
2287 return;
2288 }
2289
2290 reg_val = E1000_READ_REG(hw, reg_offset);
2291 if (enable) {
2292 reg_val |= (E1000_DTXSWC_MAC_SPOOF_MASK |
2293 E1000_DTXSWC_VLAN_SPOOF_MASK);
2294 /* The PF can spoof - it has to in order to
2295 * support emulation mode NICs
2296 */
2297 reg_val ^= (1 << pf | 1 << (pf + MAX_NUM_VFS));
2298 } else {
2299 reg_val &= ~(E1000_DTXSWC_MAC_SPOOF_MASK |
2300 E1000_DTXSWC_VLAN_SPOOF_MASK);
2301 }
2302 E1000_WRITE_REG(hw, reg_offset, reg_val);
2303 }
2304
2305 /**
2306 * e1000_vmdq_set_loopback_pf - enable or disable vmdq loopback
2307 * @hw: pointer to the hardware struct
2308 * @enable: state to enter, either enabled or disabled
2309 *
2310 * enables/disables L2 switch loopback functionality.
2311 **/
e1000_vmdq_set_loopback_pf(struct e1000_hw * hw,bool enable)2312 void e1000_vmdq_set_loopback_pf(struct e1000_hw *hw, bool enable)
2313 {
2314 u32 dtxswc;
2315
2316 switch (hw->mac.type) {
2317 case e1000_82576:
2318 dtxswc = E1000_READ_REG(hw, E1000_DTXSWC);
2319 if (enable)
2320 dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2321 else
2322 dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2323 E1000_WRITE_REG(hw, E1000_DTXSWC, dtxswc);
2324 break;
2325 case e1000_i350:
2326 case e1000_i354:
2327 dtxswc = E1000_READ_REG(hw, E1000_TXSWC);
2328 if (enable)
2329 dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2330 else
2331 dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2332 E1000_WRITE_REG(hw, E1000_TXSWC, dtxswc);
2333 break;
2334 default:
2335 /* Currently no other hardware supports loopback */
2336 break;
2337 }
2338
2339
2340 }
2341
2342 /**
2343 * e1000_vmdq_set_replication_pf - enable or disable vmdq replication
2344 * @hw: pointer to the hardware struct
2345 * @enable: state to enter, either enabled or disabled
2346 *
2347 * enables/disables replication of packets across multiple pools.
2348 **/
e1000_vmdq_set_replication_pf(struct e1000_hw * hw,bool enable)2349 void e1000_vmdq_set_replication_pf(struct e1000_hw *hw, bool enable)
2350 {
2351 u32 vt_ctl = E1000_READ_REG(hw, E1000_VT_CTL);
2352
2353 if (enable)
2354 vt_ctl |= E1000_VT_CTL_VM_REPL_EN;
2355 else
2356 vt_ctl &= ~E1000_VT_CTL_VM_REPL_EN;
2357
2358 E1000_WRITE_REG(hw, E1000_VT_CTL, vt_ctl);
2359 }
2360
2361 /**
2362 * e1000_read_phy_reg_82580 - Read 82580 MDI control register
2363 * @hw: pointer to the HW structure
2364 * @offset: register offset to be read
2365 * @data: pointer to the read data
2366 *
2367 * Reads the MDI control register in the PHY at offset and stores the
2368 * information read to data.
2369 **/
e1000_read_phy_reg_82580(struct e1000_hw * hw,u32 offset,u16 * data)2370 static s32 e1000_read_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 *data)
2371 {
2372 s32 ret_val;
2373
2374 DEBUGFUNC("e1000_read_phy_reg_82580");
2375
2376 ret_val = hw->phy.ops.acquire(hw);
2377 if (ret_val)
2378 goto out;
2379
2380 ret_val = e1000_read_phy_reg_mdic(hw, offset, data);
2381
2382 hw->phy.ops.release(hw);
2383
2384 out:
2385 return ret_val;
2386 }
2387
2388 /**
2389 * e1000_write_phy_reg_82580 - Write 82580 MDI control register
2390 * @hw: pointer to the HW structure
2391 * @offset: register offset to write to
2392 * @data: data to write to register at offset
2393 *
2394 * Writes data to MDI control register in the PHY at offset.
2395 **/
e1000_write_phy_reg_82580(struct e1000_hw * hw,u32 offset,u16 data)2396 static s32 e1000_write_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 data)
2397 {
2398 s32 ret_val;
2399
2400 DEBUGFUNC("e1000_write_phy_reg_82580");
2401
2402 ret_val = hw->phy.ops.acquire(hw);
2403 if (ret_val)
2404 goto out;
2405
2406 ret_val = e1000_write_phy_reg_mdic(hw, offset, data);
2407
2408 hw->phy.ops.release(hw);
2409
2410 out:
2411 return ret_val;
2412 }
2413
2414 /**
2415 * e1000_reset_mdicnfg_82580 - Reset MDICNFG destination and com_mdio bits
2416 * @hw: pointer to the HW structure
2417 *
2418 * This resets the the MDICNFG.Destination and MDICNFG.Com_MDIO bits based on
2419 * the values found in the EEPROM. This addresses an issue in which these
2420 * bits are not restored from EEPROM after reset.
2421 **/
e1000_reset_mdicnfg_82580(struct e1000_hw * hw)2422 static s32 e1000_reset_mdicnfg_82580(struct e1000_hw *hw)
2423 {
2424 s32 ret_val = E1000_SUCCESS;
2425 u32 mdicnfg;
2426 u16 nvm_data = 0;
2427
2428 DEBUGFUNC("e1000_reset_mdicnfg_82580");
2429
2430 if (hw->mac.type != e1000_82580)
2431 goto out;
2432 if (!e1000_sgmii_active_82575(hw))
2433 goto out;
2434
2435 ret_val = hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A +
2436 NVM_82580_LAN_FUNC_OFFSET(hw->bus.func), 1,
2437 &nvm_data);
2438 if (ret_val) {
2439 DEBUGOUT("NVM Read Error\n");
2440 goto out;
2441 }
2442
2443 mdicnfg = E1000_READ_REG(hw, E1000_MDICNFG);
2444 if (nvm_data & NVM_WORD24_EXT_MDIO)
2445 mdicnfg |= E1000_MDICNFG_EXT_MDIO;
2446 if (nvm_data & NVM_WORD24_COM_MDIO)
2447 mdicnfg |= E1000_MDICNFG_COM_MDIO;
2448 E1000_WRITE_REG(hw, E1000_MDICNFG, mdicnfg);
2449 out:
2450 return ret_val;
2451 }
2452
2453 /**
2454 * e1000_reset_hw_82580 - Reset hardware
2455 * @hw: pointer to the HW structure
2456 *
2457 * This resets function or entire device (all ports, etc.)
2458 * to a known state.
2459 **/
e1000_reset_hw_82580(struct e1000_hw * hw)2460 static s32 e1000_reset_hw_82580(struct e1000_hw *hw)
2461 {
2462 s32 ret_val = E1000_SUCCESS;
2463 /* BH SW mailbox bit in SW_FW_SYNC */
2464 u16 swmbsw_mask = E1000_SW_SYNCH_MB;
2465 u32 ctrl;
2466 bool global_device_reset = hw->dev_spec._82575.global_device_reset;
2467
2468 DEBUGFUNC("e1000_reset_hw_82580");
2469
2470 hw->dev_spec._82575.global_device_reset = FALSE;
2471
2472 /* 82580 does not reliably do global_device_reset due to hw errata */
2473 if (hw->mac.type == e1000_82580)
2474 global_device_reset = FALSE;
2475
2476 /* Get current control state. */
2477 ctrl = E1000_READ_REG(hw, E1000_CTRL);
2478
2479 /*
2480 * Prevent the PCI-E bus from sticking if there is no TLP connection
2481 * on the last TLP read/write transaction when MAC is reset.
2482 */
2483 ret_val = e1000_disable_pcie_master_generic(hw);
2484 if (ret_val)
2485 DEBUGOUT("PCI-E Master disable polling has failed.\n");
2486
2487 DEBUGOUT("Masking off all interrupts\n");
2488 E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
2489 E1000_WRITE_REG(hw, E1000_RCTL, 0);
2490 E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
2491 E1000_WRITE_FLUSH(hw);
2492
2493 msec_delay(10);
2494
2495 /* Determine whether or not a global dev reset is requested */
2496 if (global_device_reset && hw->mac.ops.acquire_swfw_sync(hw,
2497 swmbsw_mask))
2498 global_device_reset = FALSE;
2499
2500 if (global_device_reset && !(E1000_READ_REG(hw, E1000_STATUS) &
2501 E1000_STAT_DEV_RST_SET))
2502 ctrl |= E1000_CTRL_DEV_RST;
2503 else
2504 ctrl |= E1000_CTRL_RST;
2505
2506 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
2507
2508 switch (hw->device_id) {
2509 case E1000_DEV_ID_DH89XXCC_SGMII:
2510 break;
2511 default:
2512 E1000_WRITE_FLUSH(hw);
2513 break;
2514 }
2515
2516 /* Add delay to insure DEV_RST or RST has time to complete */
2517 msec_delay(5);
2518
2519 ret_val = e1000_get_auto_rd_done_generic(hw);
2520 if (ret_val) {
2521 /*
2522 * When auto config read does not complete, do not
2523 * return with an error. This can happen in situations
2524 * where there is no eeprom and prevents getting link.
2525 */
2526 DEBUGOUT("Auto Read Done did not complete\n");
2527 }
2528
2529 /* clear global device reset status bit */
2530 E1000_WRITE_REG(hw, E1000_STATUS, E1000_STAT_DEV_RST_SET);
2531
2532 /* Clear any pending interrupt events. */
2533 E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
2534 E1000_READ_REG(hw, E1000_ICR);
2535
2536 ret_val = e1000_reset_mdicnfg_82580(hw);
2537 if (ret_val)
2538 DEBUGOUT("Could not reset MDICNFG based on EEPROM\n");
2539
2540 /* Install any alternate MAC address into RAR0 */
2541 ret_val = e1000_check_alt_mac_addr_generic(hw);
2542
2543 /* Release semaphore */
2544 if (global_device_reset)
2545 hw->mac.ops.release_swfw_sync(hw, swmbsw_mask);
2546
2547 return ret_val;
2548 }
2549
2550 /**
2551 * e1000_rxpbs_adjust_82580 - adjust RXPBS value to reflect actual Rx PBA size
2552 * @data: data received by reading RXPBS register
2553 *
2554 * The 82580 uses a table based approach for packet buffer allocation sizes.
2555 * This function converts the retrieved value into the correct table value
2556 * 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7
2557 * 0x0 36 72 144 1 2 4 8 16
2558 * 0x8 35 70 140 rsv rsv rsv rsv rsv
2559 */
e1000_rxpbs_adjust_82580(u32 data)2560 u16 e1000_rxpbs_adjust_82580(u32 data)
2561 {
2562 u16 ret_val = 0;
2563
2564 if (data < E1000_82580_RXPBS_TABLE_SIZE)
2565 ret_val = e1000_82580_rxpbs_table[data];
2566
2567 return ret_val;
2568 }
2569
2570 /**
2571 * e1000_validate_nvm_checksum_with_offset - Validate EEPROM
2572 * checksum
2573 * @hw: pointer to the HW structure
2574 * @offset: offset in words of the checksum protected region
2575 *
2576 * Calculates the EEPROM checksum by reading/adding each word of the EEPROM
2577 * and then verifies that the sum of the EEPROM is equal to 0xBABA.
2578 **/
e1000_validate_nvm_checksum_with_offset(struct e1000_hw * hw,u16 offset)2579 s32 e1000_validate_nvm_checksum_with_offset(struct e1000_hw *hw, u16 offset)
2580 {
2581 s32 ret_val = E1000_SUCCESS;
2582 u16 checksum = 0;
2583 u16 i, nvm_data;
2584
2585 DEBUGFUNC("e1000_validate_nvm_checksum_with_offset");
2586
2587 for (i = offset; i < ((NVM_CHECKSUM_REG + offset) + 1); i++) {
2588 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
2589 if (ret_val) {
2590 DEBUGOUT("NVM Read Error\n");
2591 goto out;
2592 }
2593 checksum += nvm_data;
2594 }
2595
2596 if (checksum != (u16) NVM_SUM) {
2597 DEBUGOUT("NVM Checksum Invalid\n");
2598 ret_val = -E1000_ERR_NVM;
2599 goto out;
2600 }
2601
2602 out:
2603 return ret_val;
2604 }
2605
2606 /**
2607 * e1000_update_nvm_checksum_with_offset - Update EEPROM
2608 * checksum
2609 * @hw: pointer to the HW structure
2610 * @offset: offset in words of the checksum protected region
2611 *
2612 * Updates the EEPROM checksum by reading/adding each word of the EEPROM
2613 * up to the checksum. Then calculates the EEPROM checksum and writes the
2614 * value to the EEPROM.
2615 **/
e1000_update_nvm_checksum_with_offset(struct e1000_hw * hw,u16 offset)2616 s32 e1000_update_nvm_checksum_with_offset(struct e1000_hw *hw, u16 offset)
2617 {
2618 s32 ret_val;
2619 u16 checksum = 0;
2620 u16 i, nvm_data;
2621
2622 DEBUGFUNC("e1000_update_nvm_checksum_with_offset");
2623
2624 for (i = offset; i < (NVM_CHECKSUM_REG + offset); i++) {
2625 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
2626 if (ret_val) {
2627 DEBUGOUT("NVM Read Error while updating checksum.\n");
2628 goto out;
2629 }
2630 checksum += nvm_data;
2631 }
2632 checksum = (u16) NVM_SUM - checksum;
2633 ret_val = hw->nvm.ops.write(hw, (NVM_CHECKSUM_REG + offset), 1,
2634 &checksum);
2635 if (ret_val)
2636 DEBUGOUT("NVM Write Error while updating checksum.\n");
2637
2638 out:
2639 return ret_val;
2640 }
2641
2642 /**
2643 * e1000_validate_nvm_checksum_82580 - Validate EEPROM checksum
2644 * @hw: pointer to the HW structure
2645 *
2646 * Calculates the EEPROM section checksum by reading/adding each word of
2647 * the EEPROM and then verifies that the sum of the EEPROM is
2648 * equal to 0xBABA.
2649 **/
e1000_validate_nvm_checksum_82580(struct e1000_hw * hw)2650 static s32 e1000_validate_nvm_checksum_82580(struct e1000_hw *hw)
2651 {
2652 s32 ret_val;
2653 u16 eeprom_regions_count = 1;
2654 u16 j, nvm_data;
2655 u16 nvm_offset;
2656
2657 DEBUGFUNC("e1000_validate_nvm_checksum_82580");
2658
2659 ret_val = hw->nvm.ops.read(hw, NVM_COMPATIBILITY_REG_3, 1, &nvm_data);
2660 if (ret_val) {
2661 DEBUGOUT("NVM Read Error\n");
2662 goto out;
2663 }
2664
2665 if (nvm_data & NVM_COMPATIBILITY_BIT_MASK) {
2666 /* if chekcsums compatibility bit is set validate checksums
2667 * for all 4 ports. */
2668 eeprom_regions_count = 4;
2669 }
2670
2671 for (j = 0; j < eeprom_regions_count; j++) {
2672 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2673 ret_val = e1000_validate_nvm_checksum_with_offset(hw,
2674 nvm_offset);
2675 if (ret_val != E1000_SUCCESS)
2676 goto out;
2677 }
2678
2679 out:
2680 return ret_val;
2681 }
2682
2683 /**
2684 * e1000_update_nvm_checksum_82580 - Update EEPROM checksum
2685 * @hw: pointer to the HW structure
2686 *
2687 * Updates the EEPROM section checksums for all 4 ports by reading/adding
2688 * each word of the EEPROM up to the checksum. Then calculates the EEPROM
2689 * checksum and writes the value to the EEPROM.
2690 **/
e1000_update_nvm_checksum_82580(struct e1000_hw * hw)2691 static s32 e1000_update_nvm_checksum_82580(struct e1000_hw *hw)
2692 {
2693 s32 ret_val;
2694 u16 j, nvm_data;
2695 u16 nvm_offset;
2696
2697 DEBUGFUNC("e1000_update_nvm_checksum_82580");
2698
2699 ret_val = hw->nvm.ops.read(hw, NVM_COMPATIBILITY_REG_3, 1, &nvm_data);
2700 if (ret_val) {
2701 DEBUGOUT("NVM Read Error while updating checksum compatibility bit.\n");
2702 goto out;
2703 }
2704
2705 if (!(nvm_data & NVM_COMPATIBILITY_BIT_MASK)) {
2706 /* set compatibility bit to validate checksums appropriately */
2707 nvm_data = nvm_data | NVM_COMPATIBILITY_BIT_MASK;
2708 ret_val = hw->nvm.ops.write(hw, NVM_COMPATIBILITY_REG_3, 1,
2709 &nvm_data);
2710 if (ret_val) {
2711 DEBUGOUT("NVM Write Error while updating checksum compatibility bit.\n");
2712 goto out;
2713 }
2714 }
2715
2716 for (j = 0; j < 4; j++) {
2717 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2718 ret_val = e1000_update_nvm_checksum_with_offset(hw, nvm_offset);
2719 if (ret_val)
2720 goto out;
2721 }
2722
2723 out:
2724 return ret_val;
2725 }
2726
2727 /**
2728 * e1000_validate_nvm_checksum_i350 - Validate EEPROM checksum
2729 * @hw: pointer to the HW structure
2730 *
2731 * Calculates the EEPROM section checksum by reading/adding each word of
2732 * the EEPROM and then verifies that the sum of the EEPROM is
2733 * equal to 0xBABA.
2734 **/
e1000_validate_nvm_checksum_i350(struct e1000_hw * hw)2735 static s32 e1000_validate_nvm_checksum_i350(struct e1000_hw *hw)
2736 {
2737 s32 ret_val = E1000_SUCCESS;
2738 u16 j;
2739 u16 nvm_offset;
2740
2741 DEBUGFUNC("e1000_validate_nvm_checksum_i350");
2742
2743 for (j = 0; j < 4; j++) {
2744 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2745 ret_val = e1000_validate_nvm_checksum_with_offset(hw,
2746 nvm_offset);
2747 if (ret_val != E1000_SUCCESS)
2748 goto out;
2749 }
2750
2751 out:
2752 return ret_val;
2753 }
2754
2755 /**
2756 * e1000_update_nvm_checksum_i350 - Update EEPROM checksum
2757 * @hw: pointer to the HW structure
2758 *
2759 * Updates the EEPROM section checksums for all 4 ports by reading/adding
2760 * each word of the EEPROM up to the checksum. Then calculates the EEPROM
2761 * checksum and writes the value to the EEPROM.
2762 **/
e1000_update_nvm_checksum_i350(struct e1000_hw * hw)2763 static s32 e1000_update_nvm_checksum_i350(struct e1000_hw *hw)
2764 {
2765 s32 ret_val = E1000_SUCCESS;
2766 u16 j;
2767 u16 nvm_offset;
2768
2769 DEBUGFUNC("e1000_update_nvm_checksum_i350");
2770
2771 for (j = 0; j < 4; j++) {
2772 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2773 ret_val = e1000_update_nvm_checksum_with_offset(hw, nvm_offset);
2774 if (ret_val != E1000_SUCCESS)
2775 goto out;
2776 }
2777
2778 out:
2779 return ret_val;
2780 }
2781
2782 /**
2783 * __e1000_access_emi_reg - Read/write EMI register
2784 * @hw: pointer to the HW structure
2785 * @addr: EMI address to program
2786 * @data: pointer to value to read/write from/to the EMI address
2787 * @read: boolean flag to indicate read or write
2788 **/
__e1000_access_emi_reg(struct e1000_hw * hw,u16 address,u16 * data,bool read)2789 static s32 __e1000_access_emi_reg(struct e1000_hw *hw, u16 address,
2790 u16 *data, bool read)
2791 {
2792 s32 ret_val;
2793
2794 DEBUGFUNC("__e1000_access_emi_reg");
2795
2796 ret_val = hw->phy.ops.write_reg(hw, E1000_EMIADD, address);
2797 if (ret_val)
2798 return ret_val;
2799
2800 if (read)
2801 ret_val = hw->phy.ops.read_reg(hw, E1000_EMIDATA, data);
2802 else
2803 ret_val = hw->phy.ops.write_reg(hw, E1000_EMIDATA, *data);
2804
2805 return ret_val;
2806 }
2807
2808 /**
2809 * e1000_read_emi_reg - Read Extended Management Interface register
2810 * @hw: pointer to the HW structure
2811 * @addr: EMI address to program
2812 * @data: value to be read from the EMI address
2813 **/
e1000_read_emi_reg(struct e1000_hw * hw,u16 addr,u16 * data)2814 s32 e1000_read_emi_reg(struct e1000_hw *hw, u16 addr, u16 *data)
2815 {
2816 DEBUGFUNC("e1000_read_emi_reg");
2817
2818 return __e1000_access_emi_reg(hw, addr, data, TRUE);
2819 }
2820
2821 /**
2822 * e1000_initialize_M88E1512_phy - Initialize M88E1512 PHY
2823 * @hw: pointer to the HW structure
2824 *
2825 * Initialize Marvell 1512 to work correctly with Avoton.
2826 **/
e1000_initialize_M88E1512_phy(struct e1000_hw * hw)2827 s32 e1000_initialize_M88E1512_phy(struct e1000_hw *hw)
2828 {
2829 struct e1000_phy_info *phy = &hw->phy;
2830 s32 ret_val = E1000_SUCCESS;
2831
2832 DEBUGFUNC("e1000_initialize_M88E1512_phy");
2833
2834 /* Check if this is correct PHY. */
2835 if (phy->id != M88E1512_E_PHY_ID)
2836 goto out;
2837
2838 /* Switch to PHY page 0xFF. */
2839 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FF);
2840 if (ret_val)
2841 goto out;
2842
2843 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x214B);
2844 if (ret_val)
2845 goto out;
2846
2847 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2144);
2848 if (ret_val)
2849 goto out;
2850
2851 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x0C28);
2852 if (ret_val)
2853 goto out;
2854
2855 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2146);
2856 if (ret_val)
2857 goto out;
2858
2859 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xB233);
2860 if (ret_val)
2861 goto out;
2862
2863 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x214D);
2864 if (ret_val)
2865 goto out;
2866
2867 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xCC0C);
2868 if (ret_val)
2869 goto out;
2870
2871 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2159);
2872 if (ret_val)
2873 goto out;
2874
2875 /* Switch to PHY page 0xFB. */
2876 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FB);
2877 if (ret_val)
2878 goto out;
2879
2880 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_3, 0x000D);
2881 if (ret_val)
2882 goto out;
2883
2884 /* Switch to PHY page 0x12. */
2885 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x12);
2886 if (ret_val)
2887 goto out;
2888
2889 /* Change mode to SGMII-to-Copper */
2890 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_MODE, 0x8001);
2891 if (ret_val)
2892 goto out;
2893
2894 /* Return the PHY to page 0. */
2895 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
2896 if (ret_val)
2897 goto out;
2898
2899 ret_val = phy->ops.commit(hw);
2900 if (ret_val) {
2901 DEBUGOUT("Error committing the PHY changes\n");
2902 return ret_val;
2903 }
2904
2905 msec_delay(1000);
2906 out:
2907 return ret_val;
2908 }
2909
2910 /**
2911 * e1000_initialize_M88E1543_phy - Initialize M88E1543 PHY
2912 * @hw: pointer to the HW structure
2913 *
2914 * Initialize Marvell 1543 to work correctly with Avoton.
2915 **/
e1000_initialize_M88E1543_phy(struct e1000_hw * hw)2916 s32 e1000_initialize_M88E1543_phy(struct e1000_hw *hw)
2917 {
2918 struct e1000_phy_info *phy = &hw->phy;
2919 s32 ret_val = E1000_SUCCESS;
2920
2921 DEBUGFUNC("e1000_initialize_M88E1543_phy");
2922
2923 /* Check if this is correct PHY. */
2924 if (phy->id != M88E1543_E_PHY_ID)
2925 goto out;
2926
2927 /* Switch to PHY page 0xFF. */
2928 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FF);
2929 if (ret_val)
2930 goto out;
2931
2932 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x214B);
2933 if (ret_val)
2934 goto out;
2935
2936 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2144);
2937 if (ret_val)
2938 goto out;
2939
2940 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x0C28);
2941 if (ret_val)
2942 goto out;
2943
2944 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2146);
2945 if (ret_val)
2946 goto out;
2947
2948 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xB233);
2949 if (ret_val)
2950 goto out;
2951
2952 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x214D);
2953 if (ret_val)
2954 goto out;
2955
2956 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xDC0C);
2957 if (ret_val)
2958 goto out;
2959
2960 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2159);
2961 if (ret_val)
2962 goto out;
2963
2964 /* Switch to PHY page 0xFB. */
2965 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FB);
2966 if (ret_val)
2967 goto out;
2968
2969 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_3, 0xC00D);
2970 if (ret_val)
2971 goto out;
2972
2973 /* Switch to PHY page 0x12. */
2974 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x12);
2975 if (ret_val)
2976 goto out;
2977
2978 /* Change mode to SGMII-to-Copper */
2979 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_MODE, 0x8001);
2980 if (ret_val)
2981 goto out;
2982
2983 /* Switch to PHY page 1. */
2984 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x1);
2985 if (ret_val)
2986 goto out;
2987
2988 /* Change mode to 1000BASE-X/SGMII and autoneg enable; reset */
2989 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_FIBER_CTRL, 0x9140);
2990 if (ret_val)
2991 goto out;
2992
2993 /* Return the PHY to page 0. */
2994 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
2995 if (ret_val)
2996 goto out;
2997
2998 ret_val = phy->ops.commit(hw);
2999 if (ret_val) {
3000 DEBUGOUT("Error committing the PHY changes\n");
3001 return ret_val;
3002 }
3003
3004 msec_delay(1000);
3005 out:
3006 return ret_val;
3007 }
3008
3009 /**
3010 * e1000_set_eee_i350 - Enable/disable EEE support
3011 * @hw: pointer to the HW structure
3012 * @adv1g: boolean flag enabling 1G EEE advertisement
3013 * @adv100m: boolean flag enabling 100M EEE advertisement
3014 *
3015 * Enable/disable EEE based on setting in dev_spec structure.
3016 *
3017 **/
e1000_set_eee_i350(struct e1000_hw * hw,bool adv1G,bool adv100M)3018 s32 e1000_set_eee_i350(struct e1000_hw *hw, bool adv1G, bool adv100M)
3019 {
3020 u32 ipcnfg, eeer;
3021
3022 DEBUGFUNC("e1000_set_eee_i350");
3023
3024 if ((hw->mac.type < e1000_i350) ||
3025 (hw->phy.media_type != e1000_media_type_copper))
3026 goto out;
3027 ipcnfg = E1000_READ_REG(hw, E1000_IPCNFG);
3028 eeer = E1000_READ_REG(hw, E1000_EEER);
3029
3030 /* enable or disable per user setting */
3031 if (!(hw->dev_spec._82575.eee_disable)) {
3032 u32 eee_su = E1000_READ_REG(hw, E1000_EEE_SU);
3033
3034 if (adv100M)
3035 ipcnfg |= E1000_IPCNFG_EEE_100M_AN;
3036 else
3037 ipcnfg &= ~E1000_IPCNFG_EEE_100M_AN;
3038
3039 if (adv1G)
3040 ipcnfg |= E1000_IPCNFG_EEE_1G_AN;
3041 else
3042 ipcnfg &= ~E1000_IPCNFG_EEE_1G_AN;
3043
3044 eeer |= (E1000_EEER_TX_LPI_EN | E1000_EEER_RX_LPI_EN |
3045 E1000_EEER_LPI_FC);
3046
3047 /* This bit should not be set in normal operation. */
3048 if (eee_su & E1000_EEE_SU_LPI_CLK_STP)
3049 DEBUGOUT("LPI Clock Stop Bit should not be set!\n");
3050 } else {
3051 ipcnfg &= ~(E1000_IPCNFG_EEE_1G_AN | E1000_IPCNFG_EEE_100M_AN);
3052 eeer &= ~(E1000_EEER_TX_LPI_EN | E1000_EEER_RX_LPI_EN |
3053 E1000_EEER_LPI_FC);
3054 }
3055 E1000_WRITE_REG(hw, E1000_IPCNFG, ipcnfg);
3056 E1000_WRITE_REG(hw, E1000_EEER, eeer);
3057 E1000_READ_REG(hw, E1000_IPCNFG);
3058 E1000_READ_REG(hw, E1000_EEER);
3059 out:
3060
3061 return E1000_SUCCESS;
3062 }
3063
3064 /**
3065 * e1000_set_eee_i354 - Enable/disable EEE support
3066 * @hw: pointer to the HW structure
3067 * @adv1g: boolean flag enabling 1G EEE advertisement
3068 * @adv100m: boolean flag enabling 100M EEE advertisement
3069 *
3070 * Enable/disable EEE legacy mode based on setting in dev_spec structure.
3071 *
3072 **/
e1000_set_eee_i354(struct e1000_hw * hw,bool adv1G,bool adv100M)3073 s32 e1000_set_eee_i354(struct e1000_hw *hw, bool adv1G, bool adv100M)
3074 {
3075 struct e1000_phy_info *phy = &hw->phy;
3076 s32 ret_val = E1000_SUCCESS;
3077 u16 phy_data;
3078
3079 DEBUGFUNC("e1000_set_eee_i354");
3080
3081 if ((hw->phy.media_type != e1000_media_type_copper) ||
3082 ((phy->id != M88E1543_E_PHY_ID) &&
3083 (phy->id != M88E1512_E_PHY_ID)))
3084 goto out;
3085
3086 if (!hw->dev_spec._82575.eee_disable) {
3087 /* Switch to PHY page 18. */
3088 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 18);
3089 if (ret_val)
3090 goto out;
3091
3092 ret_val = phy->ops.read_reg(hw, E1000_M88E1543_EEE_CTRL_1,
3093 &phy_data);
3094 if (ret_val)
3095 goto out;
3096
3097 phy_data |= E1000_M88E1543_EEE_CTRL_1_MS;
3098 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_EEE_CTRL_1,
3099 phy_data);
3100 if (ret_val)
3101 goto out;
3102
3103 /* Return the PHY to page 0. */
3104 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
3105 if (ret_val)
3106 goto out;
3107
3108 /* Turn on EEE advertisement. */
3109 ret_val = e1000_read_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3110 E1000_EEE_ADV_DEV_I354,
3111 &phy_data);
3112 if (ret_val)
3113 goto out;
3114
3115 if (adv100M)
3116 phy_data |= E1000_EEE_ADV_100_SUPPORTED;
3117 else
3118 phy_data &= ~E1000_EEE_ADV_100_SUPPORTED;
3119
3120 if (adv1G)
3121 phy_data |= E1000_EEE_ADV_1000_SUPPORTED;
3122 else
3123 phy_data &= ~E1000_EEE_ADV_1000_SUPPORTED;
3124
3125 ret_val = e1000_write_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3126 E1000_EEE_ADV_DEV_I354,
3127 phy_data);
3128 } else {
3129 /* Turn off EEE advertisement. */
3130 ret_val = e1000_read_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3131 E1000_EEE_ADV_DEV_I354,
3132 &phy_data);
3133 if (ret_val)
3134 goto out;
3135
3136 phy_data &= ~(E1000_EEE_ADV_100_SUPPORTED |
3137 E1000_EEE_ADV_1000_SUPPORTED);
3138 ret_val = e1000_write_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3139 E1000_EEE_ADV_DEV_I354,
3140 phy_data);
3141 }
3142
3143 out:
3144 return ret_val;
3145 }
3146
3147 /**
3148 * e1000_get_eee_status_i354 - Get EEE status
3149 * @hw: pointer to the HW structure
3150 * @status: EEE status
3151 *
3152 * Get EEE status by guessing based on whether Tx or Rx LPI indications have
3153 * been received.
3154 **/
e1000_get_eee_status_i354(struct e1000_hw * hw,bool * status)3155 s32 e1000_get_eee_status_i354(struct e1000_hw *hw, bool *status)
3156 {
3157 struct e1000_phy_info *phy = &hw->phy;
3158 s32 ret_val = E1000_SUCCESS;
3159 u16 phy_data;
3160
3161 DEBUGFUNC("e1000_get_eee_status_i354");
3162
3163 /* Check if EEE is supported on this device. */
3164 if ((hw->phy.media_type != e1000_media_type_copper) ||
3165 ((phy->id != M88E1543_E_PHY_ID) &&
3166 (phy->id != M88E1512_E_PHY_ID)))
3167 goto out;
3168
3169 ret_val = e1000_read_xmdio_reg(hw, E1000_PCS_STATUS_ADDR_I354,
3170 E1000_PCS_STATUS_DEV_I354,
3171 &phy_data);
3172 if (ret_val)
3173 goto out;
3174
3175 *status = phy_data & (E1000_PCS_STATUS_TX_LPI_RCVD |
3176 E1000_PCS_STATUS_RX_LPI_RCVD) ? TRUE : FALSE;
3177
3178 out:
3179 return ret_val;
3180 }
3181
3182 /* Due to a hw errata, if the host tries to configure the VFTA register
3183 * while performing queries from the BMC or DMA, then the VFTA in some
3184 * cases won't be written.
3185 */
3186
3187 /**
3188 * e1000_clear_vfta_i350 - Clear VLAN filter table
3189 * @hw: pointer to the HW structure
3190 *
3191 * Clears the register array which contains the VLAN filter table by
3192 * setting all the values to 0.
3193 **/
e1000_clear_vfta_i350(struct e1000_hw * hw)3194 void e1000_clear_vfta_i350(struct e1000_hw *hw)
3195 {
3196 u32 offset;
3197 int i;
3198
3199 DEBUGFUNC("e1000_clear_vfta_350");
3200
3201 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
3202 for (i = 0; i < 10; i++)
3203 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
3204
3205 E1000_WRITE_FLUSH(hw);
3206 }
3207 }
3208
3209 /**
3210 * e1000_write_vfta_i350 - Write value to VLAN filter table
3211 * @hw: pointer to the HW structure
3212 * @offset: register offset in VLAN filter table
3213 * @value: register value written to VLAN filter table
3214 *
3215 * Writes value at the given offset in the register array which stores
3216 * the VLAN filter table.
3217 **/
e1000_write_vfta_i350(struct e1000_hw * hw,u32 offset,u32 value)3218 void e1000_write_vfta_i350(struct e1000_hw *hw, u32 offset, u32 value)
3219 {
3220 int i;
3221
3222 DEBUGFUNC("e1000_write_vfta_350");
3223
3224 for (i = 0; i < 10; i++)
3225 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
3226
3227 E1000_WRITE_FLUSH(hw);
3228 }
3229
3230
3231 /**
3232 * e1000_set_i2c_bb - Enable I2C bit-bang
3233 * @hw: pointer to the HW structure
3234 *
3235 * Enable I2C bit-bang interface
3236 *
3237 **/
e1000_set_i2c_bb(struct e1000_hw * hw)3238 s32 e1000_set_i2c_bb(struct e1000_hw *hw)
3239 {
3240 s32 ret_val = E1000_SUCCESS;
3241 u32 ctrl_ext, i2cparams;
3242
3243 DEBUGFUNC("e1000_set_i2c_bb");
3244
3245 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
3246 ctrl_ext |= E1000_CTRL_I2C_ENA;
3247 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
3248 E1000_WRITE_FLUSH(hw);
3249
3250 i2cparams = E1000_READ_REG(hw, E1000_I2CPARAMS);
3251 i2cparams |= E1000_I2CBB_EN;
3252 i2cparams |= E1000_I2C_DATA_OE_N;
3253 i2cparams |= E1000_I2C_CLK_OE_N;
3254 E1000_WRITE_REG(hw, E1000_I2CPARAMS, i2cparams);
3255 E1000_WRITE_FLUSH(hw);
3256
3257 return ret_val;
3258 }
3259
3260 /**
3261 * e1000_read_i2c_byte_generic - Reads 8 bit word over I2C
3262 * @hw: pointer to hardware structure
3263 * @byte_offset: byte offset to read
3264 * @dev_addr: device address
3265 * @data: value read
3266 *
3267 * Performs byte read operation over I2C interface at
3268 * a specified device address.
3269 **/
e1000_read_i2c_byte_generic(struct e1000_hw * hw,u8 byte_offset,u8 dev_addr,u8 * data)3270 s32 e1000_read_i2c_byte_generic(struct e1000_hw *hw, u8 byte_offset,
3271 u8 dev_addr, u8 *data)
3272 {
3273 s32 status = E1000_SUCCESS;
3274 u32 max_retry = 10;
3275 u32 retry = 1;
3276 u16 swfw_mask = 0;
3277
3278 bool nack = TRUE;
3279
3280 DEBUGFUNC("e1000_read_i2c_byte_generic");
3281
3282 swfw_mask = E1000_SWFW_PHY0_SM;
3283
3284 do {
3285 if (hw->mac.ops.acquire_swfw_sync(hw, swfw_mask)
3286 != E1000_SUCCESS) {
3287 status = E1000_ERR_SWFW_SYNC;
3288 goto read_byte_out;
3289 }
3290
3291 e1000_i2c_start(hw);
3292
3293 /* Device Address and write indication */
3294 status = e1000_clock_out_i2c_byte(hw, dev_addr);
3295 if (status != E1000_SUCCESS)
3296 goto fail;
3297
3298 status = e1000_get_i2c_ack(hw);
3299 if (status != E1000_SUCCESS)
3300 goto fail;
3301
3302 status = e1000_clock_out_i2c_byte(hw, byte_offset);
3303 if (status != E1000_SUCCESS)
3304 goto fail;
3305
3306 status = e1000_get_i2c_ack(hw);
3307 if (status != E1000_SUCCESS)
3308 goto fail;
3309
3310 e1000_i2c_start(hw);
3311
3312 /* Device Address and read indication */
3313 status = e1000_clock_out_i2c_byte(hw, (dev_addr | 0x1));
3314 if (status != E1000_SUCCESS)
3315 goto fail;
3316
3317 status = e1000_get_i2c_ack(hw);
3318 if (status != E1000_SUCCESS)
3319 goto fail;
3320
3321 status = e1000_clock_in_i2c_byte(hw, data);
3322 if (status != E1000_SUCCESS)
3323 goto fail;
3324
3325 status = e1000_clock_out_i2c_bit(hw, nack);
3326 if (status != E1000_SUCCESS)
3327 goto fail;
3328
3329 e1000_i2c_stop(hw);
3330 break;
3331
3332 fail:
3333 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3334 msec_delay(100);
3335 e1000_i2c_bus_clear(hw);
3336 retry++;
3337 if (retry < max_retry)
3338 DEBUGOUT("I2C byte read error - Retrying.\n");
3339 else
3340 DEBUGOUT("I2C byte read error.\n");
3341
3342 } while (retry < max_retry);
3343
3344 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3345
3346 read_byte_out:
3347
3348 return status;
3349 }
3350
3351 /**
3352 * e1000_write_i2c_byte_generic - Writes 8 bit word over I2C
3353 * @hw: pointer to hardware structure
3354 * @byte_offset: byte offset to write
3355 * @dev_addr: device address
3356 * @data: value to write
3357 *
3358 * Performs byte write operation over I2C interface at
3359 * a specified device address.
3360 **/
e1000_write_i2c_byte_generic(struct e1000_hw * hw,u8 byte_offset,u8 dev_addr,u8 data)3361 s32 e1000_write_i2c_byte_generic(struct e1000_hw *hw, u8 byte_offset,
3362 u8 dev_addr, u8 data)
3363 {
3364 s32 status = E1000_SUCCESS;
3365 u32 max_retry = 1;
3366 u32 retry = 0;
3367 u16 swfw_mask = 0;
3368
3369 DEBUGFUNC("e1000_write_i2c_byte_generic");
3370
3371 swfw_mask = E1000_SWFW_PHY0_SM;
3372
3373 if (hw->mac.ops.acquire_swfw_sync(hw, swfw_mask) != E1000_SUCCESS) {
3374 status = E1000_ERR_SWFW_SYNC;
3375 goto write_byte_out;
3376 }
3377
3378 do {
3379 e1000_i2c_start(hw);
3380
3381 status = e1000_clock_out_i2c_byte(hw, dev_addr);
3382 if (status != E1000_SUCCESS)
3383 goto fail;
3384
3385 status = e1000_get_i2c_ack(hw);
3386 if (status != E1000_SUCCESS)
3387 goto fail;
3388
3389 status = e1000_clock_out_i2c_byte(hw, byte_offset);
3390 if (status != E1000_SUCCESS)
3391 goto fail;
3392
3393 status = e1000_get_i2c_ack(hw);
3394 if (status != E1000_SUCCESS)
3395 goto fail;
3396
3397 status = e1000_clock_out_i2c_byte(hw, data);
3398 if (status != E1000_SUCCESS)
3399 goto fail;
3400
3401 status = e1000_get_i2c_ack(hw);
3402 if (status != E1000_SUCCESS)
3403 goto fail;
3404
3405 e1000_i2c_stop(hw);
3406 break;
3407
3408 fail:
3409 e1000_i2c_bus_clear(hw);
3410 retry++;
3411 if (retry < max_retry)
3412 DEBUGOUT("I2C byte write error - Retrying.\n");
3413 else
3414 DEBUGOUT("I2C byte write error.\n");
3415 } while (retry < max_retry);
3416
3417 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3418
3419 write_byte_out:
3420
3421 return status;
3422 }
3423
3424 /**
3425 * e1000_i2c_start - Sets I2C start condition
3426 * @hw: pointer to hardware structure
3427 *
3428 * Sets I2C start condition (High -> Low on SDA while SCL is High)
3429 **/
e1000_i2c_start(struct e1000_hw * hw)3430 static void e1000_i2c_start(struct e1000_hw *hw)
3431 {
3432 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3433
3434 DEBUGFUNC("e1000_i2c_start");
3435
3436 /* Start condition must begin with data and clock high */
3437 e1000_set_i2c_data(hw, &i2cctl, 1);
3438 e1000_raise_i2c_clk(hw, &i2cctl);
3439
3440 /* Setup time for start condition (4.7us) */
3441 usec_delay(E1000_I2C_T_SU_STA);
3442
3443 e1000_set_i2c_data(hw, &i2cctl, 0);
3444
3445 /* Hold time for start condition (4us) */
3446 usec_delay(E1000_I2C_T_HD_STA);
3447
3448 e1000_lower_i2c_clk(hw, &i2cctl);
3449
3450 /* Minimum low period of clock is 4.7 us */
3451 usec_delay(E1000_I2C_T_LOW);
3452
3453 }
3454
3455 /**
3456 * e1000_i2c_stop - Sets I2C stop condition
3457 * @hw: pointer to hardware structure
3458 *
3459 * Sets I2C stop condition (Low -> High on SDA while SCL is High)
3460 **/
e1000_i2c_stop(struct e1000_hw * hw)3461 static void e1000_i2c_stop(struct e1000_hw *hw)
3462 {
3463 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3464
3465 DEBUGFUNC("e1000_i2c_stop");
3466
3467 /* Stop condition must begin with data low and clock high */
3468 e1000_set_i2c_data(hw, &i2cctl, 0);
3469 e1000_raise_i2c_clk(hw, &i2cctl);
3470
3471 /* Setup time for stop condition (4us) */
3472 usec_delay(E1000_I2C_T_SU_STO);
3473
3474 e1000_set_i2c_data(hw, &i2cctl, 1);
3475
3476 /* bus free time between stop and start (4.7us)*/
3477 usec_delay(E1000_I2C_T_BUF);
3478 }
3479
3480 /**
3481 * e1000_clock_in_i2c_byte - Clocks in one byte via I2C
3482 * @hw: pointer to hardware structure
3483 * @data: data byte to clock in
3484 *
3485 * Clocks in one byte data via I2C data/clock
3486 **/
e1000_clock_in_i2c_byte(struct e1000_hw * hw,u8 * data)3487 static s32 e1000_clock_in_i2c_byte(struct e1000_hw *hw, u8 *data)
3488 {
3489 s32 i;
3490 bool bit = 0;
3491
3492 DEBUGFUNC("e1000_clock_in_i2c_byte");
3493
3494 *data = 0;
3495 for (i = 7; i >= 0; i--) {
3496 e1000_clock_in_i2c_bit(hw, &bit);
3497 *data |= bit << i;
3498 }
3499
3500 return E1000_SUCCESS;
3501 }
3502
3503 /**
3504 * e1000_clock_out_i2c_byte - Clocks out one byte via I2C
3505 * @hw: pointer to hardware structure
3506 * @data: data byte clocked out
3507 *
3508 * Clocks out one byte data via I2C data/clock
3509 **/
e1000_clock_out_i2c_byte(struct e1000_hw * hw,u8 data)3510 static s32 e1000_clock_out_i2c_byte(struct e1000_hw *hw, u8 data)
3511 {
3512 s32 status = E1000_SUCCESS;
3513 s32 i;
3514 u32 i2cctl;
3515 bool bit = 0;
3516
3517 DEBUGFUNC("e1000_clock_out_i2c_byte");
3518
3519 for (i = 7; i >= 0; i--) {
3520 bit = (data >> i) & 0x1;
3521 status = e1000_clock_out_i2c_bit(hw, bit);
3522
3523 if (status != E1000_SUCCESS)
3524 break;
3525 }
3526
3527 /* Release SDA line (set high) */
3528 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3529
3530 i2cctl |= E1000_I2C_DATA_OE_N;
3531 E1000_WRITE_REG(hw, E1000_I2CPARAMS, i2cctl);
3532 E1000_WRITE_FLUSH(hw);
3533
3534 return status;
3535 }
3536
3537 /**
3538 * e1000_get_i2c_ack - Polls for I2C ACK
3539 * @hw: pointer to hardware structure
3540 *
3541 * Clocks in/out one bit via I2C data/clock
3542 **/
e1000_get_i2c_ack(struct e1000_hw * hw)3543 static s32 e1000_get_i2c_ack(struct e1000_hw *hw)
3544 {
3545 s32 status = E1000_SUCCESS;
3546 u32 i = 0;
3547 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3548 u32 timeout = 10;
3549 bool ack = TRUE;
3550
3551 DEBUGFUNC("e1000_get_i2c_ack");
3552
3553 e1000_raise_i2c_clk(hw, &i2cctl);
3554
3555 /* Minimum high period of clock is 4us */
3556 usec_delay(E1000_I2C_T_HIGH);
3557
3558 /* Wait until SCL returns high */
3559 for (i = 0; i < timeout; i++) {
3560 usec_delay(1);
3561 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3562 if (i2cctl & E1000_I2C_CLK_IN)
3563 break;
3564 }
3565 if (!(i2cctl & E1000_I2C_CLK_IN))
3566 return E1000_ERR_I2C;
3567
3568 ack = e1000_get_i2c_data(&i2cctl);
3569 if (ack) {
3570 DEBUGOUT("I2C ack was not received.\n");
3571 status = E1000_ERR_I2C;
3572 }
3573
3574 e1000_lower_i2c_clk(hw, &i2cctl);
3575
3576 /* Minimum low period of clock is 4.7 us */
3577 usec_delay(E1000_I2C_T_LOW);
3578
3579 return status;
3580 }
3581
3582 /**
3583 * e1000_clock_in_i2c_bit - Clocks in one bit via I2C data/clock
3584 * @hw: pointer to hardware structure
3585 * @data: read data value
3586 *
3587 * Clocks in one bit via I2C data/clock
3588 **/
e1000_clock_in_i2c_bit(struct e1000_hw * hw,bool * data)3589 static s32 e1000_clock_in_i2c_bit(struct e1000_hw *hw, bool *data)
3590 {
3591 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3592
3593 DEBUGFUNC("e1000_clock_in_i2c_bit");
3594
3595 e1000_raise_i2c_clk(hw, &i2cctl);
3596
3597 /* Minimum high period of clock is 4us */
3598 usec_delay(E1000_I2C_T_HIGH);
3599
3600 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3601 *data = e1000_get_i2c_data(&i2cctl);
3602
3603 e1000_lower_i2c_clk(hw, &i2cctl);
3604
3605 /* Minimum low period of clock is 4.7 us */
3606 usec_delay(E1000_I2C_T_LOW);
3607
3608 return E1000_SUCCESS;
3609 }
3610
3611 /**
3612 * e1000_clock_out_i2c_bit - Clocks in/out one bit via I2C data/clock
3613 * @hw: pointer to hardware structure
3614 * @data: data value to write
3615 *
3616 * Clocks out one bit via I2C data/clock
3617 **/
e1000_clock_out_i2c_bit(struct e1000_hw * hw,bool data)3618 static s32 e1000_clock_out_i2c_bit(struct e1000_hw *hw, bool data)
3619 {
3620 s32 status;
3621 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3622
3623 DEBUGFUNC("e1000_clock_out_i2c_bit");
3624
3625 status = e1000_set_i2c_data(hw, &i2cctl, data);
3626 if (status == E1000_SUCCESS) {
3627 e1000_raise_i2c_clk(hw, &i2cctl);
3628
3629 /* Minimum high period of clock is 4us */
3630 usec_delay(E1000_I2C_T_HIGH);
3631
3632 e1000_lower_i2c_clk(hw, &i2cctl);
3633
3634 /* Minimum low period of clock is 4.7 us.
3635 * This also takes care of the data hold time.
3636 */
3637 usec_delay(E1000_I2C_T_LOW);
3638 } else {
3639 status = E1000_ERR_I2C;
3640 DEBUGOUT1("I2C data was not set to %X\n", data);
3641 }
3642
3643 return status;
3644 }
3645 /**
3646 * e1000_raise_i2c_clk - Raises the I2C SCL clock
3647 * @hw: pointer to hardware structure
3648 * @i2cctl: Current value of I2CCTL register
3649 *
3650 * Raises the I2C clock line '0'->'1'
3651 **/
e1000_raise_i2c_clk(struct e1000_hw * hw,u32 * i2cctl)3652 static void e1000_raise_i2c_clk(struct e1000_hw *hw, u32 *i2cctl)
3653 {
3654 DEBUGFUNC("e1000_raise_i2c_clk");
3655
3656 *i2cctl |= E1000_I2C_CLK_OUT;
3657 *i2cctl &= ~E1000_I2C_CLK_OE_N;
3658 E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3659 E1000_WRITE_FLUSH(hw);
3660
3661 /* SCL rise time (1000ns) */
3662 usec_delay(E1000_I2C_T_RISE);
3663 }
3664
3665 /**
3666 * e1000_lower_i2c_clk - Lowers the I2C SCL clock
3667 * @hw: pointer to hardware structure
3668 * @i2cctl: Current value of I2CCTL register
3669 *
3670 * Lowers the I2C clock line '1'->'0'
3671 **/
e1000_lower_i2c_clk(struct e1000_hw * hw,u32 * i2cctl)3672 static void e1000_lower_i2c_clk(struct e1000_hw *hw, u32 *i2cctl)
3673 {
3674
3675 DEBUGFUNC("e1000_lower_i2c_clk");
3676
3677 *i2cctl &= ~E1000_I2C_CLK_OUT;
3678 *i2cctl &= ~E1000_I2C_CLK_OE_N;
3679 E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3680 E1000_WRITE_FLUSH(hw);
3681
3682 /* SCL fall time (300ns) */
3683 usec_delay(E1000_I2C_T_FALL);
3684 }
3685
3686 /**
3687 * e1000_set_i2c_data - Sets the I2C data bit
3688 * @hw: pointer to hardware structure
3689 * @i2cctl: Current value of I2CCTL register
3690 * @data: I2C data value (0 or 1) to set
3691 *
3692 * Sets the I2C data bit
3693 **/
e1000_set_i2c_data(struct e1000_hw * hw,u32 * i2cctl,bool data)3694 static s32 e1000_set_i2c_data(struct e1000_hw *hw, u32 *i2cctl, bool data)
3695 {
3696 s32 status = E1000_SUCCESS;
3697
3698 DEBUGFUNC("e1000_set_i2c_data");
3699
3700 if (data)
3701 *i2cctl |= E1000_I2C_DATA_OUT;
3702 else
3703 *i2cctl &= ~E1000_I2C_DATA_OUT;
3704
3705 *i2cctl &= ~E1000_I2C_DATA_OE_N;
3706 *i2cctl |= E1000_I2C_CLK_OE_N;
3707 E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3708 E1000_WRITE_FLUSH(hw);
3709
3710 /* Data rise/fall (1000ns/300ns) and set-up time (250ns) */
3711 usec_delay(E1000_I2C_T_RISE + E1000_I2C_T_FALL + E1000_I2C_T_SU_DATA);
3712
3713 *i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3714 if (data != e1000_get_i2c_data(i2cctl)) {
3715 status = E1000_ERR_I2C;
3716 DEBUGOUT1("Error - I2C data was not set to %X.\n", data);
3717 }
3718
3719 return status;
3720 }
3721
3722 /**
3723 * e1000_get_i2c_data - Reads the I2C SDA data bit
3724 * @hw: pointer to hardware structure
3725 * @i2cctl: Current value of I2CCTL register
3726 *
3727 * Returns the I2C data bit value
3728 **/
e1000_get_i2c_data(u32 * i2cctl)3729 static bool e1000_get_i2c_data(u32 *i2cctl)
3730 {
3731 bool data;
3732
3733 DEBUGFUNC("e1000_get_i2c_data");
3734
3735 if (*i2cctl & E1000_I2C_DATA_IN)
3736 data = 1;
3737 else
3738 data = 0;
3739
3740 return data;
3741 }
3742
3743 /**
3744 * e1000_i2c_bus_clear - Clears the I2C bus
3745 * @hw: pointer to hardware structure
3746 *
3747 * Clears the I2C bus by sending nine clock pulses.
3748 * Used when data line is stuck low.
3749 **/
e1000_i2c_bus_clear(struct e1000_hw * hw)3750 void e1000_i2c_bus_clear(struct e1000_hw *hw)
3751 {
3752 u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3753 u32 i;
3754
3755 DEBUGFUNC("e1000_i2c_bus_clear");
3756
3757 e1000_i2c_start(hw);
3758
3759 e1000_set_i2c_data(hw, &i2cctl, 1);
3760
3761 for (i = 0; i < 9; i++) {
3762 e1000_raise_i2c_clk(hw, &i2cctl);
3763
3764 /* Min high period of clock is 4us */
3765 usec_delay(E1000_I2C_T_HIGH);
3766
3767 e1000_lower_i2c_clk(hw, &i2cctl);
3768
3769 /* Min low period of clock is 4.7us*/
3770 usec_delay(E1000_I2C_T_LOW);
3771 }
3772
3773 e1000_i2c_start(hw);
3774
3775 /* Put the i2c bus back to default state */
3776 e1000_i2c_stop(hw);
3777 }
3778
3779