?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: fix bootup crash in native_read_tsc()
[wrt350n-kernel.git] / drivers / net / e1000 / e1000_hw.c
blob7c6888c58c21d2e6e6033a9b6219caf3a6a8f6b6
1 /*******************************************************************************
2
3 Intel PRO/1000 Linux driver
4 Copyright(c) 1999 - 2006 Intel Corporation.
5
6 This program is free software; you can redistribute it and/or modify it
7 under the terms and conditions of the GNU General Public License,
8 version 2, as published by the Free Software Foundation.
9
10 This program is distributed in the hope it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 more details.
14
15 You should have received a copy of the GNU General Public License along with
16 this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
21
22 Contact Information:
23 Linux NICS <linux.nics@intel.com>
24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 /* e1000_hw.c
30 * Shared functions for accessing and configuring the MAC
31 */
32
33
34 #include "e1000_hw.h"
35
36 static int32_t e1000_swfw_sync_acquire(struct e1000_hw *hw, uint16_t mask);
37 static void e1000_swfw_sync_release(struct e1000_hw *hw, uint16_t mask);
38 static int32_t e1000_read_kmrn_reg(struct e1000_hw *hw, uint32_t reg_addr, uint16_t *data);
39 static int32_t e1000_write_kmrn_reg(struct e1000_hw *hw, uint32_t reg_addr, uint16_t data);
40 static int32_t e1000_get_software_semaphore(struct e1000_hw *hw);
41 static void e1000_release_software_semaphore(struct e1000_hw *hw);
42
43 static uint8_t e1000_arc_subsystem_valid(struct e1000_hw *hw);
44 static int32_t e1000_check_downshift(struct e1000_hw *hw);
45 static int32_t e1000_check_polarity(struct e1000_hw *hw, e1000_rev_polarity *polarity);
46 static void e1000_clear_hw_cntrs(struct e1000_hw *hw);
47 static void e1000_clear_vfta(struct e1000_hw *hw);
48 static int32_t e1000_commit_shadow_ram(struct e1000_hw *hw);
49 static int32_t e1000_config_dsp_after_link_change(struct e1000_hw *hw, boolean_t link_up);
50 static int32_t e1000_config_fc_after_link_up(struct e1000_hw *hw);
51 static int32_t e1000_detect_gig_phy(struct e1000_hw *hw);
52 static int32_t e1000_erase_ich8_4k_segment(struct e1000_hw *hw, uint32_t bank);
53 static int32_t e1000_get_auto_rd_done(struct e1000_hw *hw);
54 static int32_t e1000_get_cable_length(struct e1000_hw *hw, uint16_t *min_length, uint16_t *max_length);
55 static int32_t e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw);
56 static int32_t e1000_get_phy_cfg_done(struct e1000_hw *hw);
57 static int32_t e1000_get_software_flag(struct e1000_hw *hw);
58 static int32_t e1000_ich8_cycle_init(struct e1000_hw *hw);
59 static int32_t e1000_ich8_flash_cycle(struct e1000_hw *hw, uint32_t timeout);
60 static int32_t e1000_id_led_init(struct e1000_hw *hw);
61 static int32_t e1000_init_lcd_from_nvm_config_region(struct e1000_hw *hw, uint32_t cnf_base_addr, uint32_t cnf_size);
62 static int32_t e1000_init_lcd_from_nvm(struct e1000_hw *hw);
63 static void e1000_init_rx_addrs(struct e1000_hw *hw);
64 static void e1000_initialize_hardware_bits(struct e1000_hw *hw);
65 static boolean_t e1000_is_onboard_nvm_eeprom(struct e1000_hw *hw);
66 static int32_t e1000_kumeran_lock_loss_workaround(struct e1000_hw *hw);
67 static int32_t e1000_mng_enable_host_if(struct e1000_hw *hw);
68 static int32_t e1000_mng_host_if_write(struct e1000_hw *hw, uint8_t *buffer, uint16_t length, uint16_t offset, uint8_t *sum);
69 static int32_t e1000_mng_write_cmd_header(struct e1000_hw* hw, struct e1000_host_mng_command_header* hdr);
70 static int32_t e1000_mng_write_commit(struct e1000_hw *hw);
71 static int32_t e1000_phy_ife_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info);
72 static int32_t e1000_phy_igp_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info);
73 static int32_t e1000_read_eeprom_eerd(struct e1000_hw *hw, uint16_t offset, uint16_t words, uint16_t *data);
74 static int32_t e1000_write_eeprom_eewr(struct e1000_hw *hw, uint16_t offset, uint16_t words, uint16_t *data);
75 static int32_t e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd);
76 static int32_t e1000_phy_m88_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info);
77 static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw);
78 static int32_t e1000_read_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t *data);
79 static int32_t e1000_verify_write_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t byte);
80 static int32_t e1000_write_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t byte);
81 static int32_t e1000_read_ich8_word(struct e1000_hw *hw, uint32_t index, uint16_t *data);
82 static int32_t e1000_read_ich8_data(struct e1000_hw *hw, uint32_t index, uint32_t size, uint16_t *data);
83 static int32_t e1000_write_ich8_data(struct e1000_hw *hw, uint32_t index, uint32_t size, uint16_t data);
84 static int32_t e1000_read_eeprom_ich8(struct e1000_hw *hw, uint16_t offset, uint16_t words, uint16_t *data);
85 static int32_t e1000_write_eeprom_ich8(struct e1000_hw *hw, uint16_t offset, uint16_t words, uint16_t *data);
86 static void e1000_release_software_flag(struct e1000_hw *hw);
87 static int32_t e1000_set_d3_lplu_state(struct e1000_hw *hw, boolean_t active);
88 static int32_t e1000_set_d0_lplu_state(struct e1000_hw *hw, boolean_t active);
89 static int32_t e1000_set_pci_ex_no_snoop(struct e1000_hw *hw, uint32_t no_snoop);
90 static void e1000_set_pci_express_master_disable(struct e1000_hw *hw);
91 static int32_t e1000_wait_autoneg(struct e1000_hw *hw);
92 static void e1000_write_reg_io(struct e1000_hw *hw, uint32_t offset, uint32_t value);
93 static int32_t e1000_set_phy_type(struct e1000_hw *hw);
94 static void e1000_phy_init_script(struct e1000_hw *hw);
95 static int32_t e1000_setup_copper_link(struct e1000_hw *hw);
96 static int32_t e1000_setup_fiber_serdes_link(struct e1000_hw *hw);
97 static int32_t e1000_adjust_serdes_amplitude(struct e1000_hw *hw);
98 static int32_t e1000_phy_force_speed_duplex(struct e1000_hw *hw);
99 static int32_t e1000_config_mac_to_phy(struct e1000_hw *hw);
100 static void e1000_raise_mdi_clk(struct e1000_hw *hw, uint32_t *ctrl);
101 static void e1000_lower_mdi_clk(struct e1000_hw *hw, uint32_t *ctrl);
102 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, uint32_t data,
103 uint16_t count);
104 static uint16_t e1000_shift_in_mdi_bits(struct e1000_hw *hw);
105 static int32_t e1000_phy_reset_dsp(struct e1000_hw *hw);
106 static int32_t e1000_write_eeprom_spi(struct e1000_hw *hw, uint16_t offset,
107 uint16_t words, uint16_t *data);
108 static int32_t e1000_write_eeprom_microwire(struct e1000_hw *hw,
109 uint16_t offset, uint16_t words,
110 uint16_t *data);
111 static int32_t e1000_spi_eeprom_ready(struct e1000_hw *hw);
112 static void e1000_raise_ee_clk(struct e1000_hw *hw, uint32_t *eecd);
113 static void e1000_lower_ee_clk(struct e1000_hw *hw, uint32_t *eecd);
114 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, uint16_t data,
115 uint16_t count);
116 static int32_t e1000_write_phy_reg_ex(struct e1000_hw *hw, uint32_t reg_addr,
117 uint16_t phy_data);
118 static int32_t e1000_read_phy_reg_ex(struct e1000_hw *hw,uint32_t reg_addr,
119 uint16_t *phy_data);
120 static uint16_t e1000_shift_in_ee_bits(struct e1000_hw *hw, uint16_t count);
121 static int32_t e1000_acquire_eeprom(struct e1000_hw *hw);
122 static void e1000_release_eeprom(struct e1000_hw *hw);
123 static void e1000_standby_eeprom(struct e1000_hw *hw);
124 static int32_t e1000_set_vco_speed(struct e1000_hw *hw);
125 static int32_t e1000_polarity_reversal_workaround(struct e1000_hw *hw);
126 static int32_t e1000_set_phy_mode(struct e1000_hw *hw);
127 static int32_t e1000_host_if_read_cookie(struct e1000_hw *hw, uint8_t *buffer);
128 static uint8_t e1000_calculate_mng_checksum(char *buffer, uint32_t length);
129 static int32_t e1000_configure_kmrn_for_10_100(struct e1000_hw *hw,
130 uint16_t duplex);
131 static int32_t e1000_configure_kmrn_for_1000(struct e1000_hw *hw);
132
133 /* IGP cable length table */
134 static const
135 uint16_t e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] =
136 { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
137 5, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 25, 25, 25,
138 25, 25, 25, 25, 30, 30, 30, 30, 40, 40, 40, 40, 40, 40, 40, 40,
139 40, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60,
140 60, 70, 70, 70, 70, 70, 70, 80, 80, 80, 80, 80, 80, 90, 90, 90,
141 90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
142 100, 100, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
143 110, 110, 110, 110, 110, 110, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120};
144
145 static const
146 uint16_t e1000_igp_2_cable_length_table[IGP02E1000_AGC_LENGTH_TABLE_SIZE] =
147 { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
148 0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
149 6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
150 21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
151 40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
152 60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
153 83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
154 104, 109, 114, 118, 121, 124};
155
156 /******************************************************************************
157 * Set the phy type member in the hw struct.
158 *
159 * hw - Struct containing variables accessed by shared code
160 *****************************************************************************/
161 static int32_t
162 e1000_set_phy_type(struct e1000_hw *hw)
163 {
164 DEBUGFUNC("e1000_set_phy_type");
165
166 if (hw->mac_type == e1000_undefined)
167 return -E1000_ERR_PHY_TYPE;
168
169 switch (hw->phy_id) {
170 case M88E1000_E_PHY_ID:
171 case M88E1000_I_PHY_ID:
172 case M88E1011_I_PHY_ID:
173 case M88E1111_I_PHY_ID:
174 hw->phy_type = e1000_phy_m88;
175 break;
176 case IGP01E1000_I_PHY_ID:
177 if (hw->mac_type == e1000_82541 ||
178 hw->mac_type == e1000_82541_rev_2 ||
179 hw->mac_type == e1000_82547 ||
180 hw->mac_type == e1000_82547_rev_2) {
181 hw->phy_type = e1000_phy_igp;
182 break;
183 }
184 case IGP03E1000_E_PHY_ID:
185 hw->phy_type = e1000_phy_igp_3;
186 break;
187 case IFE_E_PHY_ID:
188 case IFE_PLUS_E_PHY_ID:
189 case IFE_C_E_PHY_ID:
190 hw->phy_type = e1000_phy_ife;
191 break;
192 case GG82563_E_PHY_ID:
193 if (hw->mac_type == e1000_80003es2lan) {
194 hw->phy_type = e1000_phy_gg82563;
195 break;
196 }
197 /* Fall Through */
198 default:
199 /* Should never have loaded on this device */
200 hw->phy_type = e1000_phy_undefined;
201 return -E1000_ERR_PHY_TYPE;
202 }
203
204 return E1000_SUCCESS;
205 }
206
207 /******************************************************************************
208 * IGP phy init script - initializes the GbE PHY
209 *
210 * hw - Struct containing variables accessed by shared code
211 *****************************************************************************/
212 static void
213 e1000_phy_init_script(struct e1000_hw *hw)
214 {
215 uint32_t ret_val;
216 uint16_t phy_saved_data;
217
218 DEBUGFUNC("e1000_phy_init_script");
219
220 if (hw->phy_init_script) {
221 msleep(20);
222
223 /* Save off the current value of register 0x2F5B to be restored at
224 * the end of this routine. */
225 ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
226
227 /* Disabled the PHY transmitter */
228 e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
229
230 msleep(20);
231
232 e1000_write_phy_reg(hw,0x0000,0x0140);
233
234 msleep(5);
235
236 switch (hw->mac_type) {
237 case e1000_82541:
238 case e1000_82547:
239 e1000_write_phy_reg(hw, 0x1F95, 0x0001);
240
241 e1000_write_phy_reg(hw, 0x1F71, 0xBD21);
242
243 e1000_write_phy_reg(hw, 0x1F79, 0x0018);
244
245 e1000_write_phy_reg(hw, 0x1F30, 0x1600);
246
247 e1000_write_phy_reg(hw, 0x1F31, 0x0014);
248
249 e1000_write_phy_reg(hw, 0x1F32, 0x161C);
250
251 e1000_write_phy_reg(hw, 0x1F94, 0x0003);
252
253 e1000_write_phy_reg(hw, 0x1F96, 0x003F);
254
255 e1000_write_phy_reg(hw, 0x2010, 0x0008);
256 break;
257
258 case e1000_82541_rev_2:
259 case e1000_82547_rev_2:
260 e1000_write_phy_reg(hw, 0x1F73, 0x0099);
261 break;
262 default:
263 break;
264 }
265
266 e1000_write_phy_reg(hw, 0x0000, 0x3300);
267
268 msleep(20);
269
270 /* Now enable the transmitter */
271 e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
272
273 if (hw->mac_type == e1000_82547) {
274 uint16_t fused, fine, coarse;
275
276 /* Move to analog registers page */
277 e1000_read_phy_reg(hw, IGP01E1000_ANALOG_SPARE_FUSE_STATUS, &fused);
278
279 if (!(fused & IGP01E1000_ANALOG_SPARE_FUSE_ENABLED)) {
280 e1000_read_phy_reg(hw, IGP01E1000_ANALOG_FUSE_STATUS, &fused);
281
282 fine = fused & IGP01E1000_ANALOG_FUSE_FINE_MASK;
283 coarse = fused & IGP01E1000_ANALOG_FUSE_COARSE_MASK;
284
285 if (coarse > IGP01E1000_ANALOG_FUSE_COARSE_THRESH) {
286 coarse -= IGP01E1000_ANALOG_FUSE_COARSE_10;
287 fine -= IGP01E1000_ANALOG_FUSE_FINE_1;
288 } else if (coarse == IGP01E1000_ANALOG_FUSE_COARSE_THRESH)
289 fine -= IGP01E1000_ANALOG_FUSE_FINE_10;
290
291 fused = (fused & IGP01E1000_ANALOG_FUSE_POLY_MASK) |
292 (fine & IGP01E1000_ANALOG_FUSE_FINE_MASK) |
293 (coarse & IGP01E1000_ANALOG_FUSE_COARSE_MASK);
294
295 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_CONTROL, fused);
296 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_BYPASS,
297 IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL);
298 }
299 }
300 }
301 }
302
303 /******************************************************************************
304 * Set the mac type member in the hw struct.
305 *
306 * hw - Struct containing variables accessed by shared code
307 *****************************************************************************/
308 int32_t
309 e1000_set_mac_type(struct e1000_hw *hw)
310 {
311 DEBUGFUNC("e1000_set_mac_type");
312
313 switch (hw->device_id) {
314 case E1000_DEV_ID_82542:
315 switch (hw->revision_id) {
316 case E1000_82542_2_0_REV_ID:
317 hw->mac_type = e1000_82542_rev2_0;
318 break;
319 case E1000_82542_2_1_REV_ID:
320 hw->mac_type = e1000_82542_rev2_1;
321 break;
322 default:
323 /* Invalid 82542 revision ID */
324 return -E1000_ERR_MAC_TYPE;
325 }
326 break;
327 case E1000_DEV_ID_82543GC_FIBER:
328 case E1000_DEV_ID_82543GC_COPPER:
329 hw->mac_type = e1000_82543;
330 break;
331 case E1000_DEV_ID_82544EI_COPPER:
332 case E1000_DEV_ID_82544EI_FIBER:
333 case E1000_DEV_ID_82544GC_COPPER:
334 case E1000_DEV_ID_82544GC_LOM:
335 hw->mac_type = e1000_82544;
336 break;
337 case E1000_DEV_ID_82540EM:
338 case E1000_DEV_ID_82540EM_LOM:
339 case E1000_DEV_ID_82540EP:
340 case E1000_DEV_ID_82540EP_LOM:
341 case E1000_DEV_ID_82540EP_LP:
342 hw->mac_type = e1000_82540;
343 break;
344 case E1000_DEV_ID_82545EM_COPPER:
345 case E1000_DEV_ID_82545EM_FIBER:
346 hw->mac_type = e1000_82545;
347 break;
348 case E1000_DEV_ID_82545GM_COPPER:
349 case E1000_DEV_ID_82545GM_FIBER:
350 case E1000_DEV_ID_82545GM_SERDES:
351 hw->mac_type = e1000_82545_rev_3;
352 break;
353 case E1000_DEV_ID_82546EB_COPPER:
354 case E1000_DEV_ID_82546EB_FIBER:
355 case E1000_DEV_ID_82546EB_QUAD_COPPER:
356 hw->mac_type = e1000_82546;
357 break;
358 case E1000_DEV_ID_82546GB_COPPER:
359 case E1000_DEV_ID_82546GB_FIBER:
360 case E1000_DEV_ID_82546GB_SERDES:
361 case E1000_DEV_ID_82546GB_PCIE:
362 case E1000_DEV_ID_82546GB_QUAD_COPPER:
363 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
364 hw->mac_type = e1000_82546_rev_3;
365 break;
366 case E1000_DEV_ID_82541EI:
367 case E1000_DEV_ID_82541EI_MOBILE:
368 case E1000_DEV_ID_82541ER_LOM:
369 hw->mac_type = e1000_82541;
370 break;
371 case E1000_DEV_ID_82541ER:
372 case E1000_DEV_ID_82541GI:
373 case E1000_DEV_ID_82541GI_LF:
374 case E1000_DEV_ID_82541GI_MOBILE:
375 hw->mac_type = e1000_82541_rev_2;
376 break;
377 case E1000_DEV_ID_82547EI:
378 case E1000_DEV_ID_82547EI_MOBILE:
379 hw->mac_type = e1000_82547;
380 break;
381 case E1000_DEV_ID_82547GI:
382 hw->mac_type = e1000_82547_rev_2;
383 break;
384 case E1000_DEV_ID_82571EB_COPPER:
385 case E1000_DEV_ID_82571EB_FIBER:
386 case E1000_DEV_ID_82571EB_SERDES:
387 case E1000_DEV_ID_82571EB_SERDES_DUAL:
388 case E1000_DEV_ID_82571EB_SERDES_QUAD:
389 case E1000_DEV_ID_82571EB_QUAD_COPPER:
390 case E1000_DEV_ID_82571PT_QUAD_COPPER:
391 case E1000_DEV_ID_82571EB_QUAD_FIBER:
392 case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:
393 hw->mac_type = e1000_82571;
394 break;
395 case E1000_DEV_ID_82572EI_COPPER:
396 case E1000_DEV_ID_82572EI_FIBER:
397 case E1000_DEV_ID_82572EI_SERDES:
398 case E1000_DEV_ID_82572EI:
399 hw->mac_type = e1000_82572;
400 break;
401 case E1000_DEV_ID_82573E:
402 case E1000_DEV_ID_82573E_IAMT:
403 case E1000_DEV_ID_82573L:
404 hw->mac_type = e1000_82573;
405 break;
406 case E1000_DEV_ID_80003ES2LAN_COPPER_SPT:
407 case E1000_DEV_ID_80003ES2LAN_SERDES_SPT:
408 case E1000_DEV_ID_80003ES2LAN_COPPER_DPT:
409 case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
410 hw->mac_type = e1000_80003es2lan;
411 break;
412 case E1000_DEV_ID_ICH8_IGP_M_AMT:
413 case E1000_DEV_ID_ICH8_IGP_AMT:
414 case E1000_DEV_ID_ICH8_IGP_C:
415 case E1000_DEV_ID_ICH8_IFE:
416 case E1000_DEV_ID_ICH8_IFE_GT:
417 case E1000_DEV_ID_ICH8_IFE_G:
418 case E1000_DEV_ID_ICH8_IGP_M:
419 hw->mac_type = e1000_ich8lan;
420 break;
421 default:
422 /* Should never have loaded on this device */
423 return -E1000_ERR_MAC_TYPE;
424 }
425
426 switch (hw->mac_type) {
427 case e1000_ich8lan:
428 hw->swfwhw_semaphore_present = TRUE;
429 hw->asf_firmware_present = TRUE;
430 break;
431 case e1000_80003es2lan:
432 hw->swfw_sync_present = TRUE;
433 /* fall through */
434 case e1000_82571:
435 case e1000_82572:
436 case e1000_82573:
437 hw->eeprom_semaphore_present = TRUE;
438 /* fall through */
439 case e1000_82541:
440 case e1000_82547:
441 case e1000_82541_rev_2:
442 case e1000_82547_rev_2:
443 hw->asf_firmware_present = TRUE;
444 break;
445 default:
446 break;
447 }
448
449 /* The 82543 chip does not count tx_carrier_errors properly in
450 * FD mode
451 */
452 if (hw->mac_type == e1000_82543)
453 hw->bad_tx_carr_stats_fd = TRUE;
454
455 /* capable of receiving management packets to the host */
456 if (hw->mac_type >= e1000_82571)
457 hw->has_manc2h = TRUE;
458
459 /* In rare occasions, ESB2 systems would end up started without
460 * the RX unit being turned on.
461 */
462 if (hw->mac_type == e1000_80003es2lan)
463 hw->rx_needs_kicking = TRUE;
464
465 if (hw->mac_type > e1000_82544)
466 hw->has_smbus = TRUE;
467
468 return E1000_SUCCESS;
469 }
470
471 /*****************************************************************************
472 * Set media type and TBI compatibility.
473 *
474 * hw - Struct containing variables accessed by shared code
475 * **************************************************************************/
476 void
477 e1000_set_media_type(struct e1000_hw *hw)
478 {
479 uint32_t status;
480
481 DEBUGFUNC("e1000_set_media_type");
482
483 if (hw->mac_type != e1000_82543) {
484 /* tbi_compatibility is only valid on 82543 */
485 hw->tbi_compatibility_en = FALSE;
486 }
487
488 switch (hw->device_id) {
489 case E1000_DEV_ID_82545GM_SERDES:
490 case E1000_DEV_ID_82546GB_SERDES:
491 case E1000_DEV_ID_82571EB_SERDES:
492 case E1000_DEV_ID_82571EB_SERDES_DUAL:
493 case E1000_DEV_ID_82571EB_SERDES_QUAD:
494 case E1000_DEV_ID_82572EI_SERDES:
495 case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
496 hw->media_type = e1000_media_type_internal_serdes;
497 break;
498 default:
499 switch (hw->mac_type) {
500 case e1000_82542_rev2_0:
501 case e1000_82542_rev2_1:
502 hw->media_type = e1000_media_type_fiber;
503 break;
504 case e1000_ich8lan:
505 case e1000_82573:
506 /* The STATUS_TBIMODE bit is reserved or reused for the this
507 * device.
508 */
509 hw->media_type = e1000_media_type_copper;
510 break;
511 default:
512 status = E1000_READ_REG(hw, STATUS);
513 if (status & E1000_STATUS_TBIMODE) {
514 hw->media_type = e1000_media_type_fiber;
515 /* tbi_compatibility not valid on fiber */
516 hw->tbi_compatibility_en = FALSE;
517 } else {
518 hw->media_type = e1000_media_type_copper;
519 }
520 break;
521 }
522 }
523 }
524
525 /******************************************************************************
526 * Reset the transmit and receive units; mask and clear all interrupts.
527 *
528 * hw - Struct containing variables accessed by shared code
529 *****************************************************************************/
530 int32_t
531 e1000_reset_hw(struct e1000_hw *hw)
532 {
533 uint32_t ctrl;
534 uint32_t ctrl_ext;
535 uint32_t icr;
536 uint32_t manc;
537 uint32_t led_ctrl;
538 uint32_t timeout;
539 uint32_t extcnf_ctrl;
540 int32_t ret_val;
541
542 DEBUGFUNC("e1000_reset_hw");
543
544 /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
545 if (hw->mac_type == e1000_82542_rev2_0) {
546 DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
547 e1000_pci_clear_mwi(hw);
548 }
549
550 if (hw->bus_type == e1000_bus_type_pci_express) {
551 /* Prevent the PCI-E bus from sticking if there is no TLP connection
552 * on the last TLP read/write transaction when MAC is reset.
553 */
554 if (e1000_disable_pciex_master(hw) != E1000_SUCCESS) {
555 DEBUGOUT("PCI-E Master disable polling has failed.\n");
556 }
557 }
558
559 /* Clear interrupt mask to stop board from generating interrupts */
560 DEBUGOUT("Masking off all interrupts\n");
561 E1000_WRITE_REG(hw, IMC, 0xffffffff);
562
563 /* Disable the Transmit and Receive units. Then delay to allow
564 * any pending transactions to complete before we hit the MAC with
565 * the global reset.
566 */
567 E1000_WRITE_REG(hw, RCTL, 0);
568 E1000_WRITE_REG(hw, TCTL, E1000_TCTL_PSP);
569 E1000_WRITE_FLUSH(hw);
570
571 /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
572 hw->tbi_compatibility_on = FALSE;
573
574 /* Delay to allow any outstanding PCI transactions to complete before
575 * resetting the device
576 */
577 msleep(10);
578
579 ctrl = E1000_READ_REG(hw, CTRL);
580
581 /* Must reset the PHY before resetting the MAC */
582 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
583 E1000_WRITE_REG(hw, CTRL, (ctrl | E1000_CTRL_PHY_RST));
584 msleep(5);
585 }
586
587 /* Must acquire the MDIO ownership before MAC reset.
588 * Ownership defaults to firmware after a reset. */
589 if (hw->mac_type == e1000_82573) {
590 timeout = 10;
591
592 extcnf_ctrl = E1000_READ_REG(hw, EXTCNF_CTRL);
593 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
594
595 do {
596 E1000_WRITE_REG(hw, EXTCNF_CTRL, extcnf_ctrl);
597 extcnf_ctrl = E1000_READ_REG(hw, EXTCNF_CTRL);
598
599 if (extcnf_ctrl & E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP)
600 break;
601 else
602 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
603
604 msleep(2);
605 timeout--;
606 } while (timeout);
607 }
608
609 /* Workaround for ICH8 bit corruption issue in FIFO memory */
610 if (hw->mac_type == e1000_ich8lan) {
611 /* Set Tx and Rx buffer allocation to 8k apiece. */
612 E1000_WRITE_REG(hw, PBA, E1000_PBA_8K);
613 /* Set Packet Buffer Size to 16k. */
614 E1000_WRITE_REG(hw, PBS, E1000_PBS_16K);
615 }
616
617 /* Issue a global reset to the MAC. This will reset the chip's
618 * transmit, receive, DMA, and link units. It will not effect
619 * the current PCI configuration. The global reset bit is self-
620 * clearing, and should clear within a microsecond.
621 */
622 DEBUGOUT("Issuing a global reset to MAC\n");
623
624 switch (hw->mac_type) {
625 case e1000_82544:
626 case e1000_82540:
627 case e1000_82545:
628 case e1000_82546:
629 case e1000_82541:
630 case e1000_82541_rev_2:
631 /* These controllers can't ack the 64-bit write when issuing the
632 * reset, so use IO-mapping as a workaround to issue the reset */
633 E1000_WRITE_REG_IO(hw, CTRL, (ctrl | E1000_CTRL_RST));
634 break;
635 case e1000_82545_rev_3:
636 case e1000_82546_rev_3:
637 /* Reset is performed on a shadow of the control register */
638 E1000_WRITE_REG(hw, CTRL_DUP, (ctrl | E1000_CTRL_RST));
639 break;
640 case e1000_ich8lan:
641 if (!hw->phy_reset_disable &&
642 e1000_check_phy_reset_block(hw) == E1000_SUCCESS) {
643 /* e1000_ich8lan PHY HW reset requires MAC CORE reset
644 * at the same time to make sure the interface between
645 * MAC and the external PHY is reset.
646 */
647 ctrl |= E1000_CTRL_PHY_RST;
648 }
649
650 e1000_get_software_flag(hw);
651 E1000_WRITE_REG(hw, CTRL, (ctrl | E1000_CTRL_RST));
652 msleep(5);
653 break;
654 default:
655 E1000_WRITE_REG(hw, CTRL, (ctrl | E1000_CTRL_RST));
656 break;
657 }
658
659 /* After MAC reset, force reload of EEPROM to restore power-on settings to
660 * device. Later controllers reload the EEPROM automatically, so just wait
661 * for reload to complete.
662 */
663 switch (hw->mac_type) {
664 case e1000_82542_rev2_0:
665 case e1000_82542_rev2_1:
666 case e1000_82543:
667 case e1000_82544:
668 /* Wait for reset to complete */
669 udelay(10);
670 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
671 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
672 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
673 E1000_WRITE_FLUSH(hw);
674 /* Wait for EEPROM reload */
675 msleep(2);
676 break;
677 case e1000_82541:
678 case e1000_82541_rev_2:
679 case e1000_82547:
680 case e1000_82547_rev_2:
681 /* Wait for EEPROM reload */
682 msleep(20);
683 break;
684 case e1000_82573:
685 if (e1000_is_onboard_nvm_eeprom(hw) == FALSE) {
686 udelay(10);
687 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
688 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
689 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
690 E1000_WRITE_FLUSH(hw);
691 }
692 /* fall through */
693 default:
694 /* Auto read done will delay 5ms or poll based on mac type */
695 ret_val = e1000_get_auto_rd_done(hw);
696 if (ret_val)
697 return ret_val;
698 break;
699 }
700
701 /* Disable HW ARPs on ASF enabled adapters */
702 if (hw->mac_type >= e1000_82540 && hw->mac_type <= e1000_82547_rev_2) {
703 manc = E1000_READ_REG(hw, MANC);
704 manc &= ~(E1000_MANC_ARP_EN);
705 E1000_WRITE_REG(hw, MANC, manc);
706 }
707
708 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
709 e1000_phy_init_script(hw);
710
711 /* Configure activity LED after PHY reset */
712 led_ctrl = E1000_READ_REG(hw, LEDCTL);
713 led_ctrl &= IGP_ACTIVITY_LED_MASK;
714 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
715 E1000_WRITE_REG(hw, LEDCTL, led_ctrl);
716 }
717
718 /* Clear interrupt mask to stop board from generating interrupts */
719 DEBUGOUT("Masking off all interrupts\n");
720 E1000_WRITE_REG(hw, IMC, 0xffffffff);
721
722 /* Clear any pending interrupt events. */
723 icr = E1000_READ_REG(hw, ICR);
724
725 /* If MWI was previously enabled, reenable it. */
726 if (hw->mac_type == e1000_82542_rev2_0) {
727 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
728 e1000_pci_set_mwi(hw);
729 }
730
731 if (hw->mac_type == e1000_ich8lan) {
732 uint32_t kab = E1000_READ_REG(hw, KABGTXD);
733 kab |= E1000_KABGTXD_BGSQLBIAS;
734 E1000_WRITE_REG(hw, KABGTXD, kab);
735 }
736
737 return E1000_SUCCESS;
738 }
739
740 /******************************************************************************
741 *
742 * Initialize a number of hardware-dependent bits
743 *
744 * hw: Struct containing variables accessed by shared code
745 *
746 * This function contains hardware limitation workarounds for PCI-E adapters
747 *
748 *****************************************************************************/
749 static void
750 e1000_initialize_hardware_bits(struct e1000_hw *hw)
751 {
752 if ((hw->mac_type >= e1000_82571) && (!hw->initialize_hw_bits_disable)) {
753 /* Settings common to all PCI-express silicon */
754 uint32_t reg_ctrl, reg_ctrl_ext;
755 uint32_t reg_tarc0, reg_tarc1;
756 uint32_t reg_tctl;
757 uint32_t reg_txdctl, reg_txdctl1;
758
759 /* link autonegotiation/sync workarounds */
760 reg_tarc0 = E1000_READ_REG(hw, TARC0);
761 reg_tarc0 &= ~((1 << 30)|(1 << 29)|(1 << 28)|(1 << 27));
762
763 /* Enable not-done TX descriptor counting */
764 reg_txdctl = E1000_READ_REG(hw, TXDCTL);
765 reg_txdctl |= E1000_TXDCTL_COUNT_DESC;
766 E1000_WRITE_REG(hw, TXDCTL, reg_txdctl);
767 reg_txdctl1 = E1000_READ_REG(hw, TXDCTL1);
768 reg_txdctl1 |= E1000_TXDCTL_COUNT_DESC;
769 E1000_WRITE_REG(hw, TXDCTL1, reg_txdctl1);
770
771 switch (hw->mac_type) {
772 case e1000_82571:
773 case e1000_82572:
774 /* Clear PHY TX compatible mode bits */
775 reg_tarc1 = E1000_READ_REG(hw, TARC1);
776 reg_tarc1 &= ~((1 << 30)|(1 << 29));
777
778 /* link autonegotiation/sync workarounds */
779 reg_tarc0 |= ((1 << 26)|(1 << 25)|(1 << 24)|(1 << 23));
780
781 /* TX ring control fixes */
782 reg_tarc1 |= ((1 << 26)|(1 << 25)|(1 << 24));
783
784 /* Multiple read bit is reversed polarity */
785 reg_tctl = E1000_READ_REG(hw, TCTL);
786 if (reg_tctl & E1000_TCTL_MULR)
787 reg_tarc1 &= ~(1 << 28);
788 else
789 reg_tarc1 |= (1 << 28);
790
791 E1000_WRITE_REG(hw, TARC1, reg_tarc1);
792 break;
793 case e1000_82573:
794 reg_ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
795 reg_ctrl_ext &= ~(1 << 23);
796 reg_ctrl_ext |= (1 << 22);
797
798 /* TX byte count fix */
799 reg_ctrl = E1000_READ_REG(hw, CTRL);
800 reg_ctrl &= ~(1 << 29);
801
802 E1000_WRITE_REG(hw, CTRL_EXT, reg_ctrl_ext);
803 E1000_WRITE_REG(hw, CTRL, reg_ctrl);
804 break;
805 case e1000_80003es2lan:
806 /* improve small packet performace for fiber/serdes */
807 if ((hw->media_type == e1000_media_type_fiber) ||
808 (hw->media_type == e1000_media_type_internal_serdes)) {
809 reg_tarc0 &= ~(1 << 20);
810 }
811
812 /* Multiple read bit is reversed polarity */
813 reg_tctl = E1000_READ_REG(hw, TCTL);
814 reg_tarc1 = E1000_READ_REG(hw, TARC1);
815 if (reg_tctl & E1000_TCTL_MULR)
816 reg_tarc1 &= ~(1 << 28);
817 else
818 reg_tarc1 |= (1 << 28);
819
820 E1000_WRITE_REG(hw, TARC1, reg_tarc1);
821 break;
822 case e1000_ich8lan:
823 /* Reduce concurrent DMA requests to 3 from 4 */
824 if ((hw->revision_id < 3) ||
825 ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
826 (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))
827 reg_tarc0 |= ((1 << 29)|(1 << 28));
828
829 reg_ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
830 reg_ctrl_ext |= (1 << 22);
831 E1000_WRITE_REG(hw, CTRL_EXT, reg_ctrl_ext);
832
833 /* workaround TX hang with TSO=on */
834 reg_tarc0 |= ((1 << 27)|(1 << 26)|(1 << 24)|(1 << 23));
835
836 /* Multiple read bit is reversed polarity */
837 reg_tctl = E1000_READ_REG(hw, TCTL);
838 reg_tarc1 = E1000_READ_REG(hw, TARC1);
839 if (reg_tctl & E1000_TCTL_MULR)
840 reg_tarc1 &= ~(1 << 28);
841 else
842 reg_tarc1 |= (1 << 28);
843
844 /* workaround TX hang with TSO=on */
845 reg_tarc1 |= ((1 << 30)|(1 << 26)|(1 << 24));
846
847 E1000_WRITE_REG(hw, TARC1, reg_tarc1);
848 break;
849 default:
850 break;
851 }
852
853 E1000_WRITE_REG(hw, TARC0, reg_tarc0);
854 }
855 }
856
857 /******************************************************************************
858 * Performs basic configuration of the adapter.
859 *
860 * hw - Struct containing variables accessed by shared code
861 *
862 * Assumes that the controller has previously been reset and is in a
863 * post-reset uninitialized state. Initializes the receive address registers,
864 * multicast table, and VLAN filter table. Calls routines to setup link
865 * configuration and flow control settings. Clears all on-chip counters. Leaves
866 * the transmit and receive units disabled and uninitialized.
867 *****************************************************************************/
868 int32_t
869 e1000_init_hw(struct e1000_hw *hw)
870 {
871 uint32_t ctrl;
872 uint32_t i;
873 int32_t ret_val;
874 uint32_t mta_size;
875 uint32_t reg_data;
876 uint32_t ctrl_ext;
877
878 DEBUGFUNC("e1000_init_hw");
879
880 /* force full DMA clock frequency for 10/100 on ICH8 A0-B0 */
881 if ((hw->mac_type == e1000_ich8lan) &&
882 ((hw->revision_id < 3) ||
883 ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
884 (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))) {
885 reg_data = E1000_READ_REG(hw, STATUS);
886 reg_data &= ~0x80000000;
887 E1000_WRITE_REG(hw, STATUS, reg_data);
888 }
889
890 /* Initialize Identification LED */
891 ret_val = e1000_id_led_init(hw);
892 if (ret_val) {
893 DEBUGOUT("Error Initializing Identification LED\n");
894 return ret_val;
895 }
896
897 /* Set the media type and TBI compatibility */
898 e1000_set_media_type(hw);
899
900 /* Must be called after e1000_set_media_type because media_type is used */
901 e1000_initialize_hardware_bits(hw);
902
903 /* Disabling VLAN filtering. */
904 DEBUGOUT("Initializing the IEEE VLAN\n");
905 /* VET hardcoded to standard value and VFTA removed in ICH8 LAN */
906 if (hw->mac_type != e1000_ich8lan) {
907 if (hw->mac_type < e1000_82545_rev_3)
908 E1000_WRITE_REG(hw, VET, 0);
909 e1000_clear_vfta(hw);
910 }
911
912 /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
913 if (hw->mac_type == e1000_82542_rev2_0) {
914 DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
915 e1000_pci_clear_mwi(hw);
916 E1000_WRITE_REG(hw, RCTL, E1000_RCTL_RST);
917 E1000_WRITE_FLUSH(hw);
918 msleep(5);
919 }
920
921 /* Setup the receive address. This involves initializing all of the Receive
922 * Address Registers (RARs 0 - 15).
923 */
924 e1000_init_rx_addrs(hw);
925
926 /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
927 if (hw->mac_type == e1000_82542_rev2_0) {
928 E1000_WRITE_REG(hw, RCTL, 0);
929 E1000_WRITE_FLUSH(hw);
930 msleep(1);
931 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
932 e1000_pci_set_mwi(hw);
933 }
934
935 /* Zero out the Multicast HASH table */
936 DEBUGOUT("Zeroing the MTA\n");
937 mta_size = E1000_MC_TBL_SIZE;
938 if (hw->mac_type == e1000_ich8lan)
939 mta_size = E1000_MC_TBL_SIZE_ICH8LAN;
940 for (i = 0; i < mta_size; i++) {
941 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
942 /* use write flush to prevent Memory Write Block (MWB) from
943 * occuring when accessing our register space */
944 E1000_WRITE_FLUSH(hw);
945 }
946
947 /* Set the PCI priority bit correctly in the CTRL register. This
948 * determines if the adapter gives priority to receives, or if it
949 * gives equal priority to transmits and receives. Valid only on
950 * 82542 and 82543 silicon.
951 */
952 if (hw->dma_fairness && hw->mac_type <= e1000_82543) {
953 ctrl = E1000_READ_REG(hw, CTRL);
954 E1000_WRITE_REG(hw, CTRL, ctrl | E1000_CTRL_PRIOR);
955 }
956
957 switch (hw->mac_type) {
958 case e1000_82545_rev_3:
959 case e1000_82546_rev_3:
960 break;
961 default:
962 /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
963 if (hw->bus_type == e1000_bus_type_pcix && e1000_pcix_get_mmrbc(hw) > 2048)
964 e1000_pcix_set_mmrbc(hw, 2048);
965 break;
966 }
967
968 /* More time needed for PHY to initialize */
969 if (hw->mac_type == e1000_ich8lan)
970 msleep(15);
971
972 /* Call a subroutine to configure the link and setup flow control. */
973 ret_val = e1000_setup_link(hw);
974
975 /* Set the transmit descriptor write-back policy */
976 if (hw->mac_type > e1000_82544) {
977 ctrl = E1000_READ_REG(hw, TXDCTL);
978 ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
979 E1000_WRITE_REG(hw, TXDCTL, ctrl);
980 }
981
982 if (hw->mac_type == e1000_82573) {
983 e1000_enable_tx_pkt_filtering(hw);
984 }
985
986 switch (hw->mac_type) {
987 default:
988 break;
989 case e1000_80003es2lan:
990 /* Enable retransmit on late collisions */
991 reg_data = E1000_READ_REG(hw, TCTL);
992 reg_data |= E1000_TCTL_RTLC;
993 E1000_WRITE_REG(hw, TCTL, reg_data);
994
995 /* Configure Gigabit Carry Extend Padding */
996 reg_data = E1000_READ_REG(hw, TCTL_EXT);
997 reg_data &= ~E1000_TCTL_EXT_GCEX_MASK;
998 reg_data |= DEFAULT_80003ES2LAN_TCTL_EXT_GCEX;
999 E1000_WRITE_REG(hw, TCTL_EXT, reg_data);
1000
1001 /* Configure Transmit Inter-Packet Gap */
1002 reg_data = E1000_READ_REG(hw, TIPG);
1003 reg_data &= ~E1000_TIPG_IPGT_MASK;
1004 reg_data |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
1005 E1000_WRITE_REG(hw, TIPG, reg_data);
1006
1007 reg_data = E1000_READ_REG_ARRAY(hw, FFLT, 0x0001);
1008 reg_data &= ~0x00100000;
1009 E1000_WRITE_REG_ARRAY(hw, FFLT, 0x0001, reg_data);
1010 /* Fall through */
1011 case e1000_82571:
1012 case e1000_82572:
1013 case e1000_ich8lan:
1014 ctrl = E1000_READ_REG(hw, TXDCTL1);
1015 ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
1016 E1000_WRITE_REG(hw, TXDCTL1, ctrl);
1017 break;
1018 }
1019
1020
1021 if (hw->mac_type == e1000_82573) {
1022 uint32_t gcr = E1000_READ_REG(hw, GCR);
1023 gcr |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
1024 E1000_WRITE_REG(hw, GCR, gcr);
1025 }
1026
1027 /* Clear all of the statistics registers (clear on read). It is
1028 * important that we do this after we have tried to establish link
1029 * because the symbol error count will increment wildly if there
1030 * is no link.
1031 */
1032 e1000_clear_hw_cntrs(hw);
1033
1034 /* ICH8 No-snoop bits are opposite polarity.
1035 * Set to snoop by default after reset. */
1036 if (hw->mac_type == e1000_ich8lan)
1037 e1000_set_pci_ex_no_snoop(hw, PCI_EX_82566_SNOOP_ALL);
1038
1039 if (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER ||
1040 hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3) {
1041 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
1042 /* Relaxed ordering must be disabled to avoid a parity
1043 * error crash in a PCI slot. */
1044 ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
1045 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
1046 }
1047
1048 return ret_val;
1049 }
1050
1051 /******************************************************************************
1052 * Adjust SERDES output amplitude based on EEPROM setting.
1053 *
1054 * hw - Struct containing variables accessed by shared code.
1055 *****************************************************************************/
1056 static int32_t
1057 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
1058 {
1059 uint16_t eeprom_data;
1060 int32_t ret_val;
1061
1062 DEBUGFUNC("e1000_adjust_serdes_amplitude");
1063
1064 if (hw->media_type != e1000_media_type_internal_serdes)
1065 return E1000_SUCCESS;
1066
1067 switch (hw->mac_type) {
1068 case e1000_82545_rev_3:
1069 case e1000_82546_rev_3:
1070 break;
1071 default:
1072 return E1000_SUCCESS;
1073 }
1074
1075 ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1, &eeprom_data);
1076 if (ret_val) {
1077 return ret_val;
1078 }
1079
1080 if (eeprom_data != EEPROM_RESERVED_WORD) {
1081 /* Adjust SERDES output amplitude only. */
1082 eeprom_data &= EEPROM_SERDES_AMPLITUDE_MASK;
1083 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_EXT_CTRL, eeprom_data);
1084 if (ret_val)
1085 return ret_val;
1086 }
1087
1088 return E1000_SUCCESS;
1089 }
1090
1091 /******************************************************************************
1092 * Configures flow control and link settings.
1093 *
1094 * hw - Struct containing variables accessed by shared code
1095 *
1096 * Determines which flow control settings to use. Calls the apropriate media-
1097 * specific link configuration function. Configures the flow control settings.
1098 * Assuming the adapter has a valid link partner, a valid link should be
1099 * established. Assumes the hardware has previously been reset and the
1100 * transmitter and receiver are not enabled.
1101 *****************************************************************************/
1102 int32_t
1103 e1000_setup_link(struct e1000_hw *hw)
1104 {
1105 uint32_t ctrl_ext;
1106 int32_t ret_val;
1107 uint16_t eeprom_data;
1108
1109 DEBUGFUNC("e1000_setup_link");
1110
1111 /* In the case of the phy reset being blocked, we already have a link.
1112 * We do not have to set it up again. */
1113 if (e1000_check_phy_reset_block(hw))
1114 return E1000_SUCCESS;
1115
1116 /* Read and store word 0x0F of the EEPROM. This word contains bits
1117 * that determine the hardware's default PAUSE (flow control) mode,
1118 * a bit that determines whether the HW defaults to enabling or
1119 * disabling auto-negotiation, and the direction of the
1120 * SW defined pins. If there is no SW over-ride of the flow
1121 * control setting, then the variable hw->fc will
1122 * be initialized based on a value in the EEPROM.
1123 */
1124 if (hw->fc == E1000_FC_DEFAULT) {
1125 switch (hw->mac_type) {
1126 case e1000_ich8lan:
1127 case e1000_82573:
1128 hw->fc = E1000_FC_FULL;
1129 break;
1130 default:
1131 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1132 1, &eeprom_data);
1133 if (ret_val) {
1134 DEBUGOUT("EEPROM Read Error\n");
1135 return -E1000_ERR_EEPROM;
1136 }
1137 if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0)
1138 hw->fc = E1000_FC_NONE;
1139 else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) ==
1140 EEPROM_WORD0F_ASM_DIR)
1141 hw->fc = E1000_FC_TX_PAUSE;
1142 else
1143 hw->fc = E1000_FC_FULL;
1144 break;
1145 }
1146 }
1147
1148 /* We want to save off the original Flow Control configuration just
1149 * in case we get disconnected and then reconnected into a different
1150 * hub or switch with different Flow Control capabilities.
1151 */
1152 if (hw->mac_type == e1000_82542_rev2_0)
1153 hw->fc &= (~E1000_FC_TX_PAUSE);
1154
1155 if ((hw->mac_type < e1000_82543) && (hw->report_tx_early == 1))
1156 hw->fc &= (~E1000_FC_RX_PAUSE);
1157
1158 hw->original_fc = hw->fc;
1159
1160 DEBUGOUT1("After fix-ups FlowControl is now = %x\n", hw->fc);
1161
1162 /* Take the 4 bits from EEPROM word 0x0F that determine the initial
1163 * polarity value for the SW controlled pins, and setup the
1164 * Extended Device Control reg with that info.
1165 * This is needed because one of the SW controlled pins is used for
1166 * signal detection. So this should be done before e1000_setup_pcs_link()
1167 * or e1000_phy_setup() is called.
1168 */
1169 if (hw->mac_type == e1000_82543) {
1170 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1171 1, &eeprom_data);
1172 if (ret_val) {
1173 DEBUGOUT("EEPROM Read Error\n");
1174 return -E1000_ERR_EEPROM;
1175 }
1176 ctrl_ext = ((eeprom_data & EEPROM_WORD0F_SWPDIO_EXT) <<
1177 SWDPIO__EXT_SHIFT);
1178 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
1179 }
1180
1181 /* Call the necessary subroutine to configure the link. */
1182 ret_val = (hw->media_type == e1000_media_type_copper) ?
1183 e1000_setup_copper_link(hw) :
1184 e1000_setup_fiber_serdes_link(hw);
1185
1186 /* Initialize the flow control address, type, and PAUSE timer
1187 * registers to their default values. This is done even if flow
1188 * control is disabled, because it does not hurt anything to
1189 * initialize these registers.
1190 */
1191 DEBUGOUT("Initializing the Flow Control address, type and timer regs\n");
1192
1193 /* FCAL/H and FCT are hardcoded to standard values in e1000_ich8lan. */
1194 if (hw->mac_type != e1000_ich8lan) {
1195 E1000_WRITE_REG(hw, FCT, FLOW_CONTROL_TYPE);
1196 E1000_WRITE_REG(hw, FCAH, FLOW_CONTROL_ADDRESS_HIGH);
1197 E1000_WRITE_REG(hw, FCAL, FLOW_CONTROL_ADDRESS_LOW);
1198 }
1199
1200 E1000_WRITE_REG(hw, FCTTV, hw->fc_pause_time);
1201
1202 /* Set the flow control receive threshold registers. Normally,
1203 * these registers will be set to a default threshold that may be
1204 * adjusted later by the driver's runtime code. However, if the
1205 * ability to transmit pause frames in not enabled, then these
1206 * registers will be set to 0.
1207 */
1208 if (!(hw->fc & E1000_FC_TX_PAUSE)) {
1209 E1000_WRITE_REG(hw, FCRTL, 0);
1210 E1000_WRITE_REG(hw, FCRTH, 0);
1211 } else {
1212 /* We need to set up the Receive Threshold high and low water marks
1213 * as well as (optionally) enabling the transmission of XON frames.
1214 */
1215 if (hw->fc_send_xon) {
1216 E1000_WRITE_REG(hw, FCRTL, (hw->fc_low_water | E1000_FCRTL_XONE));
1217 E1000_WRITE_REG(hw, FCRTH, hw->fc_high_water);
1218 } else {
1219 E1000_WRITE_REG(hw, FCRTL, hw->fc_low_water);
1220 E1000_WRITE_REG(hw, FCRTH, hw->fc_high_water);
1221 }
1222 }
1223 return ret_val;
1224 }
1225
1226 /******************************************************************************
1227 * Sets up link for a fiber based or serdes based adapter
1228 *
1229 * hw - Struct containing variables accessed by shared code
1230 *
1231 * Manipulates Physical Coding Sublayer functions in order to configure
1232 * link. Assumes the hardware has been previously reset and the transmitter
1233 * and receiver are not enabled.
1234 *****************************************************************************/
1235 static int32_t
1236 e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
1237 {
1238 uint32_t ctrl;
1239 uint32_t status;
1240 uint32_t txcw = 0;
1241 uint32_t i;
1242 uint32_t signal = 0;
1243 int32_t ret_val;
1244
1245 DEBUGFUNC("e1000_setup_fiber_serdes_link");
1246
1247 /* On 82571 and 82572 Fiber connections, SerDes loopback mode persists
1248 * until explicitly turned off or a power cycle is performed. A read to
1249 * the register does not indicate its status. Therefore, we ensure
1250 * loopback mode is disabled during initialization.
1251 */
1252 if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572)
1253 E1000_WRITE_REG(hw, SCTL, E1000_DISABLE_SERDES_LOOPBACK);
1254
1255 /* On adapters with a MAC newer than 82544, SWDP 1 will be
1256 * set when the optics detect a signal. On older adapters, it will be
1257 * cleared when there is a signal. This applies to fiber media only.
1258 * If we're on serdes media, adjust the output amplitude to value
1259 * set in the EEPROM.
1260 */
1261 ctrl = E1000_READ_REG(hw, CTRL);
1262 if (hw->media_type == e1000_media_type_fiber)
1263 signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
1264
1265 ret_val = e1000_adjust_serdes_amplitude(hw);
1266 if (ret_val)
1267 return ret_val;
1268
1269 /* Take the link out of reset */
1270 ctrl &= ~(E1000_CTRL_LRST);
1271
1272 /* Adjust VCO speed to improve BER performance */
1273 ret_val = e1000_set_vco_speed(hw);
1274 if (ret_val)
1275 return ret_val;
1276
1277 e1000_config_collision_dist(hw);
1278
1279 /* Check for a software override of the flow control settings, and setup
1280 * the device accordingly. If auto-negotiation is enabled, then software
1281 * will have to set the "PAUSE" bits to the correct value in the Tranmsit
1282 * Config Word Register (TXCW) and re-start auto-negotiation. However, if
1283 * auto-negotiation is disabled, then software will have to manually
1284 * configure the two flow control enable bits in the CTRL register.
1285 *
1286 * The possible values of the "fc" parameter are:
1287 * 0: Flow control is completely disabled
1288 * 1: Rx flow control is enabled (we can receive pause frames, but
1289 * not send pause frames).
1290 * 2: Tx flow control is enabled (we can send pause frames but we do
1291 * not support receiving pause frames).
1292 * 3: Both Rx and TX flow control (symmetric) are enabled.
1293 */
1294 switch (hw->fc) {
1295 case E1000_FC_NONE:
1296 /* Flow control is completely disabled by a software over-ride. */
1297 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
1298 break;
1299 case E1000_FC_RX_PAUSE:
1300 /* RX Flow control is enabled and TX Flow control is disabled by a
1301 * software over-ride. Since there really isn't a way to advertise
1302 * that we are capable of RX Pause ONLY, we will advertise that we
1303 * support both symmetric and asymmetric RX PAUSE. Later, we will
1304 * disable the adapter's ability to send PAUSE frames.
1305 */
1306 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1307 break;
1308 case E1000_FC_TX_PAUSE:
1309 /* TX Flow control is enabled, and RX Flow control is disabled, by a
1310 * software over-ride.
1311 */
1312 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
1313 break;
1314 case E1000_FC_FULL:
1315 /* Flow control (both RX and TX) is enabled by a software over-ride. */
1316 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1317 break;
1318 default:
1319 DEBUGOUT("Flow control param set incorrectly\n");
1320 return -E1000_ERR_CONFIG;
1321 break;
1322 }
1323
1324 /* Since auto-negotiation is enabled, take the link out of reset (the link
1325 * will be in reset, because we previously reset the chip). This will
1326 * restart auto-negotiation. If auto-neogtiation is successful then the
1327 * link-up status bit will be set and the flow control enable bits (RFCE
1328 * and TFCE) will be set according to their negotiated value.
1329 */
1330 DEBUGOUT("Auto-negotiation enabled\n");
1331
1332 E1000_WRITE_REG(hw, TXCW, txcw);
1333 E1000_WRITE_REG(hw, CTRL, ctrl);
1334 E1000_WRITE_FLUSH(hw);
1335
1336 hw->txcw = txcw;
1337 msleep(1);
1338
1339 /* If we have a signal (the cable is plugged in) then poll for a "Link-Up"
1340 * indication in the Device Status Register. Time-out if a link isn't
1341 * seen in 500 milliseconds seconds (Auto-negotiation should complete in
1342 * less than 500 milliseconds even if the other end is doing it in SW).
1343 * For internal serdes, we just assume a signal is present, then poll.
1344 */
1345 if (hw->media_type == e1000_media_type_internal_serdes ||
1346 (E1000_READ_REG(hw, CTRL) & E1000_CTRL_SWDPIN1) == signal) {
1347 DEBUGOUT("Looking for Link\n");
1348 for (i = 0; i < (LINK_UP_TIMEOUT / 10); i++) {
1349 msleep(10);
1350 status = E1000_READ_REG(hw, STATUS);
1351 if (status & E1000_STATUS_LU) break;
1352 }
1353 if (i == (LINK_UP_TIMEOUT / 10)) {
1354 DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1355 hw->autoneg_failed = 1;
1356 /* AutoNeg failed to achieve a link, so we'll call
1357 * e1000_check_for_link. This routine will force the link up if
1358 * we detect a signal. This will allow us to communicate with
1359 * non-autonegotiating link partners.
1360 */
1361 ret_val = e1000_check_for_link(hw);
1362 if (ret_val) {
1363 DEBUGOUT("Error while checking for link\n");
1364 return ret_val;
1365 }
1366 hw->autoneg_failed = 0;
1367 } else {
1368 hw->autoneg_failed = 0;
1369 DEBUGOUT("Valid Link Found\n");
1370 }
1371 } else {
1372 DEBUGOUT("No Signal Detected\n");
1373 }
1374 return E1000_SUCCESS;
1375 }
1376
1377 /******************************************************************************
1378 * Make sure we have a valid PHY and change PHY mode before link setup.
1379 *
1380 * hw - Struct containing variables accessed by shared code
1381 ******************************************************************************/
1382 static int32_t
1383 e1000_copper_link_preconfig(struct e1000_hw *hw)
1384 {
1385 uint32_t ctrl;
1386 int32_t ret_val;
1387 uint16_t phy_data;
1388
1389 DEBUGFUNC("e1000_copper_link_preconfig");
1390
1391 ctrl = E1000_READ_REG(hw, CTRL);
1392 /* With 82543, we need to force speed and duplex on the MAC equal to what
1393 * the PHY speed and duplex configuration is. In addition, we need to
1394 * perform a hardware reset on the PHY to take it out of reset.
1395 */
1396 if (hw->mac_type > e1000_82543) {
1397 ctrl |= E1000_CTRL_SLU;
1398 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1399 E1000_WRITE_REG(hw, CTRL, ctrl);
1400 } else {
1401 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
1402 E1000_WRITE_REG(hw, CTRL, ctrl);
1403 ret_val = e1000_phy_hw_reset(hw);
1404 if (ret_val)
1405 return ret_val;
1406 }
1407
1408 /* Make sure we have a valid PHY */
1409 ret_val = e1000_detect_gig_phy(hw);
1410 if (ret_val) {
1411 DEBUGOUT("Error, did not detect valid phy.\n");
1412 return ret_val;
1413 }
1414 DEBUGOUT1("Phy ID = %x \n", hw->phy_id);
1415
1416 /* Set PHY to class A mode (if necessary) */
1417 ret_val = e1000_set_phy_mode(hw);
1418 if (ret_val)
1419 return ret_val;
1420
1421 if ((hw->mac_type == e1000_82545_rev_3) ||
1422 (hw->mac_type == e1000_82546_rev_3)) {
1423 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1424 phy_data |= 0x00000008;
1425 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1426 }
1427
1428 if (hw->mac_type <= e1000_82543 ||
1429 hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
1430 hw->mac_type == e1000_82541_rev_2 || hw->mac_type == e1000_82547_rev_2)
1431 hw->phy_reset_disable = FALSE;
1432
1433 return E1000_SUCCESS;
1434 }
1435
1436
1437 /********************************************************************
1438 * Copper link setup for e1000_phy_igp series.
1439 *
1440 * hw - Struct containing variables accessed by shared code
1441 *********************************************************************/
1442 static int32_t
1443 e1000_copper_link_igp_setup(struct e1000_hw *hw)
1444 {
1445 uint32_t led_ctrl;
1446 int32_t ret_val;
1447 uint16_t phy_data;
1448
1449 DEBUGFUNC("e1000_copper_link_igp_setup");
1450
1451 if (hw->phy_reset_disable)
1452 return E1000_SUCCESS;
1453
1454 ret_val = e1000_phy_reset(hw);
1455 if (ret_val) {
1456 DEBUGOUT("Error Resetting the PHY\n");
1457 return ret_val;
1458 }
1459
1460 /* Wait 15ms for MAC to configure PHY from eeprom settings */
1461 msleep(15);
1462 if (hw->mac_type != e1000_ich8lan) {
1463 /* Configure activity LED after PHY reset */
1464 led_ctrl = E1000_READ_REG(hw, LEDCTL);
1465 led_ctrl &= IGP_ACTIVITY_LED_MASK;
1466 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
1467 E1000_WRITE_REG(hw, LEDCTL, led_ctrl);
1468 }
1469
1470 /* The NVM settings will configure LPLU in D3 for IGP2 and IGP3 PHYs */
1471 if (hw->phy_type == e1000_phy_igp) {
1472 /* disable lplu d3 during driver init */
1473 ret_val = e1000_set_d3_lplu_state(hw, FALSE);
1474 if (ret_val) {
1475 DEBUGOUT("Error Disabling LPLU D3\n");
1476 return ret_val;
1477 }
1478 }
1479
1480 /* disable lplu d0 during driver init */
1481 ret_val = e1000_set_d0_lplu_state(hw, FALSE);
1482 if (ret_val) {
1483 DEBUGOUT("Error Disabling LPLU D0\n");
1484 return ret_val;
1485 }
1486 /* Configure mdi-mdix settings */
1487 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1488 if (ret_val)
1489 return ret_val;
1490
1491 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
1492 hw->dsp_config_state = e1000_dsp_config_disabled;
1493 /* Force MDI for earlier revs of the IGP PHY */
1494 phy_data &= ~(IGP01E1000_PSCR_AUTO_MDIX | IGP01E1000_PSCR_FORCE_MDI_MDIX);
1495 hw->mdix = 1;
1496
1497 } else {
1498 hw->dsp_config_state = e1000_dsp_config_enabled;
1499 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1500
1501 switch (hw->mdix) {
1502 case 1:
1503 phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1504 break;
1505 case 2:
1506 phy_data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1507 break;
1508 case 0:
1509 default:
1510 phy_data |= IGP01E1000_PSCR_AUTO_MDIX;
1511 break;
1512 }
1513 }
1514 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1515 if (ret_val)
1516 return ret_val;
1517
1518 /* set auto-master slave resolution settings */
1519 if (hw->autoneg) {
1520 e1000_ms_type phy_ms_setting = hw->master_slave;
1521
1522 if (hw->ffe_config_state == e1000_ffe_config_active)
1523 hw->ffe_config_state = e1000_ffe_config_enabled;
1524
1525 if (hw->dsp_config_state == e1000_dsp_config_activated)
1526 hw->dsp_config_state = e1000_dsp_config_enabled;
1527
1528 /* when autonegotiation advertisment is only 1000Mbps then we
1529 * should disable SmartSpeed and enable Auto MasterSlave
1530 * resolution as hardware default. */
1531 if (hw->autoneg_advertised == ADVERTISE_1000_FULL) {
1532 /* Disable SmartSpeed */
1533 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1534 &phy_data);
1535 if (ret_val)
1536 return ret_val;
1537 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1538 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1539 phy_data);
1540 if (ret_val)
1541 return ret_val;
1542 /* Set auto Master/Slave resolution process */
1543 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1544 if (ret_val)
1545 return ret_val;
1546 phy_data &= ~CR_1000T_MS_ENABLE;
1547 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1548 if (ret_val)
1549 return ret_val;
1550 }
1551
1552 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1553 if (ret_val)
1554 return ret_val;
1555
1556 /* load defaults for future use */
1557 hw->original_master_slave = (phy_data & CR_1000T_MS_ENABLE) ?
1558 ((phy_data & CR_1000T_MS_VALUE) ?
1559 e1000_ms_force_master :
1560 e1000_ms_force_slave) :
1561 e1000_ms_auto;
1562
1563 switch (phy_ms_setting) {
1564 case e1000_ms_force_master:
1565 phy_data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
1566 break;
1567 case e1000_ms_force_slave:
1568 phy_data |= CR_1000T_MS_ENABLE;
1569 phy_data &= ~(CR_1000T_MS_VALUE);
1570 break;
1571 case e1000_ms_auto:
1572 phy_data &= ~CR_1000T_MS_ENABLE;
1573 default:
1574 break;
1575 }
1576 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1577 if (ret_val)
1578 return ret_val;
1579 }
1580
1581 return E1000_SUCCESS;
1582 }
1583
1584 /********************************************************************
1585 * Copper link setup for e1000_phy_gg82563 series.
1586 *
1587 * hw - Struct containing variables accessed by shared code
1588 *********************************************************************/
1589 static int32_t
1590 e1000_copper_link_ggp_setup(struct e1000_hw *hw)
1591 {
1592 int32_t ret_val;
1593 uint16_t phy_data;
1594 uint32_t reg_data;
1595
1596 DEBUGFUNC("e1000_copper_link_ggp_setup");
1597
1598 if (!hw->phy_reset_disable) {
1599
1600 /* Enable CRS on TX for half-duplex operation. */
1601 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1602 &phy_data);
1603 if (ret_val)
1604 return ret_val;
1605
1606 phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
1607 /* Use 25MHz for both link down and 1000BASE-T for Tx clock */
1608 phy_data |= GG82563_MSCR_TX_CLK_1000MBPS_25MHZ;
1609
1610 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1611 phy_data);
1612 if (ret_val)
1613 return ret_val;
1614
1615 /* Options:
1616 * MDI/MDI-X = 0 (default)
1617 * 0 - Auto for all speeds
1618 * 1 - MDI mode
1619 * 2 - MDI-X mode
1620 * 3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1621 */
1622 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL, &phy_data);
1623 if (ret_val)
1624 return ret_val;
1625
1626 phy_data &= ~GG82563_PSCR_CROSSOVER_MODE_MASK;
1627
1628 switch (hw->mdix) {
1629 case 1:
1630 phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDI;
1631 break;
1632 case 2:
1633 phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDIX;
1634 break;
1635 case 0:
1636 default:
1637 phy_data |= GG82563_PSCR_CROSSOVER_MODE_AUTO;
1638 break;
1639 }
1640
1641 /* Options:
1642 * disable_polarity_correction = 0 (default)
1643 * Automatic Correction for Reversed Cable Polarity
1644 * 0 - Disabled
1645 * 1 - Enabled
1646 */
1647 phy_data &= ~GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1648 if (hw->disable_polarity_correction == 1)
1649 phy_data |= GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1650 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL, phy_data);
1651
1652 if (ret_val)
1653 return ret_val;
1654
1655 /* SW Reset the PHY so all changes take effect */
1656 ret_val = e1000_phy_reset(hw);
1657 if (ret_val) {
1658 DEBUGOUT("Error Resetting the PHY\n");
1659 return ret_val;
1660 }
1661 } /* phy_reset_disable */
1662
1663 if (hw->mac_type == e1000_80003es2lan) {
1664 /* Bypass RX and TX FIFO's */
1665 ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_FIFO_CTRL,
1666 E1000_KUMCTRLSTA_FIFO_CTRL_RX_BYPASS |
1667 E1000_KUMCTRLSTA_FIFO_CTRL_TX_BYPASS);
1668 if (ret_val)
1669 return ret_val;
1670
1671 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, &phy_data);
1672 if (ret_val)
1673 return ret_val;
1674
1675 phy_data &= ~GG82563_PSCR2_REVERSE_AUTO_NEG;
1676 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, phy_data);
1677
1678 if (ret_val)
1679 return ret_val;
1680
1681 reg_data = E1000_READ_REG(hw, CTRL_EXT);
1682 reg_data &= ~(E1000_CTRL_EXT_LINK_MODE_MASK);
1683 E1000_WRITE_REG(hw, CTRL_EXT, reg_data);
1684
1685 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1686 &phy_data);
1687 if (ret_val)
1688 return ret_val;
1689
1690 /* Do not init these registers when the HW is in IAMT mode, since the
1691 * firmware will have already initialized them. We only initialize
1692 * them if the HW is not in IAMT mode.
1693 */
1694 if (e1000_check_mng_mode(hw) == FALSE) {
1695 /* Enable Electrical Idle on the PHY */
1696 phy_data |= GG82563_PMCR_ENABLE_ELECTRICAL_IDLE;
1697 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1698 phy_data);
1699 if (ret_val)
1700 return ret_val;
1701
1702 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1703 &phy_data);
1704 if (ret_val)
1705 return ret_val;
1706
1707 phy_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
1708 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1709 phy_data);
1710
1711 if (ret_val)
1712 return ret_val;
1713 }
1714
1715 /* Workaround: Disable padding in Kumeran interface in the MAC
1716 * and in the PHY to avoid CRC errors.
1717 */
1718 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1719 &phy_data);
1720 if (ret_val)
1721 return ret_val;
1722 phy_data |= GG82563_ICR_DIS_PADDING;
1723 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1724 phy_data);
1725 if (ret_val)
1726 return ret_val;
1727 }
1728
1729 return E1000_SUCCESS;
1730 }
1731
1732 /********************************************************************
1733 * Copper link setup for e1000_phy_m88 series.
1734 *
1735 * hw - Struct containing variables accessed by shared code
1736 *********************************************************************/
1737 static int32_t
1738 e1000_copper_link_mgp_setup(struct e1000_hw *hw)
1739 {
1740 int32_t ret_val;
1741 uint16_t phy_data;
1742
1743 DEBUGFUNC("e1000_copper_link_mgp_setup");
1744
1745 if (hw->phy_reset_disable)
1746 return E1000_SUCCESS;
1747
1748 /* Enable CRS on TX. This must be set for half-duplex operation. */
1749 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1750 if (ret_val)
1751 return ret_val;
1752
1753 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1754
1755 /* Options:
1756 * MDI/MDI-X = 0 (default)
1757 * 0 - Auto for all speeds
1758 * 1 - MDI mode
1759 * 2 - MDI-X mode
1760 * 3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1761 */
1762 phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1763
1764 switch (hw->mdix) {
1765 case 1:
1766 phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
1767 break;
1768 case 2:
1769 phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
1770 break;
1771 case 3:
1772 phy_data |= M88E1000_PSCR_AUTO_X_1000T;
1773 break;
1774 case 0:
1775 default:
1776 phy_data |= M88E1000_PSCR_AUTO_X_MODE;
1777 break;
1778 }
1779
1780 /* Options:
1781 * disable_polarity_correction = 0 (default)
1782 * Automatic Correction for Reversed Cable Polarity
1783 * 0 - Disabled
1784 * 1 - Enabled
1785 */
1786 phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
1787 if (hw->disable_polarity_correction == 1)
1788 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
1789 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1790 if (ret_val)
1791 return ret_val;
1792
1793 if (hw->phy_revision < M88E1011_I_REV_4) {
1794 /* Force TX_CLK in the Extended PHY Specific Control Register
1795 * to 25MHz clock.
1796 */
1797 ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
1798 if (ret_val)
1799 return ret_val;
1800
1801 phy_data |= M88E1000_EPSCR_TX_CLK_25;
1802
1803 if ((hw->phy_revision == E1000_REVISION_2) &&
1804 (hw->phy_id == M88E1111_I_PHY_ID)) {
1805 /* Vidalia Phy, set the downshift counter to 5x */
1806 phy_data &= ~(M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK);
1807 phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
1808 ret_val = e1000_write_phy_reg(hw,
1809 M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1810 if (ret_val)
1811 return ret_val;
1812 } else {
1813 /* Configure Master and Slave downshift values */
1814 phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
1815 M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
1816 phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
1817 M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
1818 ret_val = e1000_write_phy_reg(hw,
1819 M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1820 if (ret_val)
1821 return ret_val;
1822 }
1823 }
1824
1825 /* SW Reset the PHY so all changes take effect */
1826 ret_val = e1000_phy_reset(hw);
1827 if (ret_val) {
1828 DEBUGOUT("Error Resetting the PHY\n");
1829 return ret_val;
1830 }
1831
1832 return E1000_SUCCESS;
1833 }
1834
1835 /********************************************************************
1836 * Setup auto-negotiation and flow control advertisements,
1837 * and then perform auto-negotiation.
1838 *
1839 * hw - Struct containing variables accessed by shared code
1840 *********************************************************************/
1841 static int32_t
1842 e1000_copper_link_autoneg(struct e1000_hw *hw)
1843 {
1844 int32_t ret_val;
1845 uint16_t phy_data;
1846
1847 DEBUGFUNC("e1000_copper_link_autoneg");
1848
1849 /* Perform some bounds checking on the hw->autoneg_advertised
1850 * parameter. If this variable is zero, then set it to the default.
1851 */
1852 hw->autoneg_advertised &= AUTONEG_ADVERTISE_SPEED_DEFAULT;
1853
1854 /* If autoneg_advertised is zero, we assume it was not defaulted
1855 * by the calling code so we set to advertise full capability.
1856 */
1857 if (hw->autoneg_advertised == 0)
1858 hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
1859
1860 /* IFE phy only supports 10/100 */
1861 if (hw->phy_type == e1000_phy_ife)
1862 hw->autoneg_advertised &= AUTONEG_ADVERTISE_10_100_ALL;
1863
1864 DEBUGOUT("Reconfiguring auto-neg advertisement params\n");
1865 ret_val = e1000_phy_setup_autoneg(hw);
1866 if (ret_val) {
1867 DEBUGOUT("Error Setting up Auto-Negotiation\n");
1868 return ret_val;
1869 }
1870 DEBUGOUT("Restarting Auto-Neg\n");
1871
1872 /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1873 * the Auto Neg Restart bit in the PHY control register.
1874 */
1875 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1876 if (ret_val)
1877 return ret_val;
1878
1879 phy_data |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
1880 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
1881 if (ret_val)
1882 return ret_val;
1883
1884 /* Does the user want to wait for Auto-Neg to complete here, or
1885 * check at a later time (for example, callback routine).
1886 */
1887 if (hw->wait_autoneg_complete) {
1888 ret_val = e1000_wait_autoneg(hw);
1889 if (ret_val) {
1890 DEBUGOUT("Error while waiting for autoneg to complete\n");
1891 return ret_val;
1892 }
1893 }
1894
1895 hw->get_link_status = TRUE;
1896
1897 return E1000_SUCCESS;
1898 }
1899
1900 /******************************************************************************
1901 * Config the MAC and the PHY after link is up.
1902 * 1) Set up the MAC to the current PHY speed/duplex
1903 * if we are on 82543. If we
1904 * are on newer silicon, we only need to configure
1905 * collision distance in the Transmit Control Register.
1906 * 2) Set up flow control on the MAC to that established with
1907 * the link partner.
1908 * 3) Config DSP to improve Gigabit link quality for some PHY revisions.
1909 *
1910 * hw - Struct containing variables accessed by shared code
1911 ******************************************************************************/
1912 static int32_t
1913 e1000_copper_link_postconfig(struct e1000_hw *hw)
1914 {
1915 int32_t ret_val;
1916 DEBUGFUNC("e1000_copper_link_postconfig");
1917
1918 if (hw->mac_type >= e1000_82544) {
1919 e1000_config_collision_dist(hw);
1920 } else {
1921 ret_val = e1000_config_mac_to_phy(hw);
1922 if (ret_val) {
1923 DEBUGOUT("Error configuring MAC to PHY settings\n");
1924 return ret_val;
1925 }
1926 }
1927 ret_val = e1000_config_fc_after_link_up(hw);
1928 if (ret_val) {
1929 DEBUGOUT("Error Configuring Flow Control\n");
1930 return ret_val;
1931 }
1932
1933 /* Config DSP to improve Giga link quality */
1934 if (hw->phy_type == e1000_phy_igp) {
1935 ret_val = e1000_config_dsp_after_link_change(hw, TRUE);
1936 if (ret_val) {
1937 DEBUGOUT("Error Configuring DSP after link up\n");
1938 return ret_val;
1939 }
1940 }
1941
1942 return E1000_SUCCESS;
1943 }
1944
1945 /******************************************************************************
1946 * Detects which PHY is present and setup the speed and duplex
1947 *
1948 * hw - Struct containing variables accessed by shared code
1949 ******************************************************************************/
1950 static int32_t
1951 e1000_setup_copper_link(struct e1000_hw *hw)
1952 {
1953 int32_t ret_val;
1954 uint16_t i;
1955 uint16_t phy_data;
1956 uint16_t reg_data;
1957
1958 DEBUGFUNC("e1000_setup_copper_link");
1959
1960 switch (hw->mac_type) {
1961 case e1000_80003es2lan:
1962 case e1000_ich8lan:
1963 /* Set the mac to wait the maximum time between each
1964 * iteration and increase the max iterations when
1965 * polling the phy; this fixes erroneous timeouts at 10Mbps. */
1966 ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 4), 0xFFFF);
1967 if (ret_val)
1968 return ret_val;
1969 ret_val = e1000_read_kmrn_reg(hw, GG82563_REG(0x34, 9), &reg_data);
1970 if (ret_val)
1971 return ret_val;
1972 reg_data |= 0x3F;
1973 ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 9), reg_data);
1974 if (ret_val)
1975 return ret_val;
1976 default:
1977 break;
1978 }
1979
1980 /* Check if it is a valid PHY and set PHY mode if necessary. */
1981 ret_val = e1000_copper_link_preconfig(hw);
1982 if (ret_val)
1983 return ret_val;
1984
1985 switch (hw->mac_type) {
1986 case e1000_80003es2lan:
1987 /* Kumeran registers are written-only */
1988 reg_data = E1000_KUMCTRLSTA_INB_CTRL_LINK_STATUS_TX_TIMEOUT_DEFAULT;
1989 reg_data |= E1000_KUMCTRLSTA_INB_CTRL_DIS_PADDING;
1990 ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_INB_CTRL,
1991 reg_data);
1992 if (ret_val)
1993 return ret_val;
1994 break;
1995 default:
1996 break;
1997 }
1998
1999 if (hw->phy_type == e1000_phy_igp ||
2000 hw->phy_type == e1000_phy_igp_3 ||
2001 hw->phy_type == e1000_phy_igp_2) {
2002 ret_val = e1000_copper_link_igp_setup(hw);
2003 if (ret_val)
2004 return ret_val;
2005 } else if (hw->phy_type == e1000_phy_m88) {
2006 ret_val = e1000_copper_link_mgp_setup(hw);
2007 if (ret_val)
2008 return ret_val;
2009 } else if (hw->phy_type == e1000_phy_gg82563) {
2010 ret_val = e1000_copper_link_ggp_setup(hw);
2011 if (ret_val)
2012 return ret_val;
2013 }
2014
2015 if (hw->autoneg) {
2016 /* Setup autoneg and flow control advertisement
2017 * and perform autonegotiation */
2018 ret_val = e1000_copper_link_autoneg(hw);
2019 if (ret_val)
2020 return ret_val;
2021 } else {
2022 /* PHY will be set to 10H, 10F, 100H,or 100F
2023 * depending on value from forced_speed_duplex. */
2024 DEBUGOUT("Forcing speed and duplex\n");
2025 ret_val = e1000_phy_force_speed_duplex(hw);
2026 if (ret_val) {
2027 DEBUGOUT("Error Forcing Speed and Duplex\n");
2028 return ret_val;
2029 }
2030 }
2031
2032 /* Check link status. Wait up to 100 microseconds for link to become
2033 * valid.
2034 */
2035 for (i = 0; i < 10; i++) {
2036 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2037 if (ret_val)
2038 return ret_val;
2039 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2040 if (ret_val)
2041 return ret_val;
2042
2043 if (phy_data & MII_SR_LINK_STATUS) {
2044 /* Config the MAC and PHY after link is up */
2045 ret_val = e1000_copper_link_postconfig(hw);
2046 if (ret_val)
2047 return ret_val;
2048
2049 DEBUGOUT("Valid link established!!!\n");
2050 return E1000_SUCCESS;
2051 }
2052 udelay(10);
2053 }
2054
2055 DEBUGOUT("Unable to establish link!!!\n");
2056 return E1000_SUCCESS;
2057 }
2058
2059 /******************************************************************************
2060 * Configure the MAC-to-PHY interface for 10/100Mbps
2061 *
2062 * hw - Struct containing variables accessed by shared code
2063 ******************************************************************************/
2064 static int32_t
2065 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, uint16_t duplex)
2066 {
2067 int32_t ret_val = E1000_SUCCESS;
2068 uint32_t tipg;
2069 uint16_t reg_data;
2070
2071 DEBUGFUNC("e1000_configure_kmrn_for_10_100");
2072
2073 reg_data = E1000_KUMCTRLSTA_HD_CTRL_10_100_DEFAULT;
2074 ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2075 reg_data);
2076 if (ret_val)
2077 return ret_val;
2078
2079 /* Configure Transmit Inter-Packet Gap */
2080 tipg = E1000_READ_REG(hw, TIPG);
2081 tipg &= ~E1000_TIPG_IPGT_MASK;
2082 tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_10_100;
2083 E1000_WRITE_REG(hw, TIPG, tipg);
2084
2085 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2086
2087 if (ret_val)
2088 return ret_val;
2089
2090 if (duplex == HALF_DUPLEX)
2091 reg_data |= GG82563_KMCR_PASS_FALSE_CARRIER;
2092 else
2093 reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2094
2095 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2096
2097 return ret_val;
2098 }
2099
2100 static int32_t
2101 e1000_configure_kmrn_for_1000(struct e1000_hw *hw)
2102 {
2103 int32_t ret_val = E1000_SUCCESS;
2104 uint16_t reg_data;
2105 uint32_t tipg;
2106
2107 DEBUGFUNC("e1000_configure_kmrn_for_1000");
2108
2109 reg_data = E1000_KUMCTRLSTA_HD_CTRL_1000_DEFAULT;
2110 ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2111 reg_data);
2112 if (ret_val)
2113 return ret_val;
2114
2115 /* Configure Transmit Inter-Packet Gap */
2116 tipg = E1000_READ_REG(hw, TIPG);
2117 tipg &= ~E1000_TIPG_IPGT_MASK;
2118 tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
2119 E1000_WRITE_REG(hw, TIPG, tipg);
2120
2121 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2122
2123 if (ret_val)
2124 return ret_val;
2125
2126 reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2127 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2128
2129 return ret_val;
2130 }
2131
2132 /******************************************************************************
2133 * Configures PHY autoneg and flow control advertisement settings
2134 *
2135 * hw - Struct containing variables accessed by shared code
2136 ******************************************************************************/
2137 int32_t
2138 e1000_phy_setup_autoneg(struct e1000_hw *hw)
2139 {
2140 int32_t ret_val;
2141 uint16_t mii_autoneg_adv_reg;
2142 uint16_t mii_1000t_ctrl_reg;
2143
2144 DEBUGFUNC("e1000_phy_setup_autoneg");
2145
2146 /* Read the MII Auto-Neg Advertisement Register (Address 4). */
2147 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
2148 if (ret_val)
2149 return ret_val;
2150
2151 if (hw->phy_type != e1000_phy_ife) {
2152 /* Read the MII 1000Base-T Control Register (Address 9). */
2153 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &mii_1000t_ctrl_reg);
2154 if (ret_val)
2155 return ret_val;
2156 } else
2157 mii_1000t_ctrl_reg=0;
2158
2159 /* Need to parse both autoneg_advertised and fc and set up
2160 * the appropriate PHY registers. First we will parse for
2161 * autoneg_advertised software override. Since we can advertise
2162 * a plethora of combinations, we need to check each bit
2163 * individually.
2164 */
2165
2166 /* First we clear all the 10/100 mb speed bits in the Auto-Neg
2167 * Advertisement Register (Address 4) and the 1000 mb speed bits in
2168 * the 1000Base-T Control Register (Address 9).
2169 */
2170 mii_autoneg_adv_reg &= ~REG4_SPEED_MASK;
2171 mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
2172
2173 DEBUGOUT1("autoneg_advertised %x\n", hw->autoneg_advertised);
2174
2175 /* Do we want to advertise 10 Mb Half Duplex? */
2176 if (hw->autoneg_advertised & ADVERTISE_10_HALF) {
2177 DEBUGOUT("Advertise 10mb Half duplex\n");
2178 mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
2179 }
2180
2181 /* Do we want to advertise 10 Mb Full Duplex? */
2182 if (hw->autoneg_advertised & ADVERTISE_10_FULL) {
2183 DEBUGOUT("Advertise 10mb Full duplex\n");
2184 mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
2185 }
2186
2187 /* Do we want to advertise 100 Mb Half Duplex? */
2188 if (hw->autoneg_advertised & ADVERTISE_100_HALF) {
2189 DEBUGOUT("Advertise 100mb Half duplex\n");
2190 mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
2191 }
2192
2193 /* Do we want to advertise 100 Mb Full Duplex? */
2194 if (hw->autoneg_advertised & ADVERTISE_100_FULL) {
2195 DEBUGOUT("Advertise 100mb Full duplex\n");
2196 mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
2197 }
2198
2199 /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
2200 if (hw->autoneg_advertised & ADVERTISE_1000_HALF) {
2201 DEBUGOUT("Advertise 1000mb Half duplex requested, request denied!\n");
2202 }
2203
2204 /* Do we want to advertise 1000 Mb Full Duplex? */
2205 if (hw->autoneg_advertised & ADVERTISE_1000_FULL) {
2206 DEBUGOUT("Advertise 1000mb Full duplex\n");
2207 mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
2208 if (hw->phy_type == e1000_phy_ife) {
2209 DEBUGOUT("e1000_phy_ife is a 10/100 PHY. Gigabit speed is not supported.\n");
2210 }
2211 }
2212
2213 /* Check for a software override of the flow control settings, and
2214 * setup the PHY advertisement registers accordingly. If
2215 * auto-negotiation is enabled, then software will have to set the
2216 * "PAUSE" bits to the correct value in the Auto-Negotiation
2217 * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
2218 *
2219 * The possible values of the "fc" parameter are:
2220 * 0: Flow control is completely disabled
2221 * 1: Rx flow control is enabled (we can receive pause frames
2222 * but not send pause frames).
2223 * 2: Tx flow control is enabled (we can send pause frames
2224 * but we do not support receiving pause frames).
2225 * 3: Both Rx and TX flow control (symmetric) are enabled.
2226 * other: No software override. The flow control configuration
2227 * in the EEPROM is used.
2228 */
2229 switch (hw->fc) {
2230 case E1000_FC_NONE: /* 0 */
2231 /* Flow control (RX & TX) is completely disabled by a
2232 * software over-ride.
2233 */
2234 mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2235 break;
2236 case E1000_FC_RX_PAUSE: /* 1 */
2237 /* RX Flow control is enabled, and TX Flow control is
2238 * disabled, by a software over-ride.
2239 */
2240 /* Since there really isn't a way to advertise that we are
2241 * capable of RX Pause ONLY, we will advertise that we
2242 * support both symmetric and asymmetric RX PAUSE. Later
2243 * (in e1000_config_fc_after_link_up) we will disable the
2244 *hw's ability to send PAUSE frames.
2245 */
2246 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2247 break;
2248 case E1000_FC_TX_PAUSE: /* 2 */
2249 /* TX Flow control is enabled, and RX Flow control is
2250 * disabled, by a software over-ride.
2251 */
2252 mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
2253 mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
2254 break;
2255 case E1000_FC_FULL: /* 3 */
2256 /* Flow control (both RX and TX) is enabled by a software
2257 * over-ride.
2258 */
2259 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2260 break;
2261 default:
2262 DEBUGOUT("Flow control param set incorrectly\n");
2263 return -E1000_ERR_CONFIG;
2264 }
2265
2266 ret_val = e1000_write_phy_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
2267 if (ret_val)
2268 return ret_val;
2269
2270 DEBUGOUT1("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
2271
2272 if (hw->phy_type != e1000_phy_ife) {
2273 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, mii_1000t_ctrl_reg);
2274 if (ret_val)
2275 return ret_val;
2276 }
2277
2278 return E1000_SUCCESS;
2279 }
2280
2281 /******************************************************************************
2282 * Force PHY speed and duplex settings to hw->forced_speed_duplex
2283 *
2284 * hw - Struct containing variables accessed by shared code
2285 ******************************************************************************/
2286 static int32_t
2287 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
2288 {
2289 uint32_t ctrl;
2290 int32_t ret_val;
2291 uint16_t mii_ctrl_reg;
2292 uint16_t mii_status_reg;
2293 uint16_t phy_data;
2294 uint16_t i;
2295
2296 DEBUGFUNC("e1000_phy_force_speed_duplex");
2297
2298 /* Turn off Flow control if we are forcing speed and duplex. */
2299 hw->fc = E1000_FC_NONE;
2300
2301 DEBUGOUT1("hw->fc = %d\n", hw->fc);
2302
2303 /* Read the Device Control Register. */
2304 ctrl = E1000_READ_REG(hw, CTRL);
2305
2306 /* Set the bits to Force Speed and Duplex in the Device Ctrl Reg. */
2307 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2308 ctrl &= ~(DEVICE_SPEED_MASK);
2309
2310 /* Clear the Auto Speed Detect Enable bit. */
2311 ctrl &= ~E1000_CTRL_ASDE;
2312
2313 /* Read the MII Control Register. */
2314 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &mii_ctrl_reg);
2315 if (ret_val)
2316 return ret_val;
2317
2318 /* We need to disable autoneg in order to force link and duplex. */
2319
2320 mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
2321
2322 /* Are we forcing Full or Half Duplex? */
2323 if (hw->forced_speed_duplex == e1000_100_full ||
2324 hw->forced_speed_duplex == e1000_10_full) {
2325 /* We want to force full duplex so we SET the full duplex bits in the
2326 * Device and MII Control Registers.
2327 */
2328 ctrl |= E1000_CTRL_FD;
2329 mii_ctrl_reg |= MII_CR_FULL_DUPLEX;
2330 DEBUGOUT("Full Duplex\n");
2331 } else {
2332 /* We want to force half duplex so we CLEAR the full duplex bits in
2333 * the Device and MII Control Registers.
2334 */
2335 ctrl &= ~E1000_CTRL_FD;
2336 mii_ctrl_reg &= ~MII_CR_FULL_DUPLEX;
2337 DEBUGOUT("Half Duplex\n");
2338 }
2339
2340 /* Are we forcing 100Mbps??? */
2341 if (hw->forced_speed_duplex == e1000_100_full ||
2342 hw->forced_speed_duplex == e1000_100_half) {
2343 /* Set the 100Mb bit and turn off the 1000Mb and 10Mb bits. */
2344 ctrl |= E1000_CTRL_SPD_100;
2345 mii_ctrl_reg |= MII_CR_SPEED_100;
2346 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
2347 DEBUGOUT("Forcing 100mb ");
2348 } else {
2349 /* Set the 10Mb bit and turn off the 1000Mb and 100Mb bits. */
2350 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
2351 mii_ctrl_reg |= MII_CR_SPEED_10;
2352 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
2353 DEBUGOUT("Forcing 10mb ");
2354 }
2355
2356 e1000_config_collision_dist(hw);
2357
2358 /* Write the configured values back to the Device Control Reg. */
2359 E1000_WRITE_REG(hw, CTRL, ctrl);
2360
2361 if ((hw->phy_type == e1000_phy_m88) ||
2362 (hw->phy_type == e1000_phy_gg82563)) {
2363 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2364 if (ret_val)
2365 return ret_val;
2366
2367 /* Clear Auto-Crossover to force MDI manually. M88E1000 requires MDI
2368 * forced whenever speed are duplex are forced.
2369 */
2370 phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
2371 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2372 if (ret_val)
2373 return ret_val;
2374
2375 DEBUGOUT1("M88E1000 PSCR: %x \n", phy_data);
2376
2377 /* Need to reset the PHY or these changes will be ignored */
2378 mii_ctrl_reg |= MII_CR_RESET;
2379
2380 /* Disable MDI-X support for 10/100 */
2381 } else if (hw->phy_type == e1000_phy_ife) {
2382 ret_val = e1000_read_phy_reg(hw, IFE_PHY_MDIX_CONTROL, &phy_data);
2383 if (ret_val)
2384 return ret_val;
2385
2386 phy_data &= ~IFE_PMC_AUTO_MDIX;
2387 phy_data &= ~IFE_PMC_FORCE_MDIX;
2388
2389 ret_val = e1000_write_phy_reg(hw, IFE_PHY_MDIX_CONTROL, phy_data);
2390 if (ret_val)
2391 return ret_val;
2392
2393 } else {
2394 /* Clear Auto-Crossover to force MDI manually. IGP requires MDI
2395 * forced whenever speed or duplex are forced.
2396 */
2397 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
2398 if (ret_val)
2399 return ret_val;
2400
2401 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
2402 phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
2403
2404 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
2405 if (ret_val)
2406 return ret_val;
2407 }
2408
2409 /* Write back the modified PHY MII control register. */
2410 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, mii_ctrl_reg);
2411 if (ret_val)
2412 return ret_val;
2413
2414 udelay(1);
2415
2416 /* The wait_autoneg_complete flag may be a little misleading here.
2417 * Since we are forcing speed and duplex, Auto-Neg is not enabled.
2418 * But we do want to delay for a period while forcing only so we
2419 * don't generate false No Link messages. So we will wait here
2420 * only if the user has set wait_autoneg_complete to 1, which is
2421 * the default.
2422 */
2423 if (hw->wait_autoneg_complete) {
2424 /* We will wait for autoneg to complete. */
2425 DEBUGOUT("Waiting for forced speed/duplex link.\n");
2426 mii_status_reg = 0;
2427
2428 /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2429 for (i = PHY_FORCE_TIME; i > 0; i--) {
2430 /* Read the MII Status Register and wait for Auto-Neg Complete bit
2431 * to be set.
2432 */
2433 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2434 if (ret_val)
2435 return ret_val;
2436
2437 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2438 if (ret_val)
2439 return ret_val;
2440
2441 if (mii_status_reg & MII_SR_LINK_STATUS) break;
2442 msleep(100);
2443 }
2444 if ((i == 0) &&
2445 ((hw->phy_type == e1000_phy_m88) ||
2446 (hw->phy_type == e1000_phy_gg82563))) {
2447 /* We didn't get link. Reset the DSP and wait again for link. */
2448 ret_val = e1000_phy_reset_dsp(hw);
2449 if (ret_val) {
2450 DEBUGOUT("Error Resetting PHY DSP\n");
2451 return ret_val;
2452 }
2453 }
2454 /* This loop will early-out if the link condition has been met. */
2455 for (i = PHY_FORCE_TIME; i > 0; i--) {
2456 if (mii_status_reg & MII_SR_LINK_STATUS) break;
2457 msleep(100);
2458 /* Read the MII Status Register and wait for Auto-Neg Complete bit
2459 * to be set.
2460 */
2461 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2462 if (ret_val)
2463 return ret_val;
2464
2465 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2466 if (ret_val)
2467 return ret_val;
2468 }
2469 }
2470
2471 if (hw->phy_type == e1000_phy_m88) {
2472 /* Because we reset the PHY above, we need to re-force TX_CLK in the
2473 * Extended PHY Specific Control Register to 25MHz clock. This value
2474 * defaults back to a 2.5MHz clock when the PHY is reset.
2475 */
2476 ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
2477 if (ret_val)
2478 return ret_val;
2479
2480 phy_data |= M88E1000_EPSCR_TX_CLK_25;
2481 ret_val = e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
2482 if (ret_val)
2483 return ret_val;
2484
2485 /* In addition, because of the s/w reset above, we need to enable CRS on
2486 * TX. This must be set for both full and half duplex operation.
2487 */
2488 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2489 if (ret_val)
2490 return ret_val;
2491
2492 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
2493 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2494 if (ret_val)
2495 return ret_val;
2496
2497 if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2498 (!hw->autoneg) && (hw->forced_speed_duplex == e1000_10_full ||
2499 hw->forced_speed_duplex == e1000_10_half)) {
2500 ret_val = e1000_polarity_reversal_workaround(hw);
2501 if (ret_val)
2502 return ret_val;
2503 }
2504 } else if (hw->phy_type == e1000_phy_gg82563) {
2505 /* The TX_CLK of the Extended PHY Specific Control Register defaults
2506 * to 2.5MHz on a reset. We need to re-force it back to 25MHz, if
2507 * we're not in a forced 10/duplex configuration. */
2508 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, &phy_data);
2509 if (ret_val)
2510 return ret_val;
2511
2512 phy_data &= ~GG82563_MSCR_TX_CLK_MASK;
2513 if ((hw->forced_speed_duplex == e1000_10_full) ||
2514 (hw->forced_speed_duplex == e1000_10_half))
2515 phy_data |= GG82563_MSCR_TX_CLK_10MBPS_2_5MHZ;
2516 else
2517 phy_data |= GG82563_MSCR_TX_CLK_100MBPS_25MHZ;
2518
2519 /* Also due to the reset, we need to enable CRS on Tx. */
2520 phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
2521
2522 ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, phy_data);
2523 if (ret_val)
2524 return ret_val;
2525 }
2526 return E1000_SUCCESS;
2527 }
2528
2529 /******************************************************************************
2530 * Sets the collision distance in the Transmit Control register
2531 *
2532 * hw - Struct containing variables accessed by shared code
2533 *
2534 * Link should have been established previously. Reads the speed and duplex
2535 * information from the Device Status register.
2536 ******************************************************************************/
2537 void
2538 e1000_config_collision_dist(struct e1000_hw *hw)
2539 {
2540 uint32_t tctl, coll_dist;
2541
2542 DEBUGFUNC("e1000_config_collision_dist");
2543
2544 if (hw->mac_type < e1000_82543)
2545 coll_dist = E1000_COLLISION_DISTANCE_82542;
2546 else
2547 coll_dist = E1000_COLLISION_DISTANCE;
2548
2549 tctl = E1000_READ_REG(hw, TCTL);
2550
2551 tctl &= ~E1000_TCTL_COLD;
2552 tctl |= coll_dist << E1000_COLD_SHIFT;
2553
2554 E1000_WRITE_REG(hw, TCTL, tctl);
2555 E1000_WRITE_FLUSH(hw);
2556 }
2557
2558 /******************************************************************************
2559 * Sets MAC speed and duplex settings to reflect the those in the PHY
2560 *
2561 * hw - Struct containing variables accessed by shared code
2562 * mii_reg - data to write to the MII control register
2563 *
2564 * The contents of the PHY register containing the needed information need to
2565 * be passed in.
2566 ******************************************************************************/
2567 static int32_t
2568 e1000_config_mac_to_phy(struct e1000_hw *hw)
2569 {
2570 uint32_t ctrl;
2571 int32_t ret_val;
2572 uint16_t phy_data;
2573
2574 DEBUGFUNC("e1000_config_mac_to_phy");
2575
2576 /* 82544 or newer MAC, Auto Speed Detection takes care of
2577 * MAC speed/duplex configuration.*/
2578 if (hw->mac_type >= e1000_82544)
2579 return E1000_SUCCESS;
2580
2581 /* Read the Device Control Register and set the bits to Force Speed
2582 * and Duplex.
2583 */
2584 ctrl = E1000_READ_REG(hw, CTRL);
2585 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2586 ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
2587
2588 /* Set up duplex in the Device Control and Transmit Control
2589 * registers depending on negotiated values.
2590 */
2591 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
2592 if (ret_val)
2593 return ret_val;
2594
2595 if (phy_data & M88E1000_PSSR_DPLX)
2596 ctrl |= E1000_CTRL_FD;
2597 else
2598 ctrl &= ~E1000_CTRL_FD;
2599
2600 e1000_config_collision_dist(hw);
2601
2602 /* Set up speed in the Device Control register depending on
2603 * negotiated values.
2604 */
2605 if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
2606 ctrl |= E1000_CTRL_SPD_1000;
2607 else if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_100MBS)
2608 ctrl |= E1000_CTRL_SPD_100;
2609
2610 /* Write the configured values back to the Device Control Reg. */
2611 E1000_WRITE_REG(hw, CTRL, ctrl);
2612 return E1000_SUCCESS;
2613 }
2614
2615 /******************************************************************************
2616 * Forces the MAC's flow control settings.
2617 *
2618 * hw - Struct containing variables accessed by shared code
2619 *
2620 * Sets the TFCE and RFCE bits in the device control register to reflect
2621 * the adapter settings. TFCE and RFCE need to be explicitly set by
2622 * software when a Copper PHY is used because autonegotiation is managed
2623 * by the PHY rather than the MAC. Software must also configure these
2624 * bits when link is forced on a fiber connection.
2625 *****************************************************************************/
2626 int32_t
2627 e1000_force_mac_fc(struct e1000_hw *hw)
2628 {
2629 uint32_t ctrl;
2630
2631 DEBUGFUNC("e1000_force_mac_fc");
2632
2633 /* Get the current configuration of the Device Control Register */
2634 ctrl = E1000_READ_REG(hw, CTRL);
2635
2636 /* Because we didn't get link via the internal auto-negotiation
2637 * mechanism (we either forced link or we got link via PHY
2638 * auto-neg), we have to manually enable/disable transmit an
2639 * receive flow control.
2640 *
2641 * The "Case" statement below enables/disable flow control
2642 * according to the "hw->fc" parameter.
2643 *
2644 * The possible values of the "fc" parameter are:
2645 * 0: Flow control is completely disabled
2646 * 1: Rx flow control is enabled (we can receive pause
2647 * frames but not send pause frames).
2648 * 2: Tx flow control is enabled (we can send pause frames
2649 * frames but we do not receive pause frames).
2650 * 3: Both Rx and TX flow control (symmetric) is enabled.
2651 * other: No other values should be possible at this point.
2652 */
2653
2654 switch (hw->fc) {
2655 case E1000_FC_NONE:
2656 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
2657 break;
2658 case E1000_FC_RX_PAUSE:
2659 ctrl &= (~E1000_CTRL_TFCE);
2660 ctrl |= E1000_CTRL_RFCE;
2661 break;
2662 case E1000_FC_TX_PAUSE:
2663 ctrl &= (~E1000_CTRL_RFCE);
2664 ctrl |= E1000_CTRL_TFCE;
2665 break;
2666 case E1000_FC_FULL:
2667 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
2668 break;
2669 default:
2670 DEBUGOUT("Flow control param set incorrectly\n");
2671 return -E1000_ERR_CONFIG;
2672 }
2673
2674 /* Disable TX Flow Control for 82542 (rev 2.0) */
2675 if (hw->mac_type == e1000_82542_rev2_0)
2676 ctrl &= (~E1000_CTRL_TFCE);
2677
2678 E1000_WRITE_REG(hw, CTRL, ctrl);
2679 return E1000_SUCCESS;
2680 }
2681
2682 /******************************************************************************
2683 * Configures flow control settings after link is established
2684 *
2685 * hw - Struct containing variables accessed by shared code
2686 *
2687 * Should be called immediately after a valid link has been established.
2688 * Forces MAC flow control settings if link was forced. When in MII/GMII mode
2689 * and autonegotiation is enabled, the MAC flow control settings will be set
2690 * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
2691 * and RFCE bits will be automaticaly set to the negotiated flow control mode.
2692 *****************************************************************************/
2693 static int32_t
2694 e1000_config_fc_after_link_up(struct e1000_hw *hw)
2695 {
2696 int32_t ret_val;
2697 uint16_t mii_status_reg;
2698 uint16_t mii_nway_adv_reg;
2699 uint16_t mii_nway_lp_ability_reg;
2700 uint16_t speed;
2701 uint16_t duplex;
2702
2703 DEBUGFUNC("e1000_config_fc_after_link_up");
2704
2705 /* Check for the case where we have fiber media and auto-neg failed
2706 * so we had to force link. In this case, we need to force the
2707 * configuration of the MAC to match the "fc" parameter.
2708 */
2709 if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed)) ||
2710 ((hw->media_type == e1000_media_type_internal_serdes) &&
2711 (hw->autoneg_failed)) ||
2712 ((hw->media_type == e1000_media_type_copper) && (!hw->autoneg))) {
2713 ret_val = e1000_force_mac_fc(hw);
2714 if (ret_val) {
2715 DEBUGOUT("Error forcing flow control settings\n");
2716 return ret_val;
2717 }
2718 }
2719
2720 /* Check for the case where we have copper media and auto-neg is
2721 * enabled. In this case, we need to check and see if Auto-Neg
2722 * has completed, and if so, how the PHY and link partner has
2723 * flow control configured.
2724 */
2725 if ((hw->media_type == e1000_media_type_copper) && hw->autoneg) {
2726 /* Read the MII Status Register and check to see if AutoNeg
2727 * has completed. We read this twice because this reg has
2728 * some "sticky" (latched) bits.
2729 */
2730 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2731 if (ret_val)
2732 return ret_val;
2733 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2734 if (ret_val)
2735 return ret_val;
2736
2737 if (mii_status_reg & MII_SR_AUTONEG_COMPLETE) {
2738 /* The AutoNeg process has completed, so we now need to
2739 * read both the Auto Negotiation Advertisement Register
2740 * (Address 4) and the Auto_Negotiation Base Page Ability
2741 * Register (Address 5) to determine how flow control was
2742 * negotiated.
2743 */
2744 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV,
2745 &mii_nway_adv_reg);
2746 if (ret_val)
2747 return ret_val;
2748 ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY,
2749 &mii_nway_lp_ability_reg);
2750 if (ret_val)
2751 return ret_val;
2752
2753 /* Two bits in the Auto Negotiation Advertisement Register
2754 * (Address 4) and two bits in the Auto Negotiation Base
2755 * Page Ability Register (Address 5) determine flow control
2756 * for both the PHY and the link partner. The following
2757 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
2758 * 1999, describes these PAUSE resolution bits and how flow
2759 * control is determined based upon these settings.
2760 * NOTE: DC = Don't Care
2761 *
2762 * LOCAL DEVICE | LINK PARTNER
2763 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
2764 *-------|---------|-------|---------|--------------------
2765 * 0 | 0 | DC | DC | E1000_FC_NONE
2766 * 0 | 1 | 0 | DC | E1000_FC_NONE
2767 * 0 | 1 | 1 | 0 | E1000_FC_NONE
2768 * 0 | 1 | 1 | 1 | E1000_FC_TX_PAUSE
2769 * 1 | 0 | 0 | DC | E1000_FC_NONE
2770 * 1 | DC | 1 | DC | E1000_FC_FULL
2771 * 1 | 1 | 0 | 0 | E1000_FC_NONE
2772 * 1 | 1 | 0 | 1 | E1000_FC_RX_PAUSE
2773 *
2774 */
2775 /* Are both PAUSE bits set to 1? If so, this implies
2776 * Symmetric Flow Control is enabled at both ends. The
2777 * ASM_DIR bits are irrelevant per the spec.
2778 *
2779 * For Symmetric Flow Control:
2780 *
2781 * LOCAL DEVICE | LINK PARTNER
2782 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2783 *-------|---------|-------|---------|--------------------
2784 * 1 | DC | 1 | DC | E1000_FC_FULL
2785 *
2786 */
2787 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2788 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
2789 /* Now we need to check if the user selected RX ONLY
2790 * of pause frames. In this case, we had to advertise
2791 * FULL flow control because we could not advertise RX
2792 * ONLY. Hence, we must now check to see if we need to
2793 * turn OFF the TRANSMISSION of PAUSE frames.
2794 */
2795 if (hw->original_fc == E1000_FC_FULL) {
2796 hw->fc = E1000_FC_FULL;
2797 DEBUGOUT("Flow Control = FULL.\n");
2798 } else {
2799 hw->fc = E1000_FC_RX_PAUSE;
2800 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2801 }
2802 }
2803 /* For receiving PAUSE frames ONLY.
2804 *
2805 * LOCAL DEVICE | LINK PARTNER
2806 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2807 *-------|---------|-------|---------|--------------------
2808 * 0 | 1 | 1 | 1 | E1000_FC_TX_PAUSE
2809 *
2810 */
2811 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2812 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2813 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2814 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2815 hw->fc = E1000_FC_TX_PAUSE;
2816 DEBUGOUT("Flow Control = TX PAUSE frames only.\n");
2817 }
2818 /* For transmitting PAUSE frames ONLY.
2819 *
2820 * LOCAL DEVICE | LINK PARTNER
2821 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2822 *-------|---------|-------|---------|--------------------
2823 * 1 | 1 | 0 | 1 | E1000_FC_RX_PAUSE
2824 *
2825 */
2826 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2827 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2828 !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2829 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2830 hw->fc = E1000_FC_RX_PAUSE;
2831 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2832 }
2833 /* Per the IEEE spec, at this point flow control should be
2834 * disabled. However, we want to consider that we could
2835 * be connected to a legacy switch that doesn't advertise
2836 * desired flow control, but can be forced on the link
2837 * partner. So if we advertised no flow control, that is
2838 * what we will resolve to. If we advertised some kind of
2839 * receive capability (Rx Pause Only or Full Flow Control)
2840 * and the link partner advertised none, we will configure
2841 * ourselves to enable Rx Flow Control only. We can do
2842 * this safely for two reasons: If the link partner really
2843 * didn't want flow control enabled, and we enable Rx, no
2844 * harm done since we won't be receiving any PAUSE frames
2845 * anyway. If the intent on the link partner was to have
2846 * flow control enabled, then by us enabling RX only, we
2847 * can at least receive pause frames and process them.
2848 * This is a good idea because in most cases, since we are
2849 * predominantly a server NIC, more times than not we will
2850 * be asked to delay transmission of packets than asking
2851 * our link partner to pause transmission of frames.
2852 */
2853 else if ((hw->original_fc == E1000_FC_NONE ||
2854 hw->original_fc == E1000_FC_TX_PAUSE) ||
2855 hw->fc_strict_ieee) {
2856 hw->fc = E1000_FC_NONE;
2857 DEBUGOUT("Flow Control = NONE.\n");
2858 } else {
2859 hw->fc = E1000_FC_RX_PAUSE;
2860 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2861 }
2862
2863 /* Now we need to do one last check... If we auto-
2864 * negotiated to HALF DUPLEX, flow control should not be
2865 * enabled per IEEE 802.3 spec.
2866 */
2867 ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
2868 if (ret_val) {
2869 DEBUGOUT("Error getting link speed and duplex\n");
2870 return ret_val;
2871 }
2872
2873 if (duplex == HALF_DUPLEX)
2874 hw->fc = E1000_FC_NONE;
2875
2876 /* Now we call a subroutine to actually force the MAC
2877 * controller to use the correct flow control settings.
2878 */
2879 ret_val = e1000_force_mac_fc(hw);
2880 if (ret_val) {
2881 DEBUGOUT("Error forcing flow control settings\n");
2882 return ret_val;
2883 }
2884 } else {
2885 DEBUGOUT("Copper PHY and Auto Neg has not completed.\n");
2886 }
2887 }
2888 return E1000_SUCCESS;
2889 }
2890
2891 /******************************************************************************
2892 * Checks to see if the link status of the hardware has changed.
2893 *
2894 * hw - Struct containing variables accessed by shared code
2895 *
2896 * Called by any function that needs to check the link status of the adapter.
2897 *****************************************************************************/
2898 int32_t
2899 e1000_check_for_link(struct e1000_hw *hw)
2900 {
2901 uint32_t rxcw = 0;
2902 uint32_t ctrl;
2903 uint32_t status;
2904 uint32_t rctl;
2905 uint32_t icr;
2906 uint32_t signal = 0;
2907 int32_t ret_val;
2908 uint16_t phy_data;
2909
2910 DEBUGFUNC("e1000_check_for_link");
2911
2912 ctrl = E1000_READ_REG(hw, CTRL);
2913 status = E1000_READ_REG(hw, STATUS);
2914
2915 /* On adapters with a MAC newer than 82544, SW Defineable pin 1 will be
2916 * set when the optics detect a signal. On older adapters, it will be
2917 * cleared when there is a signal. This applies to fiber media only.
2918 */
2919 if ((hw->media_type == e1000_media_type_fiber) ||
2920 (hw->media_type == e1000_media_type_internal_serdes)) {
2921 rxcw = E1000_READ_REG(hw, RXCW);
2922
2923 if (hw->media_type == e1000_media_type_fiber) {
2924 signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
2925 if (status & E1000_STATUS_LU)
2926 hw->get_link_status = FALSE;
2927 }
2928 }
2929
2930 /* If we have a copper PHY then we only want to go out to the PHY
2931 * registers to see if Auto-Neg has completed and/or if our link
2932 * status has changed. The get_link_status flag will be set if we
2933 * receive a Link Status Change interrupt or we have Rx Sequence
2934 * Errors.
2935 */
2936 if ((hw->media_type == e1000_media_type_copper) && hw->get_link_status) {
2937 /* First we want to see if the MII Status Register reports
2938 * link. If so, then we want to get the current speed/duplex
2939 * of the PHY.
2940 * Read the register twice since the link bit is sticky.
2941 */
2942 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2943 if (ret_val)
2944 return ret_val;
2945 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2946 if (ret_val)
2947 return ret_val;
2948
2949 if (phy_data & MII_SR_LINK_STATUS) {
2950 hw->get_link_status = FALSE;
2951 /* Check if there was DownShift, must be checked immediately after
2952 * link-up */
2953 e1000_check_downshift(hw);
2954
2955 /* If we are on 82544 or 82543 silicon and speed/duplex
2956 * are forced to 10H or 10F, then we will implement the polarity
2957 * reversal workaround. We disable interrupts first, and upon
2958 * returning, place the devices interrupt state to its previous
2959 * value except for the link status change interrupt which will
2960 * happen due to the execution of this workaround.
2961 */
2962
2963 if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2964 (!hw->autoneg) &&
2965 (hw->forced_speed_duplex == e1000_10_full ||
2966 hw->forced_speed_duplex == e1000_10_half)) {
2967 E1000_WRITE_REG(hw, IMC, 0xffffffff);
2968 ret_val = e1000_polarity_reversal_workaround(hw);
2969 icr = E1000_READ_REG(hw, ICR);
2970 E1000_WRITE_REG(hw, ICS, (icr & ~E1000_ICS_LSC));
2971 E1000_WRITE_REG(hw, IMS, IMS_ENABLE_MASK);
2972 }
2973
2974 } else {
2975 /* No link detected */
2976 e1000_config_dsp_after_link_change(hw, FALSE);
2977 return 0;
2978 }
2979
2980 /* If we are forcing speed/duplex, then we simply return since
2981 * we have already determined whether we have link or not.
2982 */
2983 if (!hw->autoneg) return -E1000_ERR_CONFIG;
2984
2985 /* optimize the dsp settings for the igp phy */
2986 e1000_config_dsp_after_link_change(hw, TRUE);
2987
2988 /* We have a M88E1000 PHY and Auto-Neg is enabled. If we
2989 * have Si on board that is 82544 or newer, Auto
2990 * Speed Detection takes care of MAC speed/duplex
2991 * configuration. So we only need to configure Collision
2992 * Distance in the MAC. Otherwise, we need to force
2993 * speed/duplex on the MAC to the current PHY speed/duplex
2994 * settings.
2995 */
2996 if (hw->mac_type >= e1000_82544)
2997 e1000_config_collision_dist(hw);
2998 else {
2999 ret_val = e1000_config_mac_to_phy(hw);
3000 if (ret_val) {
3001 DEBUGOUT("Error configuring MAC to PHY settings\n");
3002 return ret_val;
3003 }
3004 }
3005
3006 /* Configure Flow Control now that Auto-Neg has completed. First, we
3007 * need to restore the desired flow control settings because we may
3008 * have had to re-autoneg with a different link partner.
3009 */
3010 ret_val = e1000_config_fc_after_link_up(hw);
3011 if (ret_val) {
3012 DEBUGOUT("Error configuring flow control\n");
3013 return ret_val;
3014 }
3015
3016 /* At this point we know that we are on copper and we have
3017 * auto-negotiated link. These are conditions for checking the link
3018 * partner capability register. We use the link speed to determine if
3019 * TBI compatibility needs to be turned on or off. If the link is not
3020 * at gigabit speed, then TBI compatibility is not needed. If we are
3021 * at gigabit speed, we turn on TBI compatibility.
3022 */
3023 if (hw->tbi_compatibility_en) {
3024 uint16_t speed, duplex;
3025 ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
3026 if (ret_val) {
3027 DEBUGOUT("Error getting link speed and duplex\n");
3028 return ret_val;
3029 }
3030 if (speed != SPEED_1000) {
3031 /* If link speed is not set to gigabit speed, we do not need
3032 * to enable TBI compatibility.
3033 */
3034 if (hw->tbi_compatibility_on) {
3035 /* If we previously were in the mode, turn it off. */
3036 rctl = E1000_READ_REG(hw, RCTL);
3037 rctl &= ~E1000_RCTL_SBP;
3038 E1000_WRITE_REG(hw, RCTL, rctl);
3039 hw->tbi_compatibility_on = FALSE;
3040 }
3041 } else {
3042 /* If TBI compatibility is was previously off, turn it on. For
3043 * compatibility with a TBI link partner, we will store bad
3044 * packets. Some frames have an additional byte on the end and
3045 * will look like CRC errors to to the hardware.
3046 */
3047 if (!hw->tbi_compatibility_on) {
3048 hw->tbi_compatibility_on = TRUE;
3049 rctl = E1000_READ_REG(hw, RCTL);
3050 rctl |= E1000_RCTL_SBP;
3051 E1000_WRITE_REG(hw, RCTL, rctl);
3052 }
3053 }
3054 }
3055 }
3056 /* If we don't have link (auto-negotiation failed or link partner cannot
3057 * auto-negotiate), the cable is plugged in (we have signal), and our
3058 * link partner is not trying to auto-negotiate with us (we are receiving
3059 * idles or data), we need to force link up. We also need to give
3060 * auto-negotiation time to complete, in case the cable was just plugged
3061 * in. The autoneg_failed flag does this.
3062 */
3063 else if ((((hw->media_type == e1000_media_type_fiber) &&
3064 ((ctrl & E1000_CTRL_SWDPIN1) == signal)) ||
3065 (hw->media_type == e1000_media_type_internal_serdes)) &&
3066 (!(status & E1000_STATUS_LU)) &&
3067 (!(rxcw & E1000_RXCW_C))) {
3068 if (hw->autoneg_failed == 0) {
3069 hw->autoneg_failed = 1;
3070 return 0;
3071 }
3072 DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\n");
3073
3074 /* Disable auto-negotiation in the TXCW register */
3075 E1000_WRITE_REG(hw, TXCW, (hw->txcw & ~E1000_TXCW_ANE));
3076
3077 /* Force link-up and also force full-duplex. */
3078 ctrl = E1000_READ_REG(hw, CTRL);
3079 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
3080 E1000_WRITE_REG(hw, CTRL, ctrl);
3081
3082 /* Configure Flow Control after forcing link up. */
3083 ret_val = e1000_config_fc_after_link_up(hw);
3084 if (ret_val) {
3085 DEBUGOUT("Error configuring flow control\n");
3086 return ret_val;
3087 }
3088 }
3089 /* If we are forcing link and we are receiving /C/ ordered sets, re-enable
3090 * auto-negotiation in the TXCW register and disable forced link in the
3091 * Device Control register in an attempt to auto-negotiate with our link
3092 * partner.
3093 */
3094 else if (((hw->media_type == e1000_media_type_fiber) ||
3095 (hw->media_type == e1000_media_type_internal_serdes)) &&
3096 (ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
3097 DEBUGOUT("RXing /C/, enable AutoNeg and stop forcing link.\n");
3098 E1000_WRITE_REG(hw, TXCW, hw->txcw);
3099 E1000_WRITE_REG(hw, CTRL, (ctrl & ~E1000_CTRL_SLU));
3100
3101 hw->serdes_link_down = FALSE;
3102 }
3103 /* If we force link for non-auto-negotiation switch, check link status
3104 * based on MAC synchronization for internal serdes media type.
3105 */
3106 else if ((hw->media_type == e1000_media_type_internal_serdes) &&
3107 !(E1000_TXCW_ANE & E1000_READ_REG(hw, TXCW))) {
3108 /* SYNCH bit and IV bit are sticky. */
3109 udelay(10);
3110 if (E1000_RXCW_SYNCH & E1000_READ_REG(hw, RXCW)) {
3111 if (!(rxcw & E1000_RXCW_IV)) {
3112 hw->serdes_link_down = FALSE;
3113 DEBUGOUT("SERDES: Link is up.\n");
3114 }
3115 } else {
3116 hw->serdes_link_down = TRUE;
3117 DEBUGOUT("SERDES: Link is down.\n");
3118 }
3119 }
3120 if ((hw->media_type == e1000_media_type_internal_serdes) &&
3121 (E1000_TXCW_ANE & E1000_READ_REG(hw, TXCW))) {
3122 hw->serdes_link_down = !(E1000_STATUS_LU & E1000_READ_REG(hw, STATUS));
3123 }
3124 return E1000_SUCCESS;
3125 }
3126
3127 /******************************************************************************
3128 * Detects the current speed and duplex settings of the hardware.
3129 *
3130 * hw - Struct containing variables accessed by shared code
3131 * speed - Speed of the connection
3132 * duplex - Duplex setting of the connection
3133 *****************************************************************************/
3134 int32_t
3135 e1000_get_speed_and_duplex(struct e1000_hw *hw,
3136 uint16_t *speed,
3137 uint16_t *duplex)
3138 {
3139 uint32_t status;
3140 int32_t ret_val;
3141 uint16_t phy_data;
3142
3143 DEBUGFUNC("e1000_get_speed_and_duplex");
3144
3145 if (hw->mac_type >= e1000_82543) {
3146 status = E1000_READ_REG(hw, STATUS);
3147 if (status & E1000_STATUS_SPEED_1000) {
3148 *speed = SPEED_1000;
3149 DEBUGOUT("1000 Mbs, ");
3150 } else if (status & E1000_STATUS_SPEED_100) {
3151 *speed = SPEED_100;
3152 DEBUGOUT("100 Mbs, ");
3153 } else {
3154 *speed = SPEED_10;
3155 DEBUGOUT("10 Mbs, ");
3156 }
3157
3158 if (status & E1000_STATUS_FD) {
3159 *duplex = FULL_DUPLEX;
3160 DEBUGOUT("Full Duplex\n");
3161 } else {
3162 *duplex = HALF_DUPLEX;
3163 DEBUGOUT(" Half Duplex\n");
3164 }
3165 } else {
3166 DEBUGOUT("1000 Mbs, Full Duplex\n");
3167 *speed = SPEED_1000;
3168 *duplex = FULL_DUPLEX;
3169 }
3170
3171 /* IGP01 PHY may advertise full duplex operation after speed downgrade even
3172 * if it is operating at half duplex. Here we set the duplex settings to
3173 * match the duplex in the link partner's capabilities.
3174 */
3175 if (hw->phy_type == e1000_phy_igp && hw->speed_downgraded) {
3176 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_data);
3177 if (ret_val)
3178 return ret_val;
3179
3180 if (!(phy_data & NWAY_ER_LP_NWAY_CAPS))
3181 *duplex = HALF_DUPLEX;
3182 else {
3183 ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
3184 if (ret_val)
3185 return ret_val;
3186 if ((*speed == SPEED_100 && !(phy_data & NWAY_LPAR_100TX_FD_CAPS)) ||
3187 (*speed == SPEED_10 && !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
3188 *duplex = HALF_DUPLEX;
3189 }
3190 }
3191
3192 if ((hw->mac_type == e1000_80003es2lan) &&
3193 (hw->media_type == e1000_media_type_copper)) {
3194 if (*speed == SPEED_1000)
3195 ret_val = e1000_configure_kmrn_for_1000(hw);
3196 else
3197 ret_val = e1000_configure_kmrn_for_10_100(hw, *duplex);
3198 if (ret_val)
3199 return ret_val;
3200 }
3201
3202 if ((hw->phy_type == e1000_phy_igp_3) && (*speed == SPEED_1000)) {
3203 ret_val = e1000_kumeran_lock_loss_workaround(hw);
3204 if (ret_val)
3205 return ret_val;
3206 }
3207
3208 return E1000_SUCCESS;
3209 }
3210
3211 /******************************************************************************
3212 * Blocks until autoneg completes or times out (~4.5 seconds)
3213 *
3214 * hw - Struct containing variables accessed by shared code
3215 ******************************************************************************/
3216 static int32_t
3217 e1000_wait_autoneg(struct e1000_hw *hw)
3218 {
3219 int32_t ret_val;
3220 uint16_t i;
3221 uint16_t phy_data;
3222
3223 DEBUGFUNC("e1000_wait_autoneg");
3224 DEBUGOUT("Waiting for Auto-Neg to complete.\n");
3225
3226 /* We will wait for autoneg to complete or 4.5 seconds to expire. */
3227 for (i = PHY_AUTO_NEG_TIME; i > 0; i--) {
3228 /* Read the MII Status Register and wait for Auto-Neg
3229 * Complete bit to be set.
3230 */
3231 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3232 if (ret_val)
3233 return ret_val;
3234 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3235 if (ret_val)
3236 return ret_val;
3237 if (phy_data & MII_SR_AUTONEG_COMPLETE) {
3238 return E1000_SUCCESS;
3239 }
3240 msleep(100);
3241 }
3242 return E1000_SUCCESS;
3243 }
3244
3245 /******************************************************************************
3246 * Raises the Management Data Clock
3247 *
3248 * hw - Struct containing variables accessed by shared code
3249 * ctrl - Device control register's current value
3250 ******************************************************************************/
3251 static void
3252 e1000_raise_mdi_clk(struct e1000_hw *hw,
3253 uint32_t *ctrl)
3254 {
3255 /* Raise the clock input to the Management Data Clock (by setting the MDC
3256 * bit), and then delay 10 microseconds.
3257 */
3258 E1000_WRITE_REG(hw, CTRL, (*ctrl | E1000_CTRL_MDC));
3259 E1000_WRITE_FLUSH(hw);
3260 udelay(10);
3261 }
3262
3263 /******************************************************************************
3264 * Lowers the Management Data Clock
3265 *
3266 * hw - Struct containing variables accessed by shared code
3267 * ctrl - Device control register's current value
3268 ******************************************************************************/
3269 static void
3270 e1000_lower_mdi_clk(struct e1000_hw *hw,
3271 uint32_t *ctrl)
3272 {
3273 /* Lower the clock input to the Management Data Clock (by clearing the MDC
3274 * bit), and then delay 10 microseconds.
3275 */
3276 E1000_WRITE_REG(hw, CTRL, (*ctrl & ~E1000_CTRL_MDC));
3277 E1000_WRITE_FLUSH(hw);
3278 udelay(10);
3279 }
3280
3281 /******************************************************************************
3282 * Shifts data bits out to the PHY
3283 *
3284 * hw - Struct containing variables accessed by shared code
3285 * data - Data to send out to the PHY
3286 * count - Number of bits to shift out
3287 *
3288 * Bits are shifted out in MSB to LSB order.
3289 ******************************************************************************/
3290 static void
3291 e1000_shift_out_mdi_bits(struct e1000_hw *hw,
3292 uint32_t data,
3293 uint16_t count)
3294 {
3295 uint32_t ctrl;
3296 uint32_t mask;
3297
3298 /* We need to shift "count" number of bits out to the PHY. So, the value
3299 * in the "data" parameter will be shifted out to the PHY one bit at a
3300 * time. In order to do this, "data" must be broken down into bits.
3301 */
3302 mask = 0x01;
3303 mask <<= (count - 1);
3304
3305 ctrl = E1000_READ_REG(hw, CTRL);
3306
3307 /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
3308 ctrl |= (E1000_CTRL_MDIO_DIR | E1000_CTRL_MDC_DIR);
3309
3310 while (mask) {
3311 /* A "1" is shifted out to the PHY by setting the MDIO bit to "1" and
3312 * then raising and lowering the Management Data Clock. A "0" is
3313 * shifted out to the PHY by setting the MDIO bit to "0" and then
3314 * raising and lowering the clock.
3315 */
3316 if (data & mask)
3317 ctrl |= E1000_CTRL_MDIO;
3318 else
3319 ctrl &= ~E1000_CTRL_MDIO;
3320
3321 E1000_WRITE_REG(hw, CTRL, ctrl);
3322 E1000_WRITE_FLUSH(hw);
3323
3324 udelay(10);
3325
3326 e1000_raise_mdi_clk(hw, &ctrl);
3327 e1000_lower_mdi_clk(hw, &ctrl);
3328
3329 mask = mask >> 1;
3330 }
3331 }
3332
3333 /******************************************************************************
3334 * Shifts data bits in from the PHY
3335 *
3336 * hw - Struct containing variables accessed by shared code
3337 *
3338 * Bits are shifted in in MSB to LSB order.
3339 ******************************************************************************/
3340 static uint16_t
3341 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
3342 {
3343 uint32_t ctrl;
3344 uint16_t data = 0;
3345 uint8_t i;
3346
3347 /* In order to read a register from the PHY, we need to shift in a total
3348 * of 18 bits from the PHY. The first two bit (turnaround) times are used
3349 * to avoid contention on the MDIO pin when a read operation is performed.
3350 * These two bits are ignored by us and thrown away. Bits are "shifted in"
3351 * by raising the input to the Management Data Clock (setting the MDC bit),
3352 * and then reading the value of the MDIO bit.
3353 */
3354 ctrl = E1000_READ_REG(hw, CTRL);
3355
3356 /* Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as input. */
3357 ctrl &= ~E1000_CTRL_MDIO_DIR;
3358 ctrl &= ~E1000_CTRL_MDIO;
3359
3360 E1000_WRITE_REG(hw, CTRL, ctrl);
3361 E1000_WRITE_FLUSH(hw);
3362
3363 /* Raise and Lower the clock before reading in the data. This accounts for
3364 * the turnaround bits. The first clock occurred when we clocked out the
3365 * last bit of the Register Address.
3366 */
3367 e1000_raise_mdi_clk(hw, &ctrl);
3368 e1000_lower_mdi_clk(hw, &ctrl);
3369
3370 for (data = 0, i = 0; i < 16; i++) {
3371 data = data << 1;
3372 e1000_raise_mdi_clk(hw, &ctrl);
3373 ctrl = E1000_READ_REG(hw, CTRL);
3374 /* Check to see if we shifted in a "1". */
3375 if (ctrl & E1000_CTRL_MDIO)
3376 data |= 1;
3377 e1000_lower_mdi_clk(hw, &ctrl);
3378 }
3379
3380 e1000_raise_mdi_clk(hw, &ctrl);
3381 e1000_lower_mdi_clk(hw, &ctrl);
3382
3383 return data;
3384 }
3385
3386 static int32_t
3387 e1000_swfw_sync_acquire(struct e1000_hw *hw, uint16_t mask)
3388 {
3389 uint32_t swfw_sync = 0;
3390 uint32_t swmask = mask;
3391 uint32_t fwmask = mask << 16;
3392 int32_t timeout = 200;
3393
3394 DEBUGFUNC("e1000_swfw_sync_acquire");
3395
3396 if (hw->swfwhw_semaphore_present)
3397 return e1000_get_software_flag(hw);
3398
3399 if (!hw->swfw_sync_present)
3400 return e1000_get_hw_eeprom_semaphore(hw);
3401
3402 while (timeout) {
3403 if (e1000_get_hw_eeprom_semaphore(hw))
3404 return -E1000_ERR_SWFW_SYNC;
3405
3406 swfw_sync = E1000_READ_REG(hw, SW_FW_SYNC);
3407 if (!(swfw_sync & (fwmask | swmask))) {
3408 break;
3409 }
3410
3411 /* firmware currently using resource (fwmask) */
3412 /* or other software thread currently using resource (swmask) */
3413 e1000_put_hw_eeprom_semaphore(hw);
3414 mdelay(5);
3415 timeout--;
3416 }
3417
3418 if (!timeout) {
3419 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
3420 return -E1000_ERR_SWFW_SYNC;
3421 }
3422
3423 swfw_sync |= swmask;
3424 E1000_WRITE_REG(hw, SW_FW_SYNC, swfw_sync);
3425
3426 e1000_put_hw_eeprom_semaphore(hw);
3427 return E1000_SUCCESS;
3428 }
3429
3430 static void
3431 e1000_swfw_sync_release(struct e1000_hw *hw, uint16_t mask)
3432 {
3433 uint32_t swfw_sync;
3434 uint32_t swmask = mask;
3435
3436 DEBUGFUNC("e1000_swfw_sync_release");
3437
3438 if (hw->swfwhw_semaphore_present) {
3439 e1000_release_software_flag(hw);
3440 return;
3441 }
3442
3443 if (!hw->swfw_sync_present) {
3444 e1000_put_hw_eeprom_semaphore(hw);
3445 return;
3446 }
3447
3448 /* if (e1000_get_hw_eeprom_semaphore(hw))
3449 * return -E1000_ERR_SWFW_SYNC; */
3450 while (e1000_get_hw_eeprom_semaphore(hw) != E1000_SUCCESS);
3451 /* empty */
3452
3453 swfw_sync = E1000_READ_REG(hw, SW_FW_SYNC);
3454 swfw_sync &= ~swmask;
3455 E1000_WRITE_REG(hw, SW_FW_SYNC, swfw_sync);
3456
3457 e1000_put_hw_eeprom_semaphore(hw);
3458 }
3459
3460 /*****************************************************************************
3461 * Reads the value from a PHY register, if the value is on a specific non zero
3462 * page, sets the page first.
3463 * hw - Struct containing variables accessed by shared code
3464 * reg_addr - address of the PHY register to read
3465 ******************************************************************************/
3466 int32_t
3467 e1000_read_phy_reg(struct e1000_hw *hw,
3468 uint32_t reg_addr,
3469 uint16_t *phy_data)
3470 {
3471 uint32_t ret_val;
3472 uint16_t swfw;
3473
3474 DEBUGFUNC("e1000_read_phy_reg");
3475
3476 if ((hw->mac_type == e1000_80003es2lan) &&
3477 (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)) {
3478 swfw = E1000_SWFW_PHY1_SM;
3479 } else {
3480 swfw = E1000_SWFW_PHY0_SM;
3481 }
3482 if (e1000_swfw_sync_acquire(hw, swfw))
3483 return -E1000_ERR_SWFW_SYNC;
3484
3485 if ((hw->phy_type == e1000_phy_igp ||
3486 hw->phy_type == e1000_phy_igp_3 ||
3487 hw->phy_type == e1000_phy_igp_2) &&
3488 (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
3489 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
3490 (uint16_t)reg_addr);
3491 if (ret_val) {
3492 e1000_swfw_sync_release(hw, swfw);
3493 return ret_val;
3494 }
3495 } else if (hw->phy_type == e1000_phy_gg82563) {
3496 if (((reg_addr & MAX_PHY_REG_ADDRESS) > MAX_PHY_MULTI_PAGE_REG) ||
3497 (hw->mac_type == e1000_80003es2lan)) {
3498 /* Select Configuration Page */
3499 if ((reg_addr & MAX_PHY_REG_ADDRESS) < GG82563_MIN_ALT_REG) {
3500 ret_val = e1000_write_phy_reg_ex(hw, GG82563_PHY_PAGE_SELECT,
3501 (uint16_t)((uint16_t)reg_addr >> GG82563_PAGE_SHIFT));
3502 } else {
3503 /* Use Alternative Page Select register to access
3504 * registers 30 and 31
3505 */
3506 ret_val = e1000_write_phy_reg_ex(hw,
3507 GG82563_PHY_PAGE_SELECT_ALT,
3508 (uint16_t)((uint16_t)reg_addr >> GG82563_PAGE_SHIFT));
3509 }
3510
3511 if (ret_val) {
3512 e1000_swfw_sync_release(hw, swfw);
3513 return ret_val;
3514 }
3515 }
3516 }
3517
3518 ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
3519 phy_data);
3520
3521 e1000_swfw_sync_release(hw, swfw);
3522 return ret_val;
3523 }
3524
3525 static int32_t
3526 e1000_read_phy_reg_ex(struct e1000_hw *hw, uint32_t reg_addr,
3527 uint16_t *phy_data)
3528 {
3529 uint32_t i;
3530 uint32_t mdic = 0;
3531 const uint32_t phy_addr = 1;
3532
3533 DEBUGFUNC("e1000_read_phy_reg_ex");
3534
3535 if (reg_addr > MAX_PHY_REG_ADDRESS) {
3536 DEBUGOUT1("PHY Address %d is out of range\n", reg_addr);
3537 return -E1000_ERR_PARAM;
3538 }
3539
3540 if (hw->mac_type > e1000_82543) {
3541 /* Set up Op-code, Phy Address, and register address in the MDI
3542 * Control register. The MAC will take care of interfacing with the
3543 * PHY to retrieve the desired data.
3544 */
3545 mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
3546 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3547 (E1000_MDIC_OP_READ));
3548
3549 E1000_WRITE_REG(hw, MDIC, mdic);
3550
3551 /* Poll the ready bit to see if the MDI read completed */
3552 for (i = 0; i < 64; i++) {
3553 udelay(50);
3554 mdic = E1000_READ_REG(hw, MDIC);
3555 if (mdic & E1000_MDIC_READY) break;
3556 }
3557 if (!(mdic & E1000_MDIC_READY)) {
3558 DEBUGOUT("MDI Read did not complete\n");
3559 return -E1000_ERR_PHY;
3560 }
3561 if (mdic & E1000_MDIC_ERROR) {
3562 DEBUGOUT("MDI Error\n");
3563 return -E1000_ERR_PHY;
3564 }
3565 *phy_data = (uint16_t) mdic;
3566 } else {
3567 /* We must first send a preamble through the MDIO pin to signal the
3568 * beginning of an MII instruction. This is done by sending 32
3569 * consecutive "1" bits.
3570 */
3571 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3572
3573 /* Now combine the next few fields that are required for a read
3574 * operation. We use this method instead of calling the
3575 * e1000_shift_out_mdi_bits routine five different times. The format of
3576 * a MII read instruction consists of a shift out of 14 bits and is
3577 * defined as follows:
3578 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr>
3579 * followed by a shift in of 18 bits. This first two bits shifted in
3580 * are TurnAround bits used to avoid contention on the MDIO pin when a
3581 * READ operation is performed. These two bits are thrown away
3582 * followed by a shift in of 16 bits which contains the desired data.
3583 */
3584 mdic = ((reg_addr) | (phy_addr << 5) |
3585 (PHY_OP_READ << 10) | (PHY_SOF << 12));
3586
3587 e1000_shift_out_mdi_bits(hw, mdic, 14);
3588
3589 /* Now that we've shifted out the read command to the MII, we need to
3590 * "shift in" the 16-bit value (18 total bits) of the requested PHY
3591 * register address.
3592 */
3593 *phy_data = e1000_shift_in_mdi_bits(hw);
3594 }
3595 return E1000_SUCCESS;
3596 }
3597
3598 /******************************************************************************
3599 * Writes a value to a PHY register
3600 *
3601 * hw - Struct containing variables accessed by shared code
3602 * reg_addr - address of the PHY register to write
3603 * data - data to write to the PHY
3604 ******************************************************************************/
3605 int32_t
3606 e1000_write_phy_reg(struct e1000_hw *hw, uint32_t reg_addr,
3607 uint16_t phy_data)
3608 {
3609 uint32_t ret_val;
3610 uint16_t swfw;
3611
3612 DEBUGFUNC("e1000_write_phy_reg");
3613
3614 if ((hw->mac_type == e1000_80003es2lan) &&
3615 (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)) {
3616 swfw = E1000_SWFW_PHY1_SM;
3617 } else {
3618 swfw = E1000_SWFW_PHY0_SM;
3619 }
3620 if (e1000_swfw_sync_acquire(hw, swfw))
3621 return -E1000_ERR_SWFW_SYNC;
3622
3623 if ((hw->phy_type == e1000_phy_igp ||
3624 hw->phy_type == e1000_phy_igp_3 ||
3625 hw->phy_type == e1000_phy_igp_2) &&
3626 (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
3627 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
3628 (uint16_t)reg_addr);
3629 if (ret_val) {
3630 e1000_swfw_sync_release(hw, swfw);
3631 return ret_val;
3632 }
3633 } else if (hw->phy_type == e1000_phy_gg82563) {
3634 if (((reg_addr & MAX_PHY_REG_ADDRESS) > MAX_PHY_MULTI_PAGE_REG) ||
3635 (hw->mac_type == e1000_80003es2lan)) {
3636 /* Select Configuration Page */
3637 if ((reg_addr & MAX_PHY_REG_ADDRESS) < GG82563_MIN_ALT_REG) {
3638 ret_val = e1000_write_phy_reg_ex(hw, GG82563_PHY_PAGE_SELECT,
3639 (uint16_t)((uint16_t)reg_addr >> GG82563_PAGE_SHIFT));
3640 } else {
3641 /* Use Alternative Page Select register to access
3642 * registers 30 and 31
3643 */
3644 ret_val = e1000_write_phy_reg_ex(hw,
3645 GG82563_PHY_PAGE_SELECT_ALT,
3646 (uint16_t)((uint16_t)reg_addr >> GG82563_PAGE_SHIFT));
3647 }
3648
3649 if (ret_val) {
3650 e1000_swfw_sync_release(hw, swfw);
3651 return ret_val;
3652 }
3653 }
3654 }
3655
3656 ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
3657 phy_data);
3658
3659 e1000_swfw_sync_release(hw, swfw);
3660 return ret_val;
3661 }
3662
3663 static int32_t
3664 e1000_write_phy_reg_ex(struct e1000_hw *hw, uint32_t reg_addr,
3665 uint16_t phy_data)
3666 {
3667 uint32_t i;
3668 uint32_t mdic = 0;
3669 const uint32_t phy_addr = 1;
3670
3671 DEBUGFUNC("e1000_write_phy_reg_ex");
3672
3673 if (reg_addr > MAX_PHY_REG_ADDRESS) {
3674 DEBUGOUT1("PHY Address %d is out of range\n", reg_addr);
3675 return -E1000_ERR_PARAM;
3676 }
3677
3678 if (hw->mac_type > e1000_82543) {
3679 /* Set up Op-code, Phy Address, register address, and data intended
3680 * for the PHY register in the MDI Control register. The MAC will take
3681 * care of interfacing with the PHY to send the desired data.
3682 */
3683 mdic = (((uint32_t) phy_data) |
3684 (reg_addr << E1000_MDIC_REG_SHIFT) |
3685 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3686 (E1000_MDIC_OP_WRITE));
3687
3688 E1000_WRITE_REG(hw, MDIC, mdic);
3689
3690 /* Poll the ready bit to see if the MDI read completed */
3691 for (i = 0; i < 641; i++) {
3692 udelay(5);
3693 mdic = E1000_READ_REG(hw, MDIC);
3694 if (mdic & E1000_MDIC_READY) break;
3695 }
3696 if (!(mdic & E1000_MDIC_READY)) {
3697 DEBUGOUT("MDI Write did not complete\n");
3698 return -E1000_ERR_PHY;
3699 }
3700 } else {
3701 /* We'll need to use the SW defined pins to shift the write command
3702 * out to the PHY. We first send a preamble to the PHY to signal the
3703 * beginning of the MII instruction. This is done by sending 32
3704 * consecutive "1" bits.
3705 */
3706 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3707
3708 /* Now combine the remaining required fields that will indicate a
3709 * write operation. We use this method instead of calling the
3710 * e1000_shift_out_mdi_bits routine for each field in the command. The
3711 * format of a MII write instruction is as follows:
3712 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr><Turnaround><Data>.
3713 */
3714 mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) |
3715 (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
3716 mdic <<= 16;
3717 mdic |= (uint32_t) phy_data;
3718
3719 e1000_shift_out_mdi_bits(hw, mdic, 32);
3720 }
3721
3722 return E1000_SUCCESS;
3723 }
3724
3725 static int32_t
3726 e1000_read_kmrn_reg(struct e1000_hw *hw,
3727 uint32_t reg_addr,
3728 uint16_t *data)
3729 {
3730 uint32_t reg_val;
3731 uint16_t swfw;
3732 DEBUGFUNC("e1000_read_kmrn_reg");
3733
3734 if ((hw->mac_type == e1000_80003es2lan) &&
3735 (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)) {
3736 swfw = E1000_SWFW_PHY1_SM;
3737 } else {
3738 swfw = E1000_SWFW_PHY0_SM;
3739 }
3740 if (e1000_swfw_sync_acquire(hw, swfw))
3741 return -E1000_ERR_SWFW_SYNC;
3742
3743 /* Write register address */
3744 reg_val = ((reg_addr << E1000_KUMCTRLSTA_OFFSET_SHIFT) &
3745 E1000_KUMCTRLSTA_OFFSET) |
3746 E1000_KUMCTRLSTA_REN;
3747 E1000_WRITE_REG(hw, KUMCTRLSTA, reg_val);
3748 udelay(2);
3749
3750 /* Read the data returned */
3751 reg_val = E1000_READ_REG(hw, KUMCTRLSTA);
3752 *data = (uint16_t)reg_val;
3753
3754 e1000_swfw_sync_release(hw, swfw);
3755 return E1000_SUCCESS;
3756 }
3757
3758 static int32_t
3759 e1000_write_kmrn_reg(struct e1000_hw *hw,
3760 uint32_t reg_addr,
3761 uint16_t data)
3762 {
3763 uint32_t reg_val;
3764 uint16_t swfw;
3765 DEBUGFUNC("e1000_write_kmrn_reg");
3766
3767 if ((hw->mac_type == e1000_80003es2lan) &&
3768 (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)) {
3769 swfw = E1000_SWFW_PHY1_SM;
3770 } else {
3771 swfw = E1000_SWFW_PHY0_SM;
3772 }
3773 if (e1000_swfw_sync_acquire(hw, swfw))
3774 return -E1000_ERR_SWFW_SYNC;
3775
3776 reg_val = ((reg_addr << E1000_KUMCTRLSTA_OFFSET_SHIFT) &
3777 E1000_KUMCTRLSTA_OFFSET) | data;
3778 E1000_WRITE_REG(hw, KUMCTRLSTA, reg_val);
3779 udelay(2);
3780
3781 e1000_swfw_sync_release(hw, swfw);
3782 return E1000_SUCCESS;
3783 }
3784
3785 /******************************************************************************
3786 * Returns the PHY to the power-on reset state
3787 *
3788 * hw - Struct containing variables accessed by shared code
3789 ******************************************************************************/
3790 int32_t
3791 e1000_phy_hw_reset(struct e1000_hw *hw)
3792 {
3793 uint32_t ctrl, ctrl_ext;
3794 uint32_t led_ctrl;
3795 int32_t ret_val;
3796 uint16_t swfw;
3797
3798 DEBUGFUNC("e1000_phy_hw_reset");
3799
3800 /* In the case of the phy reset being blocked, it's not an error, we
3801 * simply return success without performing the reset. */
3802 ret_val = e1000_check_phy_reset_block(hw);
3803 if (ret_val)
3804 return E1000_SUCCESS;
3805
3806 DEBUGOUT("Resetting Phy...\n");
3807
3808 if (hw->mac_type > e1000_82543) {
3809 if ((hw->mac_type == e1000_80003es2lan) &&
3810 (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)) {
3811 swfw = E1000_SWFW_PHY1_SM;
3812 } else {
3813 swfw = E1000_SWFW_PHY0_SM;
3814 }
3815 if (e1000_swfw_sync_acquire(hw, swfw)) {
3816 DEBUGOUT("Unable to acquire swfw sync\n");
3817 return -E1000_ERR_SWFW_SYNC;
3818 }
3819 /* Read the device control register and assert the E1000_CTRL_PHY_RST
3820 * bit. Then, take it out of reset.
3821 * For pre-e1000_82571 hardware, we delay for 10ms between the assert
3822 * and deassert. For e1000_82571 hardware and later, we instead delay
3823 * for 50us between and 10ms after the deassertion.
3824 */
3825 ctrl = E1000_READ_REG(hw, CTRL);
3826 E1000_WRITE_REG(hw, CTRL, ctrl | E1000_CTRL_PHY_RST);
3827 E1000_WRITE_FLUSH(hw);
3828
3829 if (hw->mac_type < e1000_82571)
3830 msleep(10);
3831 else
3832 udelay(100);
3833
3834 E1000_WRITE_REG(hw, CTRL, ctrl);
3835 E1000_WRITE_FLUSH(hw);
3836
3837 if (hw->mac_type >= e1000_82571)
3838 mdelay(10);
3839
3840 e1000_swfw_sync_release(hw, swfw);
3841 } else {
3842 /* Read the Extended Device Control Register, assert the PHY_RESET_DIR
3843 * bit to put the PHY into reset. Then, take it out of reset.
3844 */
3845 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
3846 ctrl_ext |= E1000_CTRL_EXT_SDP4_DIR;
3847 ctrl_ext &= ~E1000_CTRL_EXT_SDP4_DATA;
3848 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
3849 E1000_WRITE_FLUSH(hw);
3850 msleep(10);
3851 ctrl_ext |= E1000_CTRL_EXT_SDP4_DATA;
3852 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
3853 E1000_WRITE_FLUSH(hw);
3854 }
3855 udelay(150);
3856
3857 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
3858 /* Configure activity LED after PHY reset */
3859 led_ctrl = E1000_READ_REG(hw, LEDCTL);
3860 led_ctrl &= IGP_ACTIVITY_LED_MASK;
3861 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
3862 E1000_WRITE_REG(hw, LEDCTL, led_ctrl);
3863 }
3864
3865 /* Wait for FW to finish PHY configuration. */
3866 ret_val = e1000_get_phy_cfg_done(hw);
3867 if (ret_val != E1000_SUCCESS)
3868 return ret_val;
3869 e1000_release_software_semaphore(hw);
3870
3871 if ((hw->mac_type == e1000_ich8lan) && (hw->phy_type == e1000_phy_igp_3))
3872 ret_val = e1000_init_lcd_from_nvm(hw);
3873
3874 return ret_val;
3875 }
3876
3877 /******************************************************************************
3878 * Resets the PHY
3879 *
3880 * hw - Struct containing variables accessed by shared code
3881 *
3882 * Sets bit 15 of the MII Control register
3883 ******************************************************************************/
3884 int32_t
3885 e1000_phy_reset(struct e1000_hw *hw)
3886 {
3887 int32_t ret_val;
3888 uint16_t phy_data;
3889
3890 DEBUGFUNC("e1000_phy_reset");
3891
3892 /* In the case of the phy reset being blocked, it's not an error, we
3893 * simply return success without performing the reset. */
3894 ret_val = e1000_check_phy_reset_block(hw);
3895 if (ret_val)
3896 return E1000_SUCCESS;
3897
3898 switch (hw->phy_type) {
3899 case e1000_phy_igp:
3900 case e1000_phy_igp_2:
3901 case e1000_phy_igp_3:
3902 case e1000_phy_ife:
3903 ret_val = e1000_phy_hw_reset(hw);
3904 if (ret_val)
3905 return ret_val;
3906 break;
3907 default:
3908 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
3909 if (ret_val)
3910 return ret_val;
3911
3912 phy_data |= MII_CR_RESET;
3913 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
3914 if (ret_val)
3915 return ret_val;
3916
3917 udelay(1);
3918 break;
3919 }
3920
3921 if (hw->phy_type == e1000_phy_igp || hw->phy_type == e1000_phy_igp_2)
3922 e1000_phy_init_script(hw);
3923
3924 return E1000_SUCCESS;
3925 }
3926
3927 /******************************************************************************
3928 * Work-around for 82566 power-down: on D3 entry-
3929 * 1) disable gigabit link
3930 * 2) write VR power-down enable
3931 * 3) read it back
3932 * if successful continue, else issue LCD reset and repeat
3933 *
3934 * hw - struct containing variables accessed by shared code
3935 ******************************************************************************/
3936 void
3937 e1000_phy_powerdown_workaround(struct e1000_hw *hw)
3938 {
3939 int32_t reg;
3940 uint16_t phy_data;
3941 int32_t retry = 0;
3942
3943 DEBUGFUNC("e1000_phy_powerdown_workaround");
3944
3945 if (hw->phy_type != e1000_phy_igp_3)
3946 return;
3947
3948 do {
3949 /* Disable link */
3950 reg = E1000_READ_REG(hw, PHY_CTRL);
3951 E1000_WRITE_REG(hw, PHY_CTRL, reg | E1000_PHY_CTRL_GBE_DISABLE |
3952 E1000_PHY_CTRL_NOND0A_GBE_DISABLE);
3953
3954 /* Write VR power-down enable - bits 9:8 should be 10b */
3955 e1000_read_phy_reg(hw, IGP3_VR_CTRL, &phy_data);
3956 phy_data |= (1 << 9);
3957 phy_data &= ~(1 << 8);
3958 e1000_write_phy_reg(hw, IGP3_VR_CTRL, phy_data);
3959
3960 /* Read it back and test */
3961 e1000_read_phy_reg(hw, IGP3_VR_CTRL, &phy_data);
3962 if (((phy_data & IGP3_VR_CTRL_MODE_MASK) == IGP3_VR_CTRL_MODE_SHUT) || retry)
3963 break;
3964
3965 /* Issue PHY reset and repeat at most one more time */
3966 reg = E1000_READ_REG(hw, CTRL);
3967 E1000_WRITE_REG(hw, CTRL, reg | E1000_CTRL_PHY_RST);
3968 retry++;
3969 } while (retry);
3970
3971 return;
3972
3973 }
3974
3975 /******************************************************************************
3976 * Work-around for 82566 Kumeran PCS lock loss:
3977 * On link status change (i.e. PCI reset, speed change) and link is up and
3978 * speed is gigabit-
3979 * 0) if workaround is optionally disabled do nothing
3980 * 1) wait 1ms for Kumeran link to come up
3981 * 2) check Kumeran Diagnostic register PCS lock loss bit
3982 * 3) if not set the link is locked (all is good), otherwise...
3983 * 4) reset the PHY
3984 * 5) repeat up to 10 times
3985 * Note: this is only called for IGP3 copper when speed is 1gb.
3986 *
3987 * hw - struct containing variables accessed by shared code
3988 ******************************************************************************/
3989 static int32_t
3990 e1000_kumeran_lock_loss_workaround(struct e1000_hw *hw)
3991 {
3992 int32_t ret_val;
3993 int32_t reg;
3994 int32_t cnt;
3995 uint16_t phy_data;
3996
3997 if (hw->kmrn_lock_loss_workaround_disabled)
3998 return E1000_SUCCESS;
3999
4000 /* Make sure link is up before proceeding. If not just return.
4001 * Attempting this while link is negotiating fouled up link
4002 * stability */
4003 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4004 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4005
4006 if (phy_data & MII_SR_LINK_STATUS) {
4007 for (cnt = 0; cnt < 10; cnt++) {
4008 /* read once to clear */
4009 ret_val = e1000_read_phy_reg(hw, IGP3_KMRN_DIAG, &phy_data);
4010 if (ret_val)
4011 return ret_val;
4012 /* and again to get new status */
4013 ret_val = e1000_read_phy_reg(hw, IGP3_KMRN_DIAG, &phy_data);
4014 if (ret_val)
4015 return ret_val;
4016
4017 /* check for PCS lock */
4018 if (!(phy_data & IGP3_KMRN_DIAG_PCS_LOCK_LOSS))
4019 return E1000_SUCCESS;
4020
4021 /* Issue PHY reset */
4022 e1000_phy_hw_reset(hw);
4023 mdelay(5);
4024 }
4025 /* Disable GigE link negotiation */
4026 reg = E1000_READ_REG(hw, PHY_CTRL);
4027 E1000_WRITE_REG(hw, PHY_CTRL, reg | E1000_PHY_CTRL_GBE_DISABLE |
4028 E1000_PHY_CTRL_NOND0A_GBE_DISABLE);
4029
4030 /* unable to acquire PCS lock */
4031 return E1000_ERR_PHY;
4032 }
4033
4034 return E1000_SUCCESS;
4035 }
4036
4037 /******************************************************************************
4038 * Probes the expected PHY address for known PHY IDs
4039 *
4040 * hw - Struct containing variables accessed by shared code
4041 ******************************************************************************/
4042 static int32_t
4043 e1000_detect_gig_phy(struct e1000_hw *hw)
4044 {
4045 int32_t phy_init_status, ret_val;
4046 uint16_t phy_id_high, phy_id_low;
4047 boolean_t match = FALSE;
4048
4049 DEBUGFUNC("e1000_detect_gig_phy");
4050
4051 if (hw->phy_id != 0)
4052 return E1000_SUCCESS;
4053
4054 /* The 82571 firmware may still be configuring the PHY. In this
4055 * case, we cannot access the PHY until the configuration is done. So
4056 * we explicitly set the PHY values. */
4057 if (hw->mac_type == e1000_82571 ||
4058 hw->mac_type == e1000_82572) {
4059 hw->phy_id = IGP01E1000_I_PHY_ID;
4060 hw->phy_type = e1000_phy_igp_2;
4061 return E1000_SUCCESS;
4062 }
4063
4064 /* ESB-2 PHY reads require e1000_phy_gg82563 to be set because of a work-
4065 * around that forces PHY page 0 to be set or the reads fail. The rest of
4066 * the code in this routine uses e1000_read_phy_reg to read the PHY ID.
4067 * So for ESB-2 we need to have this set so our reads won't fail. If the
4068 * attached PHY is not a e1000_phy_gg82563, the routines below will figure
4069 * this out as well. */
4070 if (hw->mac_type == e1000_80003es2lan)
4071 hw->phy_type = e1000_phy_gg82563;
4072
4073 /* Read the PHY ID Registers to identify which PHY is onboard. */
4074 ret_val = e1000_read_phy_reg(hw, PHY_ID1, &phy_id_high);
4075 if (ret_val)
4076 return ret_val;
4077
4078 hw->phy_id = (uint32_t) (phy_id_high << 16);
4079 udelay(20);
4080 ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low);
4081 if (ret_val)
4082 return ret_val;
4083
4084 hw->phy_id |= (uint32_t) (phy_id_low & PHY_REVISION_MASK);
4085 hw->phy_revision = (uint32_t) phy_id_low & ~PHY_REVISION_MASK;
4086
4087 switch (hw->mac_type) {
4088 case e1000_82543:
4089 if (hw->phy_id == M88E1000_E_PHY_ID) match = TRUE;
4090 break;
4091 case e1000_82544:
4092 if (hw->phy_id == M88E1000_I_PHY_ID) match = TRUE;
4093 break;
4094 case e1000_82540:
4095 case e1000_82545:
4096 case e1000_82545_rev_3:
4097 case e1000_82546:
4098 case e1000_82546_rev_3:
4099 if (hw->phy_id == M88E1011_I_PHY_ID) match = TRUE;
4100 break;
4101 case e1000_82541:
4102 case e1000_82541_rev_2:
4103 case e1000_82547:
4104 case e1000_82547_rev_2:
4105 if (hw->phy_id == IGP01E1000_I_PHY_ID) match = TRUE;
4106 break;
4107 case e1000_82573:
4108 if (hw->phy_id == M88E1111_I_PHY_ID) match = TRUE;
4109 break;
4110 case e1000_80003es2lan:
4111 if (hw->phy_id == GG82563_E_PHY_ID) match = TRUE;
4112 break;
4113 case e1000_ich8lan:
4114 if (hw->phy_id == IGP03E1000_E_PHY_ID) match = TRUE;
4115 if (hw->phy_id == IFE_E_PHY_ID) match = TRUE;
4116 if (hw->phy_id == IFE_PLUS_E_PHY_ID) match = TRUE;
4117 if (hw->phy_id == IFE_C_E_PHY_ID) match = TRUE;
4118 break;
4119 default:
4120 DEBUGOUT1("Invalid MAC type %d\n", hw->mac_type);
4121 return -E1000_ERR_CONFIG;
4122 }
4123 phy_init_status = e1000_set_phy_type(hw);
4124
4125 if ((match) && (phy_init_status == E1000_SUCCESS)) {
4126 DEBUGOUT1("PHY ID 0x%X detected\n", hw->phy_id);
4127 return E1000_SUCCESS;
4128 }
4129 DEBUGOUT1("Invalid PHY ID 0x%X\n", hw->phy_id);
4130 return -E1000_ERR_PHY;
4131 }
4132
4133 /******************************************************************************
4134 * Resets the PHY's DSP
4135 *
4136 * hw - Struct containing variables accessed by shared code
4137 ******************************************************************************/
4138 static int32_t
4139 e1000_phy_reset_dsp(struct e1000_hw *hw)
4140 {
4141 int32_t ret_val;
4142 DEBUGFUNC("e1000_phy_reset_dsp");
4143
4144 do {
4145 if (hw->phy_type != e1000_phy_gg82563) {
4146 ret_val = e1000_write_phy_reg(hw, 29, 0x001d);
4147 if (ret_val) break;
4148 }
4149 ret_val = e1000_write_phy_reg(hw, 30, 0x00c1);
4150 if (ret_val) break;
4151 ret_val = e1000_write_phy_reg(hw, 30, 0x0000);
4152 if (ret_val) break;
4153 ret_val = E1000_SUCCESS;
4154 } while (0);
4155
4156 return ret_val;
4157 }
4158
4159 /******************************************************************************
4160 * Get PHY information from various PHY registers for igp PHY only.
4161 *
4162 * hw - Struct containing variables accessed by shared code
4163 * phy_info - PHY information structure
4164 ******************************************************************************/
4165 static int32_t
4166 e1000_phy_igp_get_info(struct e1000_hw *hw,
4167 struct e1000_phy_info *phy_info)
4168 {
4169 int32_t ret_val;
4170 uint16_t phy_data, min_length, max_length, average;
4171 e1000_rev_polarity polarity;
4172
4173 DEBUGFUNC("e1000_phy_igp_get_info");
4174
4175 /* The downshift status is checked only once, after link is established,
4176 * and it stored in the hw->speed_downgraded parameter. */
4177 phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4178
4179 /* IGP01E1000 does not need to support it. */
4180 phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
4181
4182 /* IGP01E1000 always correct polarity reversal */
4183 phy_info->polarity_correction = e1000_polarity_reversal_enabled;
4184
4185 /* Check polarity status */
4186 ret_val = e1000_check_polarity(hw, &polarity);
4187 if (ret_val)
4188 return ret_val;
4189
4190 phy_info->cable_polarity = polarity;
4191
4192 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS, &phy_data);
4193 if (ret_val)
4194 return ret_val;
4195
4196 phy_info->mdix_mode = (e1000_auto_x_mode)((phy_data & IGP01E1000_PSSR_MDIX) >>
4197 IGP01E1000_PSSR_MDIX_SHIFT);
4198
4199 if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
4200 IGP01E1000_PSSR_SPEED_1000MBPS) {
4201 /* Local/Remote Receiver Information are only valid at 1000 Mbps */
4202 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
4203 if (ret_val)
4204 return ret_val;
4205
4206 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
4207 SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
4208 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4209 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
4210 SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
4211 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4212
4213 /* Get cable length */
4214 ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
4215 if (ret_val)
4216 return ret_val;
4217
4218 /* Translate to old method */
4219 average = (max_length + min_length) / 2;
4220
4221 if (average <= e1000_igp_cable_length_50)
4222 phy_info->cable_length = e1000_cable_length_50;
4223 else if (average <= e1000_igp_cable_length_80)
4224 phy_info->cable_length = e1000_cable_length_50_80;
4225 else if (average <= e1000_igp_cable_length_110)
4226 phy_info->cable_length = e1000_cable_length_80_110;
4227 else if (average <= e1000_igp_cable_length_140)
4228 phy_info->cable_length = e1000_cable_length_110_140;
4229 else
4230 phy_info->cable_length = e1000_cable_length_140;
4231 }
4232
4233 return E1000_SUCCESS;
4234 }
4235
4236 /******************************************************************************
4237 * Get PHY information from various PHY registers for ife PHY only.
4238 *
4239 * hw - Struct containing variables accessed by shared code
4240 * phy_info - PHY information structure
4241 ******************************************************************************/
4242 static int32_t
4243 e1000_phy_ife_get_info(struct e1000_hw *hw,
4244 struct e1000_phy_info *phy_info)
4245 {
4246 int32_t ret_val;
4247 uint16_t phy_data;
4248 e1000_rev_polarity polarity;
4249
4250 DEBUGFUNC("e1000_phy_ife_get_info");
4251
4252 phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4253 phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
4254
4255 ret_val = e1000_read_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL, &phy_data);
4256 if (ret_val)
4257 return ret_val;
4258 phy_info->polarity_correction =
4259 ((phy_data & IFE_PSC_AUTO_POLARITY_DISABLE) >>
4260 IFE_PSC_AUTO_POLARITY_DISABLE_SHIFT) ?
4261 e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
4262
4263 if (phy_info->polarity_correction == e1000_polarity_reversal_enabled) {
4264 ret_val = e1000_check_polarity(hw, &polarity);
4265 if (ret_val)
4266 return ret_val;
4267 } else {
4268 /* Polarity is forced. */
4269 polarity = ((phy_data & IFE_PSC_FORCE_POLARITY) >>
4270 IFE_PSC_FORCE_POLARITY_SHIFT) ?
4271 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
4272 }
4273 phy_info->cable_polarity = polarity;
4274
4275 ret_val = e1000_read_phy_reg(hw, IFE_PHY_MDIX_CONTROL, &phy_data);
4276 if (ret_val)
4277 return ret_val;
4278
4279 phy_info->mdix_mode = (e1000_auto_x_mode)
4280 ((phy_data & (IFE_PMC_AUTO_MDIX | IFE_PMC_FORCE_MDIX)) >>
4281 IFE_PMC_MDIX_MODE_SHIFT);
4282
4283 return E1000_SUCCESS;
4284 }
4285
4286 /******************************************************************************
4287 * Get PHY information from various PHY registers fot m88 PHY only.
4288 *
4289 * hw - Struct containing variables accessed by shared code
4290 * phy_info - PHY information structure
4291 ******************************************************************************/
4292 static int32_t
4293 e1000_phy_m88_get_info(struct e1000_hw *hw,
4294 struct e1000_phy_info *phy_info)
4295 {
4296 int32_t ret_val;
4297 uint16_t phy_data;
4298 e1000_rev_polarity polarity;
4299
4300 DEBUGFUNC("e1000_phy_m88_get_info");
4301
4302 /* The downshift status is checked only once, after link is established,
4303 * and it stored in the hw->speed_downgraded parameter. */
4304 phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4305
4306 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
4307 if (ret_val)
4308 return ret_val;
4309
4310 phy_info->extended_10bt_distance =
4311 ((phy_data & M88E1000_PSCR_10BT_EXT_DIST_ENABLE) >>
4312 M88E1000_PSCR_10BT_EXT_DIST_ENABLE_SHIFT) ?
4313 e1000_10bt_ext_dist_enable_lower : e1000_10bt_ext_dist_enable_normal;
4314
4315 phy_info->polarity_correction =
4316 ((phy_data & M88E1000_PSCR_POLARITY_REVERSAL) >>
4317 M88E1000_PSCR_POLARITY_REVERSAL_SHIFT) ?
4318 e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
4319
4320 /* Check polarity status */
4321 ret_val = e1000_check_polarity(hw, &polarity);
4322 if (ret_val)
4323 return ret_val;
4324 phy_info->cable_polarity = polarity;
4325
4326 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
4327 if (ret_val)
4328 return ret_val;
4329
4330 phy_info->mdix_mode = (e1000_auto_x_mode)((phy_data & M88E1000_PSSR_MDIX) >>
4331 M88E1000_PSSR_MDIX_SHIFT);
4332
4333 if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
4334 /* Cable Length Estimation and Local/Remote Receiver Information
4335 * are only valid at 1000 Mbps.
4336 */
4337 if (hw->phy_type != e1000_phy_gg82563) {
4338 phy_info->cable_length = (e1000_cable_length)((phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
4339 M88E1000_PSSR_CABLE_LENGTH_SHIFT);
4340 } else {
4341 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_DSP_DISTANCE,
4342 &phy_data);
4343 if (ret_val)
4344 return ret_val;
4345
4346 phy_info->cable_length = (e1000_cable_length)(phy_data & GG82563_DSPD_CABLE_LENGTH);
4347 }
4348
4349 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
4350 if (ret_val)
4351 return ret_val;
4352
4353 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
4354 SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
4355 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4356 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
4357 SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
4358 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4359
4360 }
4361
4362 return E1000_SUCCESS;
4363 }
4364
4365 /******************************************************************************
4366 * Get PHY information from various PHY registers
4367 *
4368 * hw - Struct containing variables accessed by shared code
4369 * phy_info - PHY information structure
4370 ******************************************************************************/
4371 int32_t
4372 e1000_phy_get_info(struct e1000_hw *hw,
4373 struct e1000_phy_info *phy_info)
4374 {
4375 int32_t ret_val;
4376 uint16_t phy_data;
4377
4378 DEBUGFUNC("e1000_phy_get_info");
4379
4380 phy_info->cable_length = e1000_cable_length_undefined;
4381 phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_undefined;
4382 phy_info->cable_polarity = e1000_rev_polarity_undefined;
4383 phy_info->downshift = e1000_downshift_undefined;
4384 phy_info->polarity_correction = e1000_polarity_reversal_undefined;
4385 phy_info->mdix_mode = e1000_auto_x_mode_undefined;
4386 phy_info->local_rx = e1000_1000t_rx_status_undefined;
4387 phy_info->remote_rx = e1000_1000t_rx_status_undefined;
4388
4389 if (hw->media_type != e1000_media_type_copper) {
4390 DEBUGOUT("PHY info is only valid for copper media\n");
4391 return -E1000_ERR_CONFIG;
4392 }
4393
4394 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4395 if (ret_val)
4396 return ret_val;
4397
4398 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4399 if (ret_val)
4400 return ret_val;
4401
4402 if ((phy_data & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) {
4403 DEBUGOUT("PHY info is only valid if link is up\n");
4404 return -E1000_ERR_CONFIG;
4405 }
4406
4407 if (hw->phy_type == e1000_phy_igp ||
4408 hw->phy_type == e1000_phy_igp_3 ||
4409 hw->phy_type == e1000_phy_igp_2)
4410 return e1000_phy_igp_get_info(hw, phy_info);
4411 else if (hw->phy_type == e1000_phy_ife)
4412 return e1000_phy_ife_get_info(hw, phy_info);
4413 else
4414 return e1000_phy_m88_get_info(hw, phy_info);
4415 }
4416
4417 int32_t
4418 e1000_validate_mdi_setting(struct e1000_hw *hw)
4419 {
4420 DEBUGFUNC("e1000_validate_mdi_settings");
4421
4422 if (!hw->autoneg && (hw->mdix == 0 || hw->mdix == 3)) {
4423 DEBUGOUT("Invalid MDI setting detected\n");
4424 hw->mdix = 1;
4425 return -E1000_ERR_CONFIG;
4426 }
4427 return E1000_SUCCESS;
4428 }
4429
4430
4431 /******************************************************************************
4432 * Sets up eeprom variables in the hw struct. Must be called after mac_type
4433 * is configured. Additionally, if this is ICH8, the flash controller GbE
4434 * registers must be mapped, or this will crash.
4435 *
4436 * hw - Struct containing variables accessed by shared code
4437 *****************************************************************************/
4438 int32_t
4439 e1000_init_eeprom_params(struct e1000_hw *hw)
4440 {
4441 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4442 uint32_t eecd = E1000_READ_REG(hw, EECD);
4443 int32_t ret_val = E1000_SUCCESS;
4444 uint16_t eeprom_size;
4445
4446 DEBUGFUNC("e1000_init_eeprom_params");
4447
4448 switch (hw->mac_type) {
4449 case e1000_82542_rev2_0:
4450 case e1000_82542_rev2_1:
4451 case e1000_82543:
4452 case e1000_82544:
4453 eeprom->type = e1000_eeprom_microwire;
4454 eeprom->word_size = 64;
4455 eeprom->opcode_bits = 3;
4456 eeprom->address_bits = 6;
4457 eeprom->delay_usec = 50;
4458 eeprom->use_eerd = FALSE;
4459 eeprom->use_eewr = FALSE;
4460 break;
4461 case e1000_82540:
4462 case e1000_82545:
4463 case e1000_82545_rev_3:
4464 case e1000_82546:
4465 case e1000_82546_rev_3:
4466 eeprom->type = e1000_eeprom_microwire;
4467 eeprom->opcode_bits = 3;
4468 eeprom->delay_usec = 50;
4469 if (eecd & E1000_EECD_SIZE) {
4470 eeprom->word_size = 256;
4471 eeprom->address_bits = 8;
4472 } else {
4473 eeprom->word_size = 64;
4474 eeprom->address_bits = 6;
4475 }
4476 eeprom->use_eerd = FALSE;
4477 eeprom->use_eewr = FALSE;
4478 break;
4479 case e1000_82541:
4480 case e1000_82541_rev_2:
4481 case e1000_82547:
4482 case e1000_82547_rev_2:
4483 if (eecd & E1000_EECD_TYPE) {
4484 eeprom->type = e1000_eeprom_spi;
4485 eeprom->opcode_bits = 8;
4486 eeprom->delay_usec = 1;
4487 if (eecd & E1000_EECD_ADDR_BITS) {
4488 eeprom->page_size = 32;
4489 eeprom->address_bits = 16;
4490 } else {
4491 eeprom->page_size = 8;
4492 eeprom->address_bits = 8;
4493 }
4494 } else {
4495 eeprom->type = e1000_eeprom_microwire;
4496 eeprom->opcode_bits = 3;
4497 eeprom->delay_usec = 50;
4498 if (eecd & E1000_EECD_ADDR_BITS) {
4499 eeprom->word_size = 256;
4500 eeprom->address_bits = 8;
4501 } else {
4502 eeprom->word_size = 64;
4503 eeprom->address_bits = 6;
4504 }
4505 }
4506 eeprom->use_eerd = FALSE;
4507 eeprom->use_eewr = FALSE;
4508 break;
4509 case e1000_82571:
4510 case e1000_82572:
4511 eeprom->type = e1000_eeprom_spi;
4512 eeprom->opcode_bits = 8;
4513 eeprom->delay_usec = 1;
4514 if (eecd & E1000_EECD_ADDR_BITS) {
4515 eeprom->page_size = 32;
4516 eeprom->address_bits = 16;
4517 } else {
4518 eeprom->page_size = 8;
4519 eeprom->address_bits = 8;
4520 }
4521 eeprom->use_eerd = FALSE;
4522 eeprom->use_eewr = FALSE;
4523 break;
4524 case e1000_82573:
4525 eeprom->type = e1000_eeprom_spi;
4526 eeprom->opcode_bits = 8;
4527 eeprom->delay_usec = 1;
4528 if (eecd & E1000_EECD_ADDR_BITS) {
4529 eeprom->page_size = 32;
4530 eeprom->address_bits = 16;
4531 } else {
4532 eeprom->page_size = 8;
4533 eeprom->address_bits = 8;
4534 }
4535 eeprom->use_eerd = TRUE;
4536 eeprom->use_eewr = TRUE;
4537 if (e1000_is_onboard_nvm_eeprom(hw) == FALSE) {
4538 eeprom->type = e1000_eeprom_flash;
4539 eeprom->word_size = 2048;
4540
4541 /* Ensure that the Autonomous FLASH update bit is cleared due to
4542 * Flash update issue on parts which use a FLASH for NVM. */
4543 eecd &= ~E1000_EECD_AUPDEN;
4544 E1000_WRITE_REG(hw, EECD, eecd);
4545 }
4546 break;
4547 case e1000_80003es2lan:
4548 eeprom->type = e1000_eeprom_spi;
4549 eeprom->opcode_bits = 8;
4550 eeprom->delay_usec = 1;
4551 if (eecd & E1000_EECD_ADDR_BITS) {
4552 eeprom->page_size = 32;
4553 eeprom->address_bits = 16;
4554 } else {
4555 eeprom->page_size = 8;
4556 eeprom->address_bits = 8;
4557 }
4558 eeprom->use_eerd = TRUE;
4559 eeprom->use_eewr = FALSE;
4560 break;
4561 case e1000_ich8lan:
4562 {
4563 int32_t i = 0;
4564 uint32_t flash_size = E1000_READ_ICH_FLASH_REG(hw, ICH_FLASH_GFPREG);
4565
4566 eeprom->type = e1000_eeprom_ich8;
4567 eeprom->use_eerd = FALSE;
4568 eeprom->use_eewr = FALSE;
4569 eeprom->word_size = E1000_SHADOW_RAM_WORDS;
4570
4571 /* Zero the shadow RAM structure. But don't load it from NVM
4572 * so as to save time for driver init */
4573 if (hw->eeprom_shadow_ram != NULL) {
4574 for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
4575 hw->eeprom_shadow_ram[i].modified = FALSE;
4576 hw->eeprom_shadow_ram[i].eeprom_word = 0xFFFF;
4577 }
4578 }
4579
4580 hw->flash_base_addr = (flash_size & ICH_GFPREG_BASE_MASK) *
4581 ICH_FLASH_SECTOR_SIZE;
4582
4583 hw->flash_bank_size = ((flash_size >> 16) & ICH_GFPREG_BASE_MASK) + 1;
4584 hw->flash_bank_size -= (flash_size & ICH_GFPREG_BASE_MASK);
4585
4586 hw->flash_bank_size *= ICH_FLASH_SECTOR_SIZE;
4587
4588 hw->flash_bank_size /= 2 * sizeof(uint16_t);
4589
4590 break;
4591 }
4592 default:
4593 break;
4594 }
4595
4596 if (eeprom->type == e1000_eeprom_spi) {
4597 /* eeprom_size will be an enum [0..8] that maps to eeprom sizes 128B to
4598 * 32KB (incremented by powers of 2).
4599 */
4600 if (hw->mac_type <= e1000_82547_rev_2) {
4601 /* Set to default value for initial eeprom read. */
4602 eeprom->word_size = 64;
4603 ret_val = e1000_read_eeprom(hw, EEPROM_CFG, 1, &eeprom_size);
4604 if (ret_val)
4605 return ret_val;
4606 eeprom_size = (eeprom_size & EEPROM_SIZE_MASK) >> EEPROM_SIZE_SHIFT;
4607 /* 256B eeprom size was not supported in earlier hardware, so we
4608 * bump eeprom_size up one to ensure that "1" (which maps to 256B)
4609 * is never the result used in the shifting logic below. */
4610 if (eeprom_size)
4611 eeprom_size++;
4612 } else {
4613 eeprom_size = (uint16_t)((eecd & E1000_EECD_SIZE_EX_MASK) >>
4614 E1000_EECD_SIZE_EX_SHIFT);
4615 }
4616
4617 eeprom->word_size = 1 << (eeprom_size + EEPROM_WORD_SIZE_SHIFT);
4618 }
4619 return ret_val;
4620 }
4621
4622 /******************************************************************************
4623 * Raises the EEPROM's clock input.
4624 *
4625 * hw - Struct containing variables accessed by shared code
4626 * eecd - EECD's current value
4627 *****************************************************************************/
4628 static void
4629 e1000_raise_ee_clk(struct e1000_hw *hw,
4630 uint32_t *eecd)
4631 {
4632 /* Raise the clock input to the EEPROM (by setting the SK bit), and then
4633 * wait <delay> microseconds.
4634 */
4635 *eecd = *eecd | E1000_EECD_SK;
4636 E1000_WRITE_REG(hw, EECD, *eecd);
4637 E1000_WRITE_FLUSH(hw);
4638 udelay(hw->eeprom.delay_usec);
4639 }
4640
4641 /******************************************************************************
4642 * Lowers the EEPROM's clock input.
4643 *
4644 * hw - Struct containing variables accessed by shared code
4645 * eecd - EECD's current value
4646 *****************************************************************************/
4647 static void
4648 e1000_lower_ee_clk(struct e1000_hw *hw,
4649 uint32_t *eecd)
4650 {
4651 /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
4652 * wait 50 microseconds.
4653 */
4654 *eecd = *eecd & ~E1000_EECD_SK;
4655 E1000_WRITE_REG(hw, EECD, *eecd);
4656 E1000_WRITE_FLUSH(hw);
4657 udelay(hw->eeprom.delay_usec);
4658 }
4659
4660 /******************************************************************************
4661 * Shift data bits out to the EEPROM.
4662 *
4663 * hw - Struct containing variables accessed by shared code
4664 * data - data to send to the EEPROM
4665 * count - number of bits to shift out
4666 *****************************************************************************/
4667 static void
4668 e1000_shift_out_ee_bits(struct e1000_hw *hw,
4669 uint16_t data,
4670 uint16_t count)
4671 {
4672 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4673 uint32_t eecd;
4674 uint32_t mask;
4675
4676 /* We need to shift "count" bits out to the EEPROM. So, value in the
4677 * "data" parameter will be shifted out to the EEPROM one bit at a time.
4678 * In order to do this, "data" must be broken down into bits.
4679 */
4680 mask = 0x01 << (count - 1);
4681 eecd = E1000_READ_REG(hw, EECD);
4682 if (eeprom->type == e1000_eeprom_microwire) {
4683 eecd &= ~E1000_EECD_DO;
4684 } else if (eeprom->type == e1000_eeprom_spi) {
4685 eecd |= E1000_EECD_DO;
4686 }
4687 do {
4688 /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
4689 * and then raising and then lowering the clock (the SK bit controls
4690 * the clock input to the EEPROM). A "0" is shifted out to the EEPROM
4691 * by setting "DI" to "0" and then raising and then lowering the clock.
4692 */
4693 eecd &= ~E1000_EECD_DI;
4694
4695 if (data & mask)
4696 eecd |= E1000_EECD_DI;
4697
4698 E1000_WRITE_REG(hw, EECD, eecd);
4699 E1000_WRITE_FLUSH(hw);
4700
4701 udelay(eeprom->delay_usec);
4702
4703 e1000_raise_ee_clk(hw, &eecd);
4704 e1000_lower_ee_clk(hw, &eecd);
4705
4706 mask = mask >> 1;
4707
4708 } while (mask);
4709
4710 /* We leave the "DI" bit set to "0" when we leave this routine. */
4711 eecd &= ~E1000_EECD_DI;
4712 E1000_WRITE_REG(hw, EECD, eecd);
4713 }
4714
4715 /******************************************************************************
4716 * Shift data bits in from the EEPROM
4717 *
4718 * hw - Struct containing variables accessed by shared code
4719 *****************************************************************************/
4720 static uint16_t
4721 e1000_shift_in_ee_bits(struct e1000_hw *hw,
4722 uint16_t count)
4723 {
4724 uint32_t eecd;
4725 uint32_t i;
4726 uint16_t data;
4727
4728 /* In order to read a register from the EEPROM, we need to shift 'count'
4729 * bits in from the EEPROM. Bits are "shifted in" by raising the clock
4730 * input to the EEPROM (setting the SK bit), and then reading the value of
4731 * the "DO" bit. During this "shifting in" process the "DI" bit should
4732 * always be clear.
4733 */
4734
4735 eecd = E1000_READ_REG(hw, EECD);
4736
4737 eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
4738 data = 0;
4739
4740 for (i = 0; i < count; i++) {
4741 data = data << 1;
4742 e1000_raise_ee_clk(hw, &eecd);
4743
4744 eecd = E1000_READ_REG(hw, EECD);
4745
4746 eecd &= ~(E1000_EECD_DI);
4747 if (eecd & E1000_EECD_DO)
4748 data |= 1;
4749
4750 e1000_lower_ee_clk(hw, &eecd);
4751 }
4752
4753 return data;
4754 }
4755
4756 /******************************************************************************
4757 * Prepares EEPROM for access
4758 *
4759 * hw - Struct containing variables accessed by shared code
4760 *
4761 * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
4762 * function should be called before issuing a command to the EEPROM.
4763 *****************************************************************************/
4764 static int32_t
4765 e1000_acquire_eeprom(struct e1000_hw *hw)
4766 {
4767 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4768 uint32_t eecd, i=0;
4769
4770 DEBUGFUNC("e1000_acquire_eeprom");
4771
4772 if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
4773 return -E1000_ERR_SWFW_SYNC;
4774 eecd = E1000_READ_REG(hw, EECD);
4775
4776 if (hw->mac_type != e1000_82573) {
4777 /* Request EEPROM Access */
4778 if (hw->mac_type > e1000_82544) {
4779 eecd |= E1000_EECD_REQ;
4780 E1000_WRITE_REG(hw, EECD, eecd);
4781 eecd = E1000_READ_REG(hw, EECD);
4782 while ((!(eecd & E1000_EECD_GNT)) &&
4783 (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
4784 i++;
4785 udelay(5);
4786 eecd = E1000_READ_REG(hw, EECD);
4787 }
4788 if (!(eecd & E1000_EECD_GNT)) {
4789 eecd &= ~E1000_EECD_REQ;
4790 E1000_WRITE_REG(hw, EECD, eecd);
4791 DEBUGOUT("Could not acquire EEPROM grant\n");
4792 e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
4793 return -E1000_ERR_EEPROM;
4794 }
4795 }
4796 }
4797
4798 /* Setup EEPROM for Read/Write */
4799
4800 if (eeprom->type == e1000_eeprom_microwire) {
4801 /* Clear SK and DI */
4802 eecd &= ~(E1000_EECD_DI | E1000_EECD_SK);
4803 E1000_WRITE_REG(hw, EECD, eecd);
4804
4805 /* Set CS */
4806 eecd |= E1000_EECD_CS;
4807 E1000_WRITE_REG(hw, EECD, eecd);
4808 } else if (eeprom->type == e1000_eeprom_spi) {
4809 /* Clear SK and CS */
4810 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
4811 E1000_WRITE_REG(hw, EECD, eecd);
4812 udelay(1);
4813 }
4814
4815 return E1000_SUCCESS;
4816 }
4817
4818 /******************************************************************************
4819 * Returns EEPROM to a "standby" state
4820 *
4821 * hw - Struct containing variables accessed by shared code
4822 *****************************************************************************/
4823 static void
4824 e1000_standby_eeprom(struct e1000_hw *hw)
4825 {
4826 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4827 uint32_t eecd;
4828
4829 eecd = E1000_READ_REG(hw, EECD);
4830
4831 if (eeprom->type == e1000_eeprom_microwire) {
4832 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
4833 E1000_WRITE_REG(hw, EECD, eecd);
4834 E1000_WRITE_FLUSH(hw);
4835 udelay(eeprom->delay_usec);
4836
4837 /* Clock high */
4838 eecd |= E1000_EECD_SK;
4839 E1000_WRITE_REG(hw, EECD, eecd);
4840 E1000_WRITE_FLUSH(hw);
4841 udelay(eeprom->delay_usec);
4842
4843 /* Select EEPROM */
4844 eecd |= E1000_EECD_CS;
4845 E1000_WRITE_REG(hw, EECD, eecd);
4846 E1000_WRITE_FLUSH(hw);
4847 udelay(eeprom->delay_usec);
4848
4849 /* Clock low */
4850 eecd &= ~E1000_EECD_SK;
4851 E1000_WRITE_REG(hw, EECD, eecd);
4852 E1000_WRITE_FLUSH(hw);
4853 udelay(eeprom->delay_usec);
4854 } else if (eeprom->type == e1000_eeprom_spi) {
4855 /* Toggle CS to flush commands */
4856 eecd |= E1000_EECD_CS;
4857 E1000_WRITE_REG(hw, EECD, eecd);
4858 E1000_WRITE_FLUSH(hw);
4859 udelay(eeprom->delay_usec);
4860 eecd &= ~E1000_EECD_CS;
4861 E1000_WRITE_REG(hw, EECD, eecd);
4862 E1000_WRITE_FLUSH(hw);
4863 udelay(eeprom->delay_usec);
4864 }
4865 }
4866
4867 /******************************************************************************
4868 * Terminates a command by inverting the EEPROM's chip select pin
4869 *
4870 * hw - Struct containing variables accessed by shared code
4871 *****************************************************************************/
4872 static void
4873 e1000_release_eeprom(struct e1000_hw *hw)
4874 {
4875 uint32_t eecd;
4876
4877 DEBUGFUNC("e1000_release_eeprom");
4878
4879 eecd = E1000_READ_REG(hw, EECD);
4880
4881 if (hw->eeprom.type == e1000_eeprom_spi) {
4882 eecd |= E1000_EECD_CS; /* Pull CS high */
4883 eecd &= ~E1000_EECD_SK; /* Lower SCK */
4884
4885 E1000_WRITE_REG(hw, EECD, eecd);
4886
4887 udelay(hw->eeprom.delay_usec);
4888 } else if (hw->eeprom.type == e1000_eeprom_microwire) {
4889 /* cleanup eeprom */
4890
4891 /* CS on Microwire is active-high */
4892 eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
4893
4894 E1000_WRITE_REG(hw, EECD, eecd);
4895
4896 /* Rising edge of clock */
4897 eecd |= E1000_EECD_SK;
4898 E1000_WRITE_REG(hw, EECD, eecd);
4899 E1000_WRITE_FLUSH(hw);
4900 udelay(hw->eeprom.delay_usec);
4901
4902 /* Falling edge of clock */
4903 eecd &= ~E1000_EECD_SK;
4904 E1000_WRITE_REG(hw, EECD, eecd);
4905 E1000_WRITE_FLUSH(hw);
4906 udelay(hw->eeprom.delay_usec);
4907 }
4908
4909 /* Stop requesting EEPROM access */
4910 if (hw->mac_type > e1000_82544) {
4911 eecd &= ~E1000_EECD_REQ;
4912 E1000_WRITE_REG(hw, EECD, eecd);
4913 }
4914
4915 e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
4916 }
4917
4918 /******************************************************************************
4919 * Reads a 16 bit word from the EEPROM.
4920 *
4921 * hw - Struct containing variables accessed by shared code
4922 *****************************************************************************/
4923 static int32_t
4924 e1000_spi_eeprom_ready(struct e1000_hw *hw)
4925 {
4926 uint16_t retry_count = 0;
4927 uint8_t spi_stat_reg;
4928
4929 DEBUGFUNC("e1000_spi_eeprom_ready");
4930
4931 /* Read "Status Register" repeatedly until the LSB is cleared. The
4932 * EEPROM will signal that the command has been completed by clearing
4933 * bit 0 of the internal status register. If it's not cleared within
4934 * 5 milliseconds, then error out.
4935 */
4936 retry_count = 0;
4937 do {
4938 e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI,
4939 hw->eeprom.opcode_bits);
4940 spi_stat_reg = (uint8_t)e1000_shift_in_ee_bits(hw, 8);
4941 if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI))
4942 break;
4943
4944 udelay(5);
4945 retry_count += 5;
4946
4947 e1000_standby_eeprom(hw);
4948 } while (retry_count < EEPROM_MAX_RETRY_SPI);
4949
4950 /* ATMEL SPI write time could vary from 0-20mSec on 3.3V devices (and
4951 * only 0-5mSec on 5V devices)
4952 */
4953 if (retry_count >= EEPROM_MAX_RETRY_SPI) {
4954 DEBUGOUT("SPI EEPROM Status error\n");
4955 return -E1000_ERR_EEPROM;
4956 }
4957
4958 return E1000_SUCCESS;
4959 }
4960
4961 /******************************************************************************
4962 * Reads a 16 bit word from the EEPROM.
4963 *
4964 * hw - Struct containing variables accessed by shared code
4965 * offset - offset of word in the EEPROM to read
4966 * data - word read from the EEPROM
4967 * words - number of words to read
4968 *****************************************************************************/
4969 int32_t
4970 e1000_read_eeprom(struct e1000_hw *hw,
4971 uint16_t offset,
4972 uint16_t words,
4973 uint16_t *data)
4974 {
4975 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4976 uint32_t i = 0;
4977
4978 DEBUGFUNC("e1000_read_eeprom");
4979
4980 /* If eeprom is not yet detected, do so now */
4981 if (eeprom->word_size == 0)
4982 e1000_init_eeprom_params(hw);
4983
4984 /* A check for invalid values: offset too large, too many words, and not
4985 * enough words.
4986 */
4987 if ((offset >= eeprom->word_size) || (words > eeprom->word_size - offset) ||
4988 (words == 0)) {
4989 DEBUGOUT2("\"words\" parameter out of bounds. Words = %d, size = %d\n", offset, eeprom->word_size);
4990 return -E1000_ERR_EEPROM;
4991 }
4992
4993 /* EEPROM's that don't use EERD to read require us to bit-bang the SPI
4994 * directly. In this case, we need to acquire the EEPROM so that
4995 * FW or other port software does not interrupt.
4996 */
4997 if (e1000_is_onboard_nvm_eeprom(hw) == TRUE &&
4998 hw->eeprom.use_eerd == FALSE) {
4999 /* Prepare the EEPROM for bit-bang reading */
5000 if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
5001 return -E1000_ERR_EEPROM;
5002 }
5003
5004 /* Eerd register EEPROM access requires no eeprom aquire/release */
5005 if (eeprom->use_eerd == TRUE)
5006 return e1000_read_eeprom_eerd(hw, offset, words, data);
5007
5008 /* ICH EEPROM access is done via the ICH flash controller */
5009 if (eeprom->type == e1000_eeprom_ich8)
5010 return e1000_read_eeprom_ich8(hw, offset, words, data);
5011
5012 /* Set up the SPI or Microwire EEPROM for bit-bang reading. We have
5013 * acquired the EEPROM at this point, so any returns should relase it */
5014 if (eeprom->type == e1000_eeprom_spi) {
5015 uint16_t word_in;
5016 uint8_t read_opcode = EEPROM_READ_OPCODE_SPI;
5017
5018 if (e1000_spi_eeprom_ready(hw)) {
5019 e1000_release_eeprom(hw);
5020 return -E1000_ERR_EEPROM;
5021 }
5022
5023 e1000_standby_eeprom(hw);
5024
5025 /* Some SPI eeproms use the 8th address bit embedded in the opcode */
5026 if ((eeprom->address_bits == 8) && (offset >= 128))
5027 read_opcode |= EEPROM_A8_OPCODE_SPI;
5028
5029 /* Send the READ command (opcode + addr) */
5030 e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits);
5031 e1000_shift_out_ee_bits(hw, (uint16_t)(offset*2), eeprom->address_bits);
5032
5033 /* Read the data. The address of the eeprom internally increments with
5034 * each byte (spi) being read, saving on the overhead of eeprom setup
5035 * and tear-down. The address counter will roll over if reading beyond
5036 * the size of the eeprom, thus allowing the entire memory to be read
5037 * starting from any offset. */
5038 for (i = 0; i < words; i++) {
5039 word_in = e1000_shift_in_ee_bits(hw, 16);
5040 data[i] = (word_in >> 8) | (word_in << 8);
5041 }
5042 } else if (eeprom->type == e1000_eeprom_microwire) {
5043 for (i = 0; i < words; i++) {
5044 /* Send the READ command (opcode + addr) */
5045 e1000_shift_out_ee_bits(hw, EEPROM_READ_OPCODE_MICROWIRE,
5046 eeprom->opcode_bits);
5047 e1000_shift_out_ee_bits(hw, (uint16_t)(offset + i),
5048 eeprom->address_bits);
5049
5050 /* Read the data. For microwire, each word requires the overhead
5051 * of eeprom setup and tear-down. */
5052 data[i] = e1000_shift_in_ee_bits(hw, 16);
5053 e1000_standby_eeprom(hw);
5054 }
5055 }
5056
5057 /* End this read operation */
5058 e1000_release_eeprom(hw);
5059
5060 return E1000_SUCCESS;
5061 }
5062
5063 /******************************************************************************
5064 * Reads a 16 bit word from the EEPROM using the EERD register.
5065 *
5066 * hw - Struct containing variables accessed by shared code
5067 * offset - offset of word in the EEPROM to read
5068 * data - word read from the EEPROM
5069 * words - number of words to read
5070 *****************************************************************************/
5071 static int32_t
5072 e1000_read_eeprom_eerd(struct e1000_hw *hw,
5073 uint16_t offset,
5074 uint16_t words,
5075 uint16_t *data)
5076 {
5077 uint32_t i, eerd = 0;
5078 int32_t error = 0;
5079
5080 for (i = 0; i < words; i++) {
5081 eerd = ((offset+i) << E1000_EEPROM_RW_ADDR_SHIFT) +
5082 E1000_EEPROM_RW_REG_START;
5083
5084 E1000_WRITE_REG(hw, EERD, eerd);
5085 error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_READ);
5086
5087 if (error) {
5088 break;
5089 }
5090 data[i] = (E1000_READ_REG(hw, EERD) >> E1000_EEPROM_RW_REG_DATA);
5091
5092 }
5093
5094 return error;
5095 }
5096
5097 /******************************************************************************
5098 * Writes a 16 bit word from the EEPROM using the EEWR register.
5099 *
5100 * hw - Struct containing variables accessed by shared code
5101 * offset - offset of word in the EEPROM to read
5102 * data - word read from the EEPROM
5103 * words - number of words to read
5104 *****************************************************************************/
5105 static int32_t
5106 e1000_write_eeprom_eewr(struct e1000_hw *hw,
5107 uint16_t offset,
5108 uint16_t words,
5109 uint16_t *data)
5110 {
5111 uint32_t register_value = 0;
5112 uint32_t i = 0;
5113 int32_t error = 0;
5114
5115 if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
5116 return -E1000_ERR_SWFW_SYNC;
5117
5118 for (i = 0; i < words; i++) {
5119 register_value = (data[i] << E1000_EEPROM_RW_REG_DATA) |
5120 ((offset+i) << E1000_EEPROM_RW_ADDR_SHIFT) |
5121 E1000_EEPROM_RW_REG_START;
5122
5123 error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_WRITE);
5124 if (error) {
5125 break;
5126 }
5127
5128 E1000_WRITE_REG(hw, EEWR, register_value);
5129
5130 error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_WRITE);
5131
5132 if (error) {
5133 break;
5134 }
5135 }
5136
5137 e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
5138 return error;
5139 }
5140
5141 /******************************************************************************
5142 * Polls the status bit (bit 1) of the EERD to determine when the read is done.
5143 *
5144 * hw - Struct containing variables accessed by shared code
5145 *****************************************************************************/
5146 static int32_t
5147 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd)
5148 {
5149 uint32_t attempts = 100000;
5150 uint32_t i, reg = 0;
5151 int32_t done = E1000_ERR_EEPROM;
5152
5153 for (i = 0; i < attempts; i++) {
5154 if (eerd == E1000_EEPROM_POLL_READ)
5155 reg = E1000_READ_REG(hw, EERD);
5156 else
5157 reg = E1000_READ_REG(hw, EEWR);
5158
5159 if (reg & E1000_EEPROM_RW_REG_DONE) {
5160 done = E1000_SUCCESS;
5161 break;
5162 }
5163 udelay(5);
5164 }
5165
5166 return done;
5167 }
5168
5169 /***************************************************************************
5170 * Description: Determines if the onboard NVM is FLASH or EEPROM.
5171 *
5172 * hw - Struct containing variables accessed by shared code
5173 ****************************************************************************/
5174 static boolean_t
5175 e1000_is_onboard_nvm_eeprom(struct e1000_hw *hw)
5176 {
5177 uint32_t eecd = 0;
5178
5179 DEBUGFUNC("e1000_is_onboard_nvm_eeprom");
5180
5181 if (hw->mac_type == e1000_ich8lan)
5182 return FALSE;
5183
5184 if (hw->mac_type == e1000_82573) {
5185 eecd = E1000_READ_REG(hw, EECD);
5186
5187 /* Isolate bits 15 & 16 */
5188 eecd = ((eecd >> 15) & 0x03);
5189
5190 /* If both bits are set, device is Flash type */
5191 if (eecd == 0x03) {
5192 return FALSE;
5193 }
5194 }
5195 return TRUE;
5196 }
5197
5198 /******************************************************************************
5199 * Verifies that the EEPROM has a valid checksum
5200 *
5201 * hw - Struct containing variables accessed by shared code
5202 *
5203 * Reads the first 64 16 bit words of the EEPROM and sums the values read.
5204 * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
5205 * valid.
5206 *****************************************************************************/
5207 int32_t
5208 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
5209 {
5210 uint16_t checksum = 0;
5211 uint16_t i, eeprom_data;
5212
5213 DEBUGFUNC("e1000_validate_eeprom_checksum");
5214
5215 if ((hw->mac_type == e1000_82573) &&
5216 (e1000_is_onboard_nvm_eeprom(hw) == FALSE)) {
5217 /* Check bit 4 of word 10h. If it is 0, firmware is done updating
5218 * 10h-12h. Checksum may need to be fixed. */
5219 e1000_read_eeprom(hw, 0x10, 1, &eeprom_data);
5220 if ((eeprom_data & 0x10) == 0) {
5221 /* Read 0x23 and check bit 15. This bit is a 1 when the checksum
5222 * has already been fixed. If the checksum is still wrong and this
5223 * bit is a 1, we need to return bad checksum. Otherwise, we need
5224 * to set this bit to a 1 and update the checksum. */
5225 e1000_read_eeprom(hw, 0x23, 1, &eeprom_data);
5226 if ((eeprom_data & 0x8000) == 0) {
5227 eeprom_data |= 0x8000;
5228 e1000_write_eeprom(hw, 0x23, 1, &eeprom_data);
5229 e1000_update_eeprom_checksum(hw);
5230 }
5231 }
5232 }
5233
5234 if (hw->mac_type == e1000_ich8lan) {
5235 /* Drivers must allocate the shadow ram structure for the
5236 * EEPROM checksum to be updated. Otherwise, this bit as well
5237 * as the checksum must both be set correctly for this
5238 * validation to pass.
5239 */
5240 e1000_read_eeprom(hw, 0x19, 1, &eeprom_data);
5241 if ((eeprom_data & 0x40) == 0) {
5242 eeprom_data |= 0x40;
5243 e1000_write_eeprom(hw, 0x19, 1, &eeprom_data);
5244 e1000_update_eeprom_checksum(hw);
5245 }
5246 }
5247
5248 for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
5249 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
5250 DEBUGOUT("EEPROM Read Error\n");
5251 return -E1000_ERR_EEPROM;
5252 }
5253 checksum += eeprom_data;
5254 }
5255
5256 if (checksum == (uint16_t) EEPROM_SUM)
5257 return E1000_SUCCESS;
5258 else {
5259 DEBUGOUT("EEPROM Checksum Invalid\n");
5260 return -E1000_ERR_EEPROM;
5261 }
5262 }
5263
5264 /******************************************************************************
5265 * Calculates the EEPROM checksum and writes it to the EEPROM
5266 *
5267 * hw - Struct containing variables accessed by shared code
5268 *
5269 * Sums the first 63 16 bit words of the EEPROM. Subtracts the sum from 0xBABA.
5270 * Writes the difference to word offset 63 of the EEPROM.
5271 *****************************************************************************/
5272 int32_t
5273 e1000_update_eeprom_checksum(struct e1000_hw *hw)
5274 {
5275 uint32_t ctrl_ext;
5276 uint16_t checksum = 0;
5277 uint16_t i, eeprom_data;
5278
5279 DEBUGFUNC("e1000_update_eeprom_checksum");
5280
5281 for (i = 0; i < EEPROM_CHECKSUM_REG; i++) {
5282 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
5283 DEBUGOUT("EEPROM Read Error\n");
5284 return -E1000_ERR_EEPROM;
5285 }
5286 checksum += eeprom_data;
5287 }
5288 checksum = (uint16_t) EEPROM_SUM - checksum;
5289 if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) {
5290 DEBUGOUT("EEPROM Write Error\n");
5291 return -E1000_ERR_EEPROM;
5292 } else if (hw->eeprom.type == e1000_eeprom_flash) {
5293 e1000_commit_shadow_ram(hw);
5294 } else if (hw->eeprom.type == e1000_eeprom_ich8) {
5295 e1000_commit_shadow_ram(hw);
5296 /* Reload the EEPROM, or else modifications will not appear
5297 * until after next adapter reset. */
5298 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
5299 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
5300 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
5301 msleep(10);
5302 }
5303 return E1000_SUCCESS;
5304 }
5305
5306 /******************************************************************************
5307 * Parent function for writing words to the different EEPROM types.
5308 *
5309 * hw - Struct containing variables accessed by shared code
5310 * offset - offset within the EEPROM to be written to
5311 * words - number of words to write
5312 * data - 16 bit word to be written to the EEPROM
5313 *
5314 * If e1000_update_eeprom_checksum is not called after this function, the
5315 * EEPROM will most likely contain an invalid checksum.
5316 *****************************************************************************/
5317 int32_t
5318 e1000_write_eeprom(struct e1000_hw *hw,
5319 uint16_t offset,
5320 uint16_t words,
5321 uint16_t *data)
5322 {
5323 struct e1000_eeprom_info *eeprom = &hw->eeprom;
5324 int32_t status = 0;
5325
5326 DEBUGFUNC("e1000_write_eeprom");
5327
5328 /* If eeprom is not yet detected, do so now */
5329 if (eeprom->word_size == 0)
5330 e1000_init_eeprom_params(hw);
5331
5332 /* A check for invalid values: offset too large, too many words, and not
5333 * enough words.
5334 */
5335 if ((offset >= eeprom->word_size) || (words > eeprom->word_size - offset) ||
5336 (words == 0)) {
5337 DEBUGOUT("\"words\" parameter out of bounds\n");
5338 return -E1000_ERR_EEPROM;
5339 }
5340
5341 /* 82573 writes only through eewr */
5342 if (eeprom->use_eewr == TRUE)
5343 return e1000_write_eeprom_eewr(hw, offset, words, data);
5344
5345 if (eeprom->type == e1000_eeprom_ich8)
5346 return e1000_write_eeprom_ich8(hw, offset, words, data);
5347
5348 /* Prepare the EEPROM for writing */
5349 if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
5350 return -E1000_ERR_EEPROM;
5351
5352 if (eeprom->type == e1000_eeprom_microwire) {
5353 status = e1000_write_eeprom_microwire(hw, offset, words, data);
5354 } else {
5355 status = e1000_write_eeprom_spi(hw, offset, words, data);
5356 msleep(10);
5357 }
5358
5359 /* Done with writing */
5360 e1000_release_eeprom(hw);
5361
5362 return status;
5363 }
5364
5365 /******************************************************************************
5366 * Writes a 16 bit word to a given offset in an SPI EEPROM.
5367 *
5368 * hw - Struct containing variables accessed by shared code
5369 * offset - offset within the EEPROM to be written to
5370 * words - number of words to write
5371 * data - pointer to array of 8 bit words to be written to the EEPROM
5372 *
5373 *****************************************************************************/
5374 static int32_t
5375 e1000_write_eeprom_spi(struct e1000_hw *hw,
5376 uint16_t offset,
5377 uint16_t words,
5378 uint16_t *data)
5379 {
5380 struct e1000_eeprom_info *eeprom = &hw->eeprom;
5381 uint16_t widx = 0;
5382
5383 DEBUGFUNC("e1000_write_eeprom_spi");
5384
5385 while (widx < words) {
5386 uint8_t write_opcode = EEPROM_WRITE_OPCODE_SPI;
5387
5388 if (e1000_spi_eeprom_ready(hw)) return -E1000_ERR_EEPROM;
5389
5390 e1000_standby_eeprom(hw);
5391
5392 /* Send the WRITE ENABLE command (8 bit opcode ) */
5393 e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI,
5394 eeprom->opcode_bits);
5395
5396 e1000_standby_eeprom(hw);
5397
5398 /* Some SPI eeproms use the 8th address bit embedded in the opcode */
5399 if ((eeprom->address_bits == 8) && (offset >= 128))
5400 write_opcode |= EEPROM_A8_OPCODE_SPI;
5401
5402 /* Send the Write command (8-bit opcode + addr) */
5403 e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits);
5404
5405 e1000_shift_out_ee_bits(hw, (uint16_t)((offset + widx)*2),
5406 eeprom->address_bits);
5407
5408 /* Send the data */
5409
5410 /* Loop to allow for up to whole page write (32 bytes) of eeprom */
5411 while (widx < words) {
5412 uint16_t word_out = data[widx];
5413 word_out = (word_out >> 8) | (word_out << 8);
5414 e1000_shift_out_ee_bits(hw, word_out, 16);
5415 widx++;
5416
5417 /* Some larger eeprom sizes are capable of a 32-byte PAGE WRITE
5418 * operation, while the smaller eeproms are capable of an 8-byte
5419 * PAGE WRITE operation. Break the inner loop to pass new address
5420 */
5421 if ((((offset + widx)*2) % eeprom->page_size) == 0) {
5422 e1000_standby_eeprom(hw);
5423 break;
5424 }
5425 }
5426 }
5427
5428 return E1000_SUCCESS;
5429 }
5430
5431 /******************************************************************************
5432 * Writes a 16 bit word to a given offset in a Microwire EEPROM.
5433 *
5434 * hw - Struct containing variables accessed by shared code
5435 * offset - offset within the EEPROM to be written to
5436 * words - number of words to write
5437 * data - pointer to array of 16 bit words to be written to the EEPROM
5438 *
5439 *****************************************************************************/
5440 static int32_t
5441 e1000_write_eeprom_microwire(struct e1000_hw *hw,
5442 uint16_t offset,
5443 uint16_t words,
5444 uint16_t *data)
5445 {
5446 struct e1000_eeprom_info *eeprom = &hw->eeprom;
5447 uint32_t eecd;
5448 uint16_t words_written = 0;
5449 uint16_t i = 0;
5450
5451 DEBUGFUNC("e1000_write_eeprom_microwire");
5452
5453 /* Send the write enable command to the EEPROM (3-bit opcode plus
5454 * 6/8-bit dummy address beginning with 11). It's less work to include
5455 * the 11 of the dummy address as part of the opcode than it is to shift
5456 * it over the correct number of bits for the address. This puts the
5457 * EEPROM into write/erase mode.
5458 */
5459 e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE,
5460 (uint16_t)(eeprom->opcode_bits + 2));
5461
5462 e1000_shift_out_ee_bits(hw, 0, (uint16_t)(eeprom->address_bits - 2));
5463
5464 /* Prepare the EEPROM */
5465 e1000_standby_eeprom(hw);
5466
5467 while (words_written < words) {
5468 /* Send the Write command (3-bit opcode + addr) */
5469 e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE,
5470 eeprom->opcode_bits);
5471
5472 e1000_shift_out_ee_bits(hw, (uint16_t)(offset + words_written),
5473 eeprom->address_bits);
5474
5475 /* Send the data */
5476 e1000_shift_out_ee_bits(hw, data[words_written], 16);
5477
5478 /* Toggle the CS line. This in effect tells the EEPROM to execute
5479 * the previous command.
5480 */
5481 e1000_standby_eeprom(hw);
5482
5483 /* Read DO repeatedly until it is high (equal to '1'). The EEPROM will
5484 * signal that the command has been completed by raising the DO signal.
5485 * If DO does not go high in 10 milliseconds, then error out.
5486 */
5487 for (i = 0; i < 200; i++) {
5488 eecd = E1000_READ_REG(hw, EECD);
5489 if (eecd & E1000_EECD_DO) break;
5490 udelay(50);
5491 }
5492 if (i == 200) {
5493 DEBUGOUT("EEPROM Write did not complete\n");
5494 return -E1000_ERR_EEPROM;
5495 }
5496
5497 /* Recover from write */
5498 e1000_standby_eeprom(hw);
5499
5500 words_written++;
5501 }
5502
5503 /* Send the write disable command to the EEPROM (3-bit opcode plus
5504 * 6/8-bit dummy address beginning with 10). It's less work to include
5505 * the 10 of the dummy address as part of the opcode than it is to shift
5506 * it over the correct number of bits for the address. This takes the
5507 * EEPROM out of write/erase mode.
5508 */
5509 e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE,
5510 (uint16_t)(eeprom->opcode_bits + 2));
5511
5512 e1000_shift_out_ee_bits(hw, 0, (uint16_t)(eeprom->address_bits - 2));
5513
5514 return E1000_SUCCESS;
5515 }
5516
5517 /******************************************************************************
5518 * Flushes the cached eeprom to NVM. This is done by saving the modified values
5519 * in the eeprom cache and the non modified values in the currently active bank
5520 * to the new bank.
5521 *
5522 * hw - Struct containing variables accessed by shared code
5523 * offset - offset of word in the EEPROM to read
5524 * data - word read from the EEPROM
5525 * words - number of words to read
5526 *****************************************************************************/
5527 static int32_t
5528 e1000_commit_shadow_ram(struct e1000_hw *hw)
5529 {
5530 uint32_t attempts = 100000;
5531 uint32_t eecd = 0;
5532 uint32_t flop = 0;
5533 uint32_t i = 0;
5534 int32_t error = E1000_SUCCESS;
5535 uint32_t old_bank_offset = 0;
5536 uint32_t new_bank_offset = 0;
5537 uint8_t low_byte = 0;
5538 uint8_t high_byte = 0;
5539 boolean_t sector_write_failed = FALSE;
5540
5541 if (hw->mac_type == e1000_82573) {
5542 /* The flop register will be used to determine if flash type is STM */
5543 flop = E1000_READ_REG(hw, FLOP);
5544 for (i=0; i < attempts; i++) {
5545 eecd = E1000_READ_REG(hw, EECD);
5546 if ((eecd & E1000_EECD_FLUPD) == 0) {
5547 break;
5548 }
5549 udelay(5);
5550 }
5551
5552 if (i == attempts) {
5553 return -E1000_ERR_EEPROM;
5554 }
5555
5556 /* If STM opcode located in bits 15:8 of flop, reset firmware */
5557 if ((flop & 0xFF00) == E1000_STM_OPCODE) {
5558 E1000_WRITE_REG(hw, HICR, E1000_HICR_FW_RESET);
5559 }
5560
5561 /* Perform the flash update */
5562 E1000_WRITE_REG(hw, EECD, eecd | E1000_EECD_FLUPD);
5563
5564 for (i=0; i < attempts; i++) {
5565 eecd = E1000_READ_REG(hw, EECD);
5566 if ((eecd & E1000_EECD_FLUPD) == 0) {
5567 break;
5568 }
5569 udelay(5);
5570 }
5571
5572 if (i == attempts) {
5573 return -E1000_ERR_EEPROM;
5574 }
5575 }
5576
5577 if (hw->mac_type == e1000_ich8lan && hw->eeprom_shadow_ram != NULL) {
5578 /* We're writing to the opposite bank so if we're on bank 1,
5579 * write to bank 0 etc. We also need to erase the segment that
5580 * is going to be written */
5581 if (!(E1000_READ_REG(hw, EECD) & E1000_EECD_SEC1VAL)) {
5582 new_bank_offset = hw->flash_bank_size * 2;
5583 old_bank_offset = 0;
5584 e1000_erase_ich8_4k_segment(hw, 1);
5585 } else {
5586 old_bank_offset = hw->flash_bank_size * 2;
5587 new_bank_offset = 0;
5588 e1000_erase_ich8_4k_segment(hw, 0);
5589 }
5590
5591 sector_write_failed = FALSE;
5592 /* Loop for every byte in the shadow RAM,
5593 * which is in units of words. */
5594 for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
5595 /* Determine whether to write the value stored
5596 * in the other NVM bank or a modified value stored
5597 * in the shadow RAM */
5598 if (hw->eeprom_shadow_ram[i].modified == TRUE) {
5599 low_byte = (uint8_t)hw->eeprom_shadow_ram[i].eeprom_word;
5600 udelay(100);
5601 error = e1000_verify_write_ich8_byte(hw,
5602 (i << 1) + new_bank_offset, low_byte);
5603
5604 if (error != E1000_SUCCESS)
5605 sector_write_failed = TRUE;
5606 else {
5607 high_byte =
5608 (uint8_t)(hw->eeprom_shadow_ram[i].eeprom_word >> 8);
5609 udelay(100);
5610 }
5611 } else {
5612 e1000_read_ich8_byte(hw, (i << 1) + old_bank_offset,
5613 &low_byte);
5614 udelay(100);
5615 error = e1000_verify_write_ich8_byte(hw,
5616 (i << 1) + new_bank_offset, low_byte);
5617
5618 if (error != E1000_SUCCESS)
5619 sector_write_failed = TRUE;
5620 else {
5621 e1000_read_ich8_byte(hw, (i << 1) + old_bank_offset + 1,
5622 &high_byte);
5623 udelay(100);
5624 }
5625 }
5626
5627 /* If the write of the low byte was successful, go ahread and
5628 * write the high byte while checking to make sure that if it
5629 * is the signature byte, then it is handled properly */
5630 if (sector_write_failed == FALSE) {
5631 /* If the word is 0x13, then make sure the signature bits
5632 * (15:14) are 11b until the commit has completed.
5633 * This will allow us to write 10b which indicates the
5634 * signature is valid. We want to do this after the write
5635 * has completed so that we don't mark the segment valid
5636 * while the write is still in progress */
5637 if (i == E1000_ICH_NVM_SIG_WORD)
5638 high_byte = E1000_ICH_NVM_SIG_MASK | high_byte;
5639
5640 error = e1000_verify_write_ich8_byte(hw,
5641 (i << 1) + new_bank_offset + 1, high_byte);
5642 if (error != E1000_SUCCESS)
5643 sector_write_failed = TRUE;
5644
5645 } else {
5646 /* If the write failed then break from the loop and
5647 * return an error */
5648 break;
5649 }
5650 }
5651
5652 /* Don't bother writing the segment valid bits if sector
5653 * programming failed. */
5654 if (sector_write_failed == FALSE) {
5655 /* Finally validate the new segment by setting bit 15:14
5656 * to 10b in word 0x13 , this can be done without an
5657 * erase as well since these bits are 11 to start with
5658 * and we need to change bit 14 to 0b */
5659 e1000_read_ich8_byte(hw,
5660 E1000_ICH_NVM_SIG_WORD * 2 + 1 + new_bank_offset,
5661 &high_byte);
5662 high_byte &= 0xBF;
5663 error = e1000_verify_write_ich8_byte(hw,
5664 E1000_ICH_NVM_SIG_WORD * 2 + 1 + new_bank_offset, high_byte);
5665 /* And invalidate the previously valid segment by setting
5666 * its signature word (0x13) high_byte to 0b. This can be
5667 * done without an erase because flash erase sets all bits
5668 * to 1's. We can write 1's to 0's without an erase */
5669 if (error == E1000_SUCCESS) {
5670 error = e1000_verify_write_ich8_byte(hw,
5671 E1000_ICH_NVM_SIG_WORD * 2 + 1 + old_bank_offset, 0);
5672 }
5673
5674 /* Clear the now not used entry in the cache */
5675 for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
5676 hw->eeprom_shadow_ram[i].modified = FALSE;
5677 hw->eeprom_shadow_ram[i].eeprom_word = 0xFFFF;
5678 }
5679 }
5680 }
5681
5682 return error;
5683 }
5684
5685 /******************************************************************************
5686 * Reads the adapter's MAC address from the EEPROM and inverts the LSB for the
5687 * second function of dual function devices
5688 *
5689 * hw - Struct containing variables accessed by shared code
5690 *****************************************************************************/
5691 int32_t
5692 e1000_read_mac_addr(struct e1000_hw * hw)
5693 {
5694 uint16_t offset;
5695 uint16_t eeprom_data, i;
5696
5697 DEBUGFUNC("e1000_read_mac_addr");
5698
5699 for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
5700 offset = i >> 1;
5701 if (e1000_read_eeprom(hw, offset, 1, &eeprom_data) < 0) {
5702 DEBUGOUT("EEPROM Read Error\n");
5703 return -E1000_ERR_EEPROM;
5704 }
5705 hw->perm_mac_addr[i] = (uint8_t) (eeprom_data & 0x00FF);
5706 hw->perm_mac_addr[i+1] = (uint8_t) (eeprom_data >> 8);
5707 }
5708
5709 switch (hw->mac_type) {
5710 default:
5711 break;
5712 case e1000_82546:
5713 case e1000_82546_rev_3:
5714 case e1000_82571:
5715 case e1000_80003es2lan:
5716 if (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)
5717 hw->perm_mac_addr[5] ^= 0x01;
5718 break;
5719 }
5720
5721 for (i = 0; i < NODE_ADDRESS_SIZE; i++)
5722 hw->mac_addr[i] = hw->perm_mac_addr[i];
5723 return E1000_SUCCESS;
5724 }
5725
5726 /******************************************************************************
5727 * Initializes receive address filters.
5728 *
5729 * hw - Struct containing variables accessed by shared code
5730 *
5731 * Places the MAC address in receive address register 0 and clears the rest
5732 * of the receive addresss registers. Clears the multicast table. Assumes
5733 * the receiver is in reset when the routine is called.
5734 *****************************************************************************/
5735 static void
5736 e1000_init_rx_addrs(struct e1000_hw *hw)
5737 {
5738 uint32_t i;
5739 uint32_t rar_num;
5740
5741 DEBUGFUNC("e1000_init_rx_addrs");
5742
5743 /* Setup the receive address. */
5744 DEBUGOUT("Programming MAC Address into RAR[0]\n");
5745
5746 e1000_rar_set(hw, hw->mac_addr, 0);
5747
5748 rar_num = E1000_RAR_ENTRIES;
5749
5750 /* Reserve a spot for the Locally Administered Address to work around
5751 * an 82571 issue in which a reset on one port will reload the MAC on
5752 * the other port. */
5753 if ((hw->mac_type == e1000_82571) && (hw->laa_is_present == TRUE))
5754 rar_num -= 1;
5755 if (hw->mac_type == e1000_ich8lan)
5756 rar_num = E1000_RAR_ENTRIES_ICH8LAN;
5757
5758 /* Zero out the other 15 receive addresses. */
5759 DEBUGOUT("Clearing RAR[1-15]\n");
5760 for (i = 1; i < rar_num; i++) {
5761 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
5762 E1000_WRITE_FLUSH(hw);
5763 E1000_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
5764 E1000_WRITE_FLUSH(hw);
5765 }
5766 }
5767
5768 /******************************************************************************
5769 * Hashes an address to determine its location in the multicast table
5770 *
5771 * hw - Struct containing variables accessed by shared code
5772 * mc_addr - the multicast address to hash
5773 *****************************************************************************/
5774 uint32_t
5775 e1000_hash_mc_addr(struct e1000_hw *hw,
5776 uint8_t *mc_addr)
5777 {
5778 uint32_t hash_value = 0;
5779
5780 /* The portion of the address that is used for the hash table is
5781 * determined by the mc_filter_type setting.
5782 */
5783 switch (hw->mc_filter_type) {
5784 /* [0] [1] [2] [3] [4] [5]
5785 * 01 AA 00 12 34 56
5786 * LSB MSB
5787 */
5788 case 0:
5789 if (hw->mac_type == e1000_ich8lan) {
5790 /* [47:38] i.e. 0x158 for above example address */
5791 hash_value = ((mc_addr[4] >> 6) | (((uint16_t) mc_addr[5]) << 2));
5792 } else {
5793 /* [47:36] i.e. 0x563 for above example address */
5794 hash_value = ((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4));
5795 }
5796 break;
5797 case 1:
5798 if (hw->mac_type == e1000_ich8lan) {
5799 /* [46:37] i.e. 0x2B1 for above example address */
5800 hash_value = ((mc_addr[4] >> 5) | (((uint16_t) mc_addr[5]) << 3));
5801 } else {
5802 /* [46:35] i.e. 0xAC6 for above example address */
5803 hash_value = ((mc_addr[4] >> 3) | (((uint16_t) mc_addr[5]) << 5));
5804 }
5805 break;
5806 case 2:
5807 if (hw->mac_type == e1000_ich8lan) {
5808 /*[45:36] i.e. 0x163 for above example address */
5809 hash_value = ((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4));
5810 } else {
5811 /* [45:34] i.e. 0x5D8 for above example address */
5812 hash_value = ((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6));
5813 }
5814 break;
5815 case 3:
5816 if (hw->mac_type == e1000_ich8lan) {
5817 /* [43:34] i.e. 0x18D for above example address */
5818 hash_value = ((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6));
5819 } else {
5820 /* [43:32] i.e. 0x634 for above example address */
5821 hash_value = ((mc_addr[4]) | (((uint16_t) mc_addr[5]) << 8));
5822 }
5823 break;
5824 }
5825
5826 hash_value &= 0xFFF;
5827 if (hw->mac_type == e1000_ich8lan)
5828 hash_value &= 0x3FF;
5829
5830 return hash_value;
5831 }
5832
5833 /******************************************************************************
5834 * Sets the bit in the multicast table corresponding to the hash value.
5835 *
5836 * hw - Struct containing variables accessed by shared code
5837 * hash_value - Multicast address hash value
5838 *****************************************************************************/
5839 void
5840 e1000_mta_set(struct e1000_hw *hw,
5841 uint32_t hash_value)
5842 {
5843 uint32_t hash_bit, hash_reg;
5844 uint32_t mta;
5845 uint32_t temp;
5846
5847 /* The MTA is a register array of 128 32-bit registers.
5848 * It is treated like an array of 4096 bits. We want to set
5849 * bit BitArray[hash_value]. So we figure out what register
5850 * the bit is in, read it, OR in the new bit, then write
5851 * back the new value. The register is determined by the
5852 * upper 7 bits of the hash value and the bit within that
5853 * register are determined by the lower 5 bits of the value.
5854 */
5855 hash_reg = (hash_value >> 5) & 0x7F;
5856 if (hw->mac_type == e1000_ich8lan)
5857 hash_reg &= 0x1F;
5858
5859 hash_bit = hash_value & 0x1F;
5860
5861 mta = E1000_READ_REG_ARRAY(hw, MTA, hash_reg);
5862
5863 mta |= (1 << hash_bit);
5864
5865 /* If we are on an 82544 and we are trying to write an odd offset
5866 * in the MTA, save off the previous entry before writing and
5867 * restore the old value after writing.
5868 */
5869 if ((hw->mac_type == e1000_82544) && ((hash_reg & 0x1) == 1)) {
5870 temp = E1000_READ_REG_ARRAY(hw, MTA, (hash_reg - 1));
5871 E1000_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta);
5872 E1000_WRITE_FLUSH(hw);
5873 E1000_WRITE_REG_ARRAY(hw, MTA, (hash_reg - 1), temp);
5874 E1000_WRITE_FLUSH(hw);
5875 } else {
5876 E1000_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta);
5877 E1000_WRITE_FLUSH(hw);
5878 }
5879 }
5880
5881 /******************************************************************************
5882 * Puts an ethernet address into a receive address register.
5883 *
5884 * hw - Struct containing variables accessed by shared code
5885 * addr - Address to put into receive address register
5886 * index - Receive address register to write
5887 *****************************************************************************/
5888 void
5889 e1000_rar_set(struct e1000_hw *hw,
5890 uint8_t *addr,
5891 uint32_t index)
5892 {
5893 uint32_t rar_low, rar_high;
5894
5895 /* HW expects these in little endian so we reverse the byte order
5896 * from network order (big endian) to little endian
5897 */
5898 rar_low = ((uint32_t) addr[0] |
5899 ((uint32_t) addr[1] << 8) |
5900 ((uint32_t) addr[2] << 16) | ((uint32_t) addr[3] << 24));
5901 rar_high = ((uint32_t) addr[4] | ((uint32_t) addr[5] << 8));
5902
5903 /* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx
5904 * unit hang.
5905 *
5906 * Description:
5907 * If there are any Rx frames queued up or otherwise present in the HW
5908 * before RSS is enabled, and then we enable RSS, the HW Rx unit will
5909 * hang. To work around this issue, we have to disable receives and
5910 * flush out all Rx frames before we enable RSS. To do so, we modify we
5911 * redirect all Rx traffic to manageability and then reset the HW.
5912 * This flushes away Rx frames, and (since the redirections to
5913 * manageability persists across resets) keeps new ones from coming in
5914 * while we work. Then, we clear the Address Valid AV bit for all MAC
5915 * addresses and undo the re-direction to manageability.
5916 * Now, frames are coming in again, but the MAC won't accept them, so
5917 * far so good. We now proceed to initialize RSS (if necessary) and
5918 * configure the Rx unit. Last, we re-enable the AV bits and continue
5919 * on our merry way.
5920 */
5921 switch (hw->mac_type) {
5922 case e1000_82571:
5923 case e1000_82572:
5924 case e1000_80003es2lan:
5925 if (hw->leave_av_bit_off == TRUE)
5926 break;
5927 default:
5928 /* Indicate to hardware the Address is Valid. */
5929 rar_high |= E1000_RAH_AV;
5930 break;
5931 }
5932
5933 E1000_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
5934 E1000_WRITE_FLUSH(hw);
5935 E1000_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
5936 E1000_WRITE_FLUSH(hw);
5937 }
5938
5939 /******************************************************************************
5940 * Writes a value to the specified offset in the VLAN filter table.
5941 *
5942 * hw - Struct containing variables accessed by shared code
5943 * offset - Offset in VLAN filer table to write
5944 * value - Value to write into VLAN filter table
5945 *****************************************************************************/
5946 void
5947 e1000_write_vfta(struct e1000_hw *hw,
5948 uint32_t offset,
5949 uint32_t value)
5950 {
5951 uint32_t temp;
5952
5953 if (hw->mac_type == e1000_ich8lan)
5954 return;
5955
5956 if ((hw->mac_type == e1000_82544) && ((offset & 0x1) == 1)) {
5957 temp = E1000_READ_REG_ARRAY(hw, VFTA, (offset - 1));
5958 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
5959 E1000_WRITE_FLUSH(hw);
5960 E1000_WRITE_REG_ARRAY(hw, VFTA, (offset - 1), temp);
5961 E1000_WRITE_FLUSH(hw);
5962 } else {
5963 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
5964 E1000_WRITE_FLUSH(hw);
5965 }
5966 }
5967
5968 /******************************************************************************
5969 * Clears the VLAN filer table
5970 *
5971 * hw - Struct containing variables accessed by shared code
5972 *****************************************************************************/
5973 static void
5974 e1000_clear_vfta(struct e1000_hw *hw)
5975 {
5976 uint32_t offset;
5977 uint32_t vfta_value = 0;
5978 uint32_t vfta_offset = 0;
5979 uint32_t vfta_bit_in_reg = 0;
5980
5981 if (hw->mac_type == e1000_ich8lan)
5982 return;
5983
5984 if (hw->mac_type == e1000_82573) {
5985 if (hw->mng_cookie.vlan_id != 0) {
5986 /* The VFTA is a 4096b bit-field, each identifying a single VLAN
5987 * ID. The following operations determine which 32b entry
5988 * (i.e. offset) into the array we want to set the VLAN ID
5989 * (i.e. bit) of the manageability unit. */
5990 vfta_offset = (hw->mng_cookie.vlan_id >>
5991 E1000_VFTA_ENTRY_SHIFT) &
5992 E1000_VFTA_ENTRY_MASK;
5993 vfta_bit_in_reg = 1 << (hw->mng_cookie.vlan_id &
5994 E1000_VFTA_ENTRY_BIT_SHIFT_MASK);
5995 }
5996 }
5997 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
5998 /* If the offset we want to clear is the same offset of the
5999 * manageability VLAN ID, then clear all bits except that of the
6000 * manageability unit */
6001 vfta_value = (offset == vfta_offset) ? vfta_bit_in_reg : 0;
6002 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, vfta_value);
6003 E1000_WRITE_FLUSH(hw);
6004 }
6005 }
6006
6007 static int32_t
6008 e1000_id_led_init(struct e1000_hw * hw)
6009 {
6010 uint32_t ledctl;
6011 const uint32_t ledctl_mask = 0x000000FF;
6012 const uint32_t ledctl_on = E1000_LEDCTL_MODE_LED_ON;
6013 const uint32_t ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
6014 uint16_t eeprom_data, i, temp;
6015 const uint16_t led_mask = 0x0F;
6016
6017 DEBUGFUNC("e1000_id_led_init");
6018
6019 if (hw->mac_type < e1000_82540) {
6020 /* Nothing to do */
6021 return E1000_SUCCESS;
6022 }
6023
6024 ledctl = E1000_READ_REG(hw, LEDCTL);
6025 hw->ledctl_default = ledctl;
6026 hw->ledctl_mode1 = hw->ledctl_default;
6027 hw->ledctl_mode2 = hw->ledctl_default;
6028
6029 if (e1000_read_eeprom(hw, EEPROM_ID_LED_SETTINGS, 1, &eeprom_data) < 0) {
6030 DEBUGOUT("EEPROM Read Error\n");
6031 return -E1000_ERR_EEPROM;
6032 }
6033
6034 if ((hw->mac_type == e1000_82573) &&
6035 (eeprom_data == ID_LED_RESERVED_82573))
6036 eeprom_data = ID_LED_DEFAULT_82573;
6037 else if ((eeprom_data == ID_LED_RESERVED_0000) ||
6038 (eeprom_data == ID_LED_RESERVED_FFFF)) {
6039 if (hw->mac_type == e1000_ich8lan)
6040 eeprom_data = ID_LED_DEFAULT_ICH8LAN;
6041 else
6042 eeprom_data = ID_LED_DEFAULT;
6043 }
6044
6045 for (i = 0; i < 4; i++) {
6046 temp = (eeprom_data >> (i << 2)) & led_mask;
6047 switch (temp) {
6048 case ID_LED_ON1_DEF2:
6049 case ID_LED_ON1_ON2:
6050 case ID_LED_ON1_OFF2:
6051 hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
6052 hw->ledctl_mode1 |= ledctl_on << (i << 3);
6053 break;
6054 case ID_LED_OFF1_DEF2:
6055 case ID_LED_OFF1_ON2:
6056 case ID_LED_OFF1_OFF2:
6057 hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
6058 hw->ledctl_mode1 |= ledctl_off << (i << 3);
6059 break;
6060 default:
6061 /* Do nothing */
6062 break;
6063 }
6064 switch (temp) {
6065 case ID_LED_DEF1_ON2:
6066 case ID_LED_ON1_ON2:
6067 case ID_LED_OFF1_ON2:
6068 hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
6069 hw->ledctl_mode2 |= ledctl_on << (i << 3);
6070 break;
6071 case ID_LED_DEF1_OFF2:
6072 case ID_LED_ON1_OFF2:
6073 case ID_LED_OFF1_OFF2:
6074 hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
6075 hw->ledctl_mode2 |= ledctl_off << (i << 3);
6076 break;
6077 default:
6078 /* Do nothing */
6079 break;
6080 }
6081 }
6082 return E1000_SUCCESS;
6083 }
6084
6085 /******************************************************************************
6086 * Prepares SW controlable LED for use and saves the current state of the LED.
6087 *
6088 * hw - Struct containing variables accessed by shared code
6089 *****************************************************************************/
6090 int32_t
6091 e1000_setup_led(struct e1000_hw *hw)
6092 {
6093 uint32_t ledctl;
6094 int32_t ret_val = E1000_SUCCESS;
6095
6096 DEBUGFUNC("e1000_setup_led");
6097
6098 switch (hw->mac_type) {
6099 case e1000_82542_rev2_0:
6100 case e1000_82542_rev2_1:
6101 case e1000_82543:
6102 case e1000_82544:
6103 /* No setup necessary */
6104 break;
6105 case e1000_82541:
6106 case e1000_82547:
6107 case e1000_82541_rev_2:
6108 case e1000_82547_rev_2:
6109 /* Turn off PHY Smart Power Down (if enabled) */
6110 ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO,
6111 &hw->phy_spd_default);
6112 if (ret_val)
6113 return ret_val;
6114 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
6115 (uint16_t)(hw->phy_spd_default &
6116 ~IGP01E1000_GMII_SPD));
6117 if (ret_val)
6118 return ret_val;
6119 /* Fall Through */
6120 default:
6121 if (hw->media_type == e1000_media_type_fiber) {
6122 ledctl = E1000_READ_REG(hw, LEDCTL);
6123 /* Save current LEDCTL settings */
6124 hw->ledctl_default = ledctl;
6125 /* Turn off LED0 */
6126 ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
6127 E1000_LEDCTL_LED0_BLINK |
6128 E1000_LEDCTL_LED0_MODE_MASK);
6129 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
6130 E1000_LEDCTL_LED0_MODE_SHIFT);
6131 E1000_WRITE_REG(hw, LEDCTL, ledctl);
6132 } else if (hw->media_type == e1000_media_type_copper)
6133 E1000_WRITE_REG(hw, LEDCTL, hw->ledctl_mode1);
6134 break;
6135 }
6136
6137 return E1000_SUCCESS;
6138 }
6139
6140
6141 /******************************************************************************
6142 * Used on 82571 and later Si that has LED blink bits.
6143 * Callers must use their own timer and should have already called
6144 * e1000_id_led_init()
6145 * Call e1000_cleanup led() to stop blinking
6146 *
6147 * hw - Struct containing variables accessed by shared code
6148 *****************************************************************************/
6149 int32_t
6150 e1000_blink_led_start(struct e1000_hw *hw)
6151 {
6152 int16_t i;
6153 uint32_t ledctl_blink = 0;
6154
6155 DEBUGFUNC("e1000_id_led_blink_on");
6156
6157 if (hw->mac_type < e1000_82571) {
6158 /* Nothing to do */
6159 return E1000_SUCCESS;
6160 }
6161 if (hw->media_type == e1000_media_type_fiber) {
6162 /* always blink LED0 for PCI-E fiber */
6163 ledctl_blink = E1000_LEDCTL_LED0_BLINK |
6164 (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
6165 } else {
6166 /* set the blink bit for each LED that's "on" (0x0E) in ledctl_mode2 */
6167 ledctl_blink = hw->ledctl_mode2;
6168 for (i=0; i < 4; i++)
6169 if (((hw->ledctl_mode2 >> (i * 8)) & 0xFF) ==
6170 E1000_LEDCTL_MODE_LED_ON)
6171 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK << (i * 8));
6172 }
6173
6174 E1000_WRITE_REG(hw, LEDCTL, ledctl_blink);
6175
6176 return E1000_SUCCESS;
6177 }
6178
6179 /******************************************************************************
6180 * Restores the saved state of the SW controlable LED.
6181 *
6182 * hw - Struct containing variables accessed by shared code
6183 *****************************************************************************/
6184 int32_t
6185 e1000_cleanup_led(struct e1000_hw *hw)
6186 {
6187 int32_t ret_val = E1000_SUCCESS;
6188
6189 DEBUGFUNC("e1000_cleanup_led");
6190
6191 switch (hw->mac_type) {
6192 case e1000_82542_rev2_0:
6193 case e1000_82542_rev2_1:
6194 case e1000_82543:
6195 case e1000_82544:
6196 /* No cleanup necessary */
6197 break;
6198 case e1000_82541:
6199 case e1000_82547:
6200 case e1000_82541_rev_2:
6201 case e1000_82547_rev_2:
6202 /* Turn on PHY Smart Power Down (if previously enabled) */
6203 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
6204 hw->phy_spd_default);
6205 if (ret_val)
6206 return ret_val;
6207 /* Fall Through */
6208 default:
6209 if (hw->phy_type == e1000_phy_ife) {
6210 e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
6211 break;
6212 }
6213 /* Restore LEDCTL settings */
6214 E1000_WRITE_REG(hw, LEDCTL, hw->ledctl_default);
6215 break;
6216 }
6217
6218 return E1000_SUCCESS;
6219 }
6220
6221 /******************************************************************************
6222 * Turns on the software controllable LED
6223 *
6224 * hw - Struct containing variables accessed by shared code
6225 *****************************************************************************/
6226 int32_t
6227 e1000_led_on(struct e1000_hw *hw)
6228 {
6229 uint32_t ctrl = E1000_READ_REG(hw, CTRL);
6230
6231 DEBUGFUNC("e1000_led_on");
6232
6233 switch (hw->mac_type) {
6234 case e1000_82542_rev2_0:
6235 case e1000_82542_rev2_1:
6236 case e1000_82543:
6237 /* Set SW Defineable Pin 0 to turn on the LED */
6238 ctrl |= E1000_CTRL_SWDPIN0;
6239 ctrl |= E1000_CTRL_SWDPIO0;
6240 break;
6241 case e1000_82544:
6242 if (hw->media_type == e1000_media_type_fiber) {
6243 /* Set SW Defineable Pin 0 to turn on the LED */
6244 ctrl |= E1000_CTRL_SWDPIN0;
6245 ctrl |= E1000_CTRL_SWDPIO0;
6246 } else {
6247 /* Clear SW Defineable Pin 0 to turn on the LED */
6248 ctrl &= ~E1000_CTRL_SWDPIN0;
6249 ctrl |= E1000_CTRL_SWDPIO0;
6250 }
6251 break;
6252 default:
6253 if (hw->media_type == e1000_media_type_fiber) {
6254 /* Clear SW Defineable Pin 0 to turn on the LED */
6255 ctrl &= ~E1000_CTRL_SWDPIN0;
6256 ctrl |= E1000_CTRL_SWDPIO0;
6257 } else if (hw->phy_type == e1000_phy_ife) {
6258 e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED,
6259 (IFE_PSCL_PROBE_MODE | IFE_PSCL_PROBE_LEDS_ON));
6260 } else if (hw->media_type == e1000_media_type_copper) {
6261 E1000_WRITE_REG(hw, LEDCTL, hw->ledctl_mode2);
6262 return E1000_SUCCESS;
6263 }
6264 break;
6265 }
6266
6267 E1000_WRITE_REG(hw, CTRL, ctrl);
6268
6269 return E1000_SUCCESS;
6270 }
6271
6272 /******************************************************************************
6273 * Turns off the software controllable LED
6274 *
6275 * hw - Struct containing variables accessed by shared code
6276 *****************************************************************************/
6277 int32_t
6278 e1000_led_off(struct e1000_hw *hw)
6279 {
6280 uint32_t ctrl = E1000_READ_REG(hw, CTRL);
6281
6282 DEBUGFUNC("e1000_led_off");
6283
6284 switch (hw->mac_type) {
6285 case e1000_82542_rev2_0:
6286 case e1000_82542_rev2_1:
6287 case e1000_82543:
6288 /* Clear SW Defineable Pin 0 to turn off the LED */
6289 ctrl &= ~E1000_CTRL_SWDPIN0;
6290 ctrl |= E1000_CTRL_SWDPIO0;
6291 break;
6292 case e1000_82544:
6293 if (hw->media_type == e1000_media_type_fiber) {
6294 /* Clear SW Defineable Pin 0 to turn off the LED */
6295 ctrl &= ~E1000_CTRL_SWDPIN0;
6296 ctrl |= E1000_CTRL_SWDPIO0;
6297 } else {
6298 /* Set SW Defineable Pin 0 to turn off the LED */
6299 ctrl |= E1000_CTRL_SWDPIN0;
6300 ctrl |= E1000_CTRL_SWDPIO0;
6301 }
6302 break;
6303 default:
6304 if (hw->media_type == e1000_media_type_fiber) {
6305 /* Set SW Defineable Pin 0 to turn off the LED */
6306 ctrl |= E1000_CTRL_SWDPIN0;
6307 ctrl |= E1000_CTRL_SWDPIO0;
6308 } else if (hw->phy_type == e1000_phy_ife) {
6309 e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED,
6310 (IFE_PSCL_PROBE_MODE | IFE_PSCL_PROBE_LEDS_OFF));
6311 } else if (hw->media_type == e1000_media_type_copper) {
6312 E1000_WRITE_REG(hw, LEDCTL, hw->ledctl_mode1);
6313 return E1000_SUCCESS;
6314 }
6315 break;
6316 }
6317
6318 E1000_WRITE_REG(hw, CTRL, ctrl);
6319
6320 return E1000_SUCCESS;
6321 }
6322
6323 /******************************************************************************
6324 * Clears all hardware statistics counters.
6325 *
6326 * hw - Struct containing variables accessed by shared code
6327 *****************************************************************************/
6328 static void
6329 e1000_clear_hw_cntrs(struct e1000_hw *hw)
6330 {
6331 volatile uint32_t temp;
6332
6333 temp = E1000_READ_REG(hw, CRCERRS);
6334 temp = E1000_READ_REG(hw, SYMERRS);
6335 temp = E1000_READ_REG(hw, MPC);
6336 temp = E1000_READ_REG(hw, SCC);
6337 temp = E1000_READ_REG(hw, ECOL);
6338 temp = E1000_READ_REG(hw, MCC);
6339 temp = E1000_READ_REG(hw, LATECOL);
6340 temp = E1000_READ_REG(hw, COLC);
6341 temp = E1000_READ_REG(hw, DC);
6342 temp = E1000_READ_REG(hw, SEC);
6343 temp = E1000_READ_REG(hw, RLEC);
6344 temp = E1000_READ_REG(hw, XONRXC);
6345 temp = E1000_READ_REG(hw, XONTXC);
6346 temp = E1000_READ_REG(hw, XOFFRXC);
6347 temp = E1000_READ_REG(hw, XOFFTXC);
6348 temp = E1000_READ_REG(hw, FCRUC);
6349
6350 if (hw->mac_type != e1000_ich8lan) {
6351 temp = E1000_READ_REG(hw, PRC64);
6352 temp = E1000_READ_REG(hw, PRC127);
6353 temp = E1000_READ_REG(hw, PRC255);
6354 temp = E1000_READ_REG(hw, PRC511);
6355 temp = E1000_READ_REG(hw, PRC1023);
6356 temp = E1000_READ_REG(hw, PRC1522);
6357 }
6358
6359 temp = E1000_READ_REG(hw, GPRC);
6360 temp = E1000_READ_REG(hw, BPRC);
6361 temp = E1000_READ_REG(hw, MPRC);
6362 temp = E1000_READ_REG(hw, GPTC);
6363 temp = E1000_READ_REG(hw, GORCL);
6364 temp = E1000_READ_REG(hw, GORCH);
6365 temp = E1000_READ_REG(hw, GOTCL);
6366 temp = E1000_READ_REG(hw, GOTCH);
6367 temp = E1000_READ_REG(hw, RNBC);
6368 temp = E1000_READ_REG(hw, RUC);
6369 temp = E1000_READ_REG(hw, RFC);
6370 temp = E1000_READ_REG(hw, ROC);
6371 temp = E1000_READ_REG(hw, RJC);
6372 temp = E1000_READ_REG(hw, TORL);
6373 temp = E1000_READ_REG(hw, TORH);
6374 temp = E1000_READ_REG(hw, TOTL);
6375 temp = E1000_READ_REG(hw, TOTH);
6376 temp = E1000_READ_REG(hw, TPR);
6377 temp = E1000_READ_REG(hw, TPT);
6378
6379 if (hw->mac_type != e1000_ich8lan) {
6380 temp = E1000_READ_REG(hw, PTC64);
6381 temp = E1000_READ_REG(hw, PTC127);
6382 temp = E1000_READ_REG(hw, PTC255);
6383 temp = E1000_READ_REG(hw, PTC511);
6384 temp = E1000_READ_REG(hw, PTC1023);
6385 temp = E1000_READ_REG(hw, PTC1522);
6386 }
6387
6388 temp = E1000_READ_REG(hw, MPTC);
6389 temp = E1000_READ_REG(hw, BPTC);
6390
6391 if (hw->mac_type < e1000_82543) return;
6392
6393 temp = E1000_READ_REG(hw, ALGNERRC);
6394 temp = E1000_READ_REG(hw, RXERRC);
6395 temp = E1000_READ_REG(hw, TNCRS);
6396 temp = E1000_READ_REG(hw, CEXTERR);
6397 temp = E1000_READ_REG(hw, TSCTC);
6398 temp = E1000_READ_REG(hw, TSCTFC);
6399
6400 if (hw->mac_type <= e1000_82544) return;
6401
6402 temp = E1000_READ_REG(hw, MGTPRC);
6403 temp = E1000_READ_REG(hw, MGTPDC);
6404 temp = E1000_READ_REG(hw, MGTPTC);
6405
6406 if (hw->mac_type <= e1000_82547_rev_2) return;
6407
6408 temp = E1000_READ_REG(hw, IAC);
6409 temp = E1000_READ_REG(hw, ICRXOC);
6410
6411 if (hw->mac_type == e1000_ich8lan) return;
6412
6413 temp = E1000_READ_REG(hw, ICRXPTC);
6414 temp = E1000_READ_REG(hw, ICRXATC);
6415 temp = E1000_READ_REG(hw, ICTXPTC);
6416 temp = E1000_READ_REG(hw, ICTXATC);
6417 temp = E1000_READ_REG(hw, ICTXQEC);
6418 temp = E1000_READ_REG(hw, ICTXQMTC);
6419 temp = E1000_READ_REG(hw, ICRXDMTC);
6420 }
6421
6422 /******************************************************************************
6423 * Resets Adaptive IFS to its default state.
6424 *
6425 * hw - Struct containing variables accessed by shared code
6426 *
6427 * Call this after e1000_init_hw. You may override the IFS defaults by setting
6428 * hw->ifs_params_forced to TRUE. However, you must initialize hw->
6429 * current_ifs_val, ifs_min_val, ifs_max_val, ifs_step_size, and ifs_ratio
6430 * before calling this function.
6431 *****************************************************************************/
6432 void
6433 e1000_reset_adaptive(struct e1000_hw *hw)
6434 {
6435 DEBUGFUNC("e1000_reset_adaptive");
6436
6437 if (hw->adaptive_ifs) {
6438 if (!hw->ifs_params_forced) {
6439 hw->current_ifs_val = 0;
6440 hw->ifs_min_val = IFS_MIN;
6441 hw->ifs_max_val = IFS_MAX;
6442 hw->ifs_step_size = IFS_STEP;
6443 hw->ifs_ratio = IFS_RATIO;
6444 }
6445 hw->in_ifs_mode = FALSE;
6446 E1000_WRITE_REG(hw, AIT, 0);
6447 } else {
6448 DEBUGOUT("Not in Adaptive IFS mode!\n");
6449 }
6450 }
6451
6452 /******************************************************************************
6453 * Called during the callback/watchdog routine to update IFS value based on
6454 * the ratio of transmits to collisions.
6455 *
6456 * hw - Struct containing variables accessed by shared code
6457 * tx_packets - Number of transmits since last callback
6458 * total_collisions - Number of collisions since last callback
6459 *****************************************************************************/
6460 void
6461 e1000_update_adaptive(struct e1000_hw *hw)
6462 {
6463 DEBUGFUNC("e1000_update_adaptive");
6464
6465 if (hw->adaptive_ifs) {
6466 if ((hw->collision_delta * hw->ifs_ratio) > hw->tx_packet_delta) {
6467 if (hw->tx_packet_delta > MIN_NUM_XMITS) {
6468 hw->in_ifs_mode = TRUE;
6469 if (hw->current_ifs_val < hw->ifs_max_val) {
6470 if (hw->current_ifs_val == 0)
6471 hw->current_ifs_val = hw->ifs_min_val;
6472 else
6473 hw->current_ifs_val += hw->ifs_step_size;
6474 E1000_WRITE_REG(hw, AIT, hw->current_ifs_val);
6475 }
6476 }
6477 } else {
6478 if (hw->in_ifs_mode && (hw->tx_packet_delta <= MIN_NUM_XMITS)) {
6479 hw->current_ifs_val = 0;
6480 hw->in_ifs_mode = FALSE;
6481 E1000_WRITE_REG(hw, AIT, 0);
6482 }
6483 }
6484 } else {
6485 DEBUGOUT("Not in Adaptive IFS mode!\n");
6486 }
6487 }
6488
6489 /******************************************************************************
6490 * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
6491 *
6492 * hw - Struct containing variables accessed by shared code
6493 * frame_len - The length of the frame in question
6494 * mac_addr - The Ethernet destination address of the frame in question
6495 *****************************************************************************/
6496 void
6497 e1000_tbi_adjust_stats(struct e1000_hw *hw,
6498 struct e1000_hw_stats *stats,
6499 uint32_t frame_len,
6500 uint8_t *mac_addr)
6501 {
6502 uint64_t carry_bit;
6503
6504 /* First adjust the frame length. */
6505 frame_len--;
6506 /* We need to adjust the statistics counters, since the hardware
6507 * counters overcount this packet as a CRC error and undercount
6508 * the packet as a good packet
6509 */
6510 /* This packet should not be counted as a CRC error. */
6511 stats->crcerrs--;
6512 /* This packet does count as a Good Packet Received. */
6513 stats->gprc++;
6514
6515 /* Adjust the Good Octets received counters */
6516 carry_bit = 0x80000000 & stats->gorcl;
6517 stats->gorcl += frame_len;
6518 /* If the high bit of Gorcl (the low 32 bits of the Good Octets
6519 * Received Count) was one before the addition,
6520 * AND it is zero after, then we lost the carry out,
6521 * need to add one to Gorch (Good Octets Received Count High).
6522 * This could be simplified if all environments supported
6523 * 64-bit integers.
6524 */
6525 if (carry_bit && ((stats->gorcl & 0x80000000) == 0))
6526 stats->gorch++;
6527 /* Is this a broadcast or multicast? Check broadcast first,
6528 * since the test for a multicast frame will test positive on
6529 * a broadcast frame.
6530 */
6531 if ((mac_addr[0] == (uint8_t) 0xff) && (mac_addr[1] == (uint8_t) 0xff))
6532 /* Broadcast packet */
6533 stats->bprc++;
6534 else if (*mac_addr & 0x01)
6535 /* Multicast packet */
6536 stats->mprc++;
6537
6538 if (frame_len == hw->max_frame_size) {
6539 /* In this case, the hardware has overcounted the number of
6540 * oversize frames.
6541 */
6542 if (stats->roc > 0)
6543 stats->roc--;
6544 }
6545
6546 /* Adjust the bin counters when the extra byte put the frame in the
6547 * wrong bin. Remember that the frame_len was adjusted above.
6548 */
6549 if (frame_len == 64) {
6550 stats->prc64++;
6551 stats->prc127--;
6552 } else if (frame_len == 127) {
6553 stats->prc127++;
6554 stats->prc255--;
6555 } else if (frame_len == 255) {
6556 stats->prc255++;
6557 stats->prc511--;
6558 } else if (frame_len == 511) {
6559 stats->prc511++;
6560 stats->prc1023--;
6561 } else if (frame_len == 1023) {
6562 stats->prc1023++;
6563 stats->prc1522--;
6564 } else if (frame_len == 1522) {
6565 stats->prc1522++;
6566 }
6567 }
6568
6569 /******************************************************************************
6570 * Gets the current PCI bus type, speed, and width of the hardware
6571 *
6572 * hw - Struct containing variables accessed by shared code
6573 *****************************************************************************/
6574 void
6575 e1000_get_bus_info(struct e1000_hw *hw)
6576 {
6577 int32_t ret_val;
6578 uint16_t pci_ex_link_status;
6579 uint32_t status;
6580
6581 switch (hw->mac_type) {
6582 case e1000_82542_rev2_0:
6583 case e1000_82542_rev2_1:
6584 hw->bus_type = e1000_bus_type_pci;
6585 hw->bus_speed = e1000_bus_speed_unknown;
6586 hw->bus_width = e1000_bus_width_unknown;
6587 break;
6588 case e1000_82571:
6589 case e1000_82572:
6590 case e1000_82573:
6591 case e1000_80003es2lan:
6592 hw->bus_type = e1000_bus_type_pci_express;
6593 hw->bus_speed = e1000_bus_speed_2500;
6594 ret_val = e1000_read_pcie_cap_reg(hw,
6595 PCI_EX_LINK_STATUS,
6596 &pci_ex_link_status);
6597 if (ret_val)
6598 hw->bus_width = e1000_bus_width_unknown;
6599 else
6600 hw->bus_width = (pci_ex_link_status & PCI_EX_LINK_WIDTH_MASK) >>
6601 PCI_EX_LINK_WIDTH_SHIFT;
6602 break;
6603 case e1000_ich8lan:
6604 hw->bus_type = e1000_bus_type_pci_express;
6605 hw->bus_speed = e1000_bus_speed_2500;
6606 hw->bus_width = e1000_bus_width_pciex_1;
6607 break;
6608 default:
6609 status = E1000_READ_REG(hw, STATUS);
6610 hw->bus_type = (status & E1000_STATUS_PCIX_MODE) ?
6611 e1000_bus_type_pcix : e1000_bus_type_pci;
6612
6613 if (hw->device_id == E1000_DEV_ID_82546EB_QUAD_COPPER) {
6614 hw->bus_speed = (hw->bus_type == e1000_bus_type_pci) ?
6615 e1000_bus_speed_66 : e1000_bus_speed_120;
6616 } else if (hw->bus_type == e1000_bus_type_pci) {
6617 hw->bus_speed = (status & E1000_STATUS_PCI66) ?
6618 e1000_bus_speed_66 : e1000_bus_speed_33;
6619 } else {
6620 switch (status & E1000_STATUS_PCIX_SPEED) {
6621 case E1000_STATUS_PCIX_SPEED_66:
6622 hw->bus_speed = e1000_bus_speed_66;
6623 break;
6624 case E1000_STATUS_PCIX_SPEED_100:
6625 hw->bus_speed = e1000_bus_speed_100;
6626 break;
6627 case E1000_STATUS_PCIX_SPEED_133:
6628 hw->bus_speed = e1000_bus_speed_133;
6629 break;
6630 default:
6631 hw->bus_speed = e1000_bus_speed_reserved;
6632 break;
6633 }
6634 }
6635 hw->bus_width = (status & E1000_STATUS_BUS64) ?
6636 e1000_bus_width_64 : e1000_bus_width_32;
6637 break;
6638 }
6639 }
6640
6641 /******************************************************************************
6642 * Writes a value to one of the devices registers using port I/O (as opposed to
6643 * memory mapped I/O). Only 82544 and newer devices support port I/O.
6644 *
6645 * hw - Struct containing variables accessed by shared code
6646 * offset - offset to write to
6647 * value - value to write
6648 *****************************************************************************/
6649 static void
6650 e1000_write_reg_io(struct e1000_hw *hw,
6651 uint32_t offset,
6652 uint32_t value)
6653 {
6654 unsigned long io_addr = hw->io_base;
6655 unsigned long io_data = hw->io_base + 4;
6656
6657 e1000_io_write(hw, io_addr, offset);
6658 e1000_io_write(hw, io_data, value);
6659 }
6660
6661 /******************************************************************************
6662 * Estimates the cable length.
6663 *
6664 * hw - Struct containing variables accessed by shared code
6665 * min_length - The estimated minimum length
6666 * max_length - The estimated maximum length
6667 *
6668 * returns: - E1000_ERR_XXX
6669 * E1000_SUCCESS
6670 *
6671 * This function always returns a ranged length (minimum & maximum).
6672 * So for M88 phy's, this function interprets the one value returned from the
6673 * register to the minimum and maximum range.
6674 * For IGP phy's, the function calculates the range by the AGC registers.
6675 *****************************************************************************/
6676 static int32_t
6677 e1000_get_cable_length(struct e1000_hw *hw,
6678 uint16_t *min_length,
6679 uint16_t *max_length)
6680 {
6681 int32_t ret_val;
6682 uint16_t agc_value = 0;
6683 uint16_t i, phy_data;
6684 uint16_t cable_length;
6685
6686 DEBUGFUNC("e1000_get_cable_length");
6687
6688 *min_length = *max_length = 0;
6689
6690 /* Use old method for Phy older than IGP */
6691 if (hw->phy_type == e1000_phy_m88) {
6692
6693 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6694 &phy_data);
6695 if (ret_val)
6696 return ret_val;
6697 cable_length = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
6698 M88E1000_PSSR_CABLE_LENGTH_SHIFT;
6699
6700 /* Convert the enum value to ranged values */
6701 switch (cable_length) {
6702 case e1000_cable_length_50:
6703 *min_length = 0;
6704 *max_length = e1000_igp_cable_length_50;
6705 break;
6706 case e1000_cable_length_50_80:
6707 *min_length = e1000_igp_cable_length_50;
6708 *max_length = e1000_igp_cable_length_80;
6709 break;
6710 case e1000_cable_length_80_110:
6711 *min_length = e1000_igp_cable_length_80;
6712 *max_length = e1000_igp_cable_length_110;
6713 break;
6714 case e1000_cable_length_110_140:
6715 *min_length = e1000_igp_cable_length_110;
6716 *max_length = e1000_igp_cable_length_140;
6717 break;
6718 case e1000_cable_length_140:
6719 *min_length = e1000_igp_cable_length_140;
6720 *max_length = e1000_igp_cable_length_170;
6721 break;
6722 default:
6723 return -E1000_ERR_PHY;
6724 break;
6725 }
6726 } else if (hw->phy_type == e1000_phy_gg82563) {
6727 ret_val = e1000_read_phy_reg(hw, GG82563_PHY_DSP_DISTANCE,
6728 &phy_data);
6729 if (ret_val)
6730 return ret_val;
6731 cable_length = phy_data & GG82563_DSPD_CABLE_LENGTH;
6732
6733 switch (cable_length) {
6734 case e1000_gg_cable_length_60:
6735 *min_length = 0;
6736 *max_length = e1000_igp_cable_length_60;
6737 break;
6738 case e1000_gg_cable_length_60_115:
6739 *min_length = e1000_igp_cable_length_60;
6740 *max_length = e1000_igp_cable_length_115;
6741 break;
6742 case e1000_gg_cable_length_115_150:
6743 *min_length = e1000_igp_cable_length_115;
6744 *max_length = e1000_igp_cable_length_150;
6745 break;
6746 case e1000_gg_cable_length_150:
6747 *min_length = e1000_igp_cable_length_150;
6748 *max_length = e1000_igp_cable_length_180;
6749 break;
6750 default:
6751 return -E1000_ERR_PHY;
6752 break;
6753 }
6754 } else if (hw->phy_type == e1000_phy_igp) { /* For IGP PHY */
6755 uint16_t cur_agc_value;
6756 uint16_t min_agc_value = IGP01E1000_AGC_LENGTH_TABLE_SIZE;
6757 uint16_t agc_reg_array[IGP01E1000_PHY_CHANNEL_NUM] =
6758 {IGP01E1000_PHY_AGC_A,
6759 IGP01E1000_PHY_AGC_B,
6760 IGP01E1000_PHY_AGC_C,
6761 IGP01E1000_PHY_AGC_D};
6762 /* Read the AGC registers for all channels */
6763 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
6764
6765 ret_val = e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
6766 if (ret_val)
6767 return ret_val;
6768
6769 cur_agc_value = phy_data >> IGP01E1000_AGC_LENGTH_SHIFT;
6770
6771 /* Value bound check. */
6772 if ((cur_agc_value >= IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1) ||
6773 (cur_agc_value == 0))
6774 return -E1000_ERR_PHY;
6775
6776 agc_value += cur_agc_value;
6777
6778 /* Update minimal AGC value. */
6779 if (min_agc_value > cur_agc_value)
6780 min_agc_value = cur_agc_value;
6781 }
6782
6783 /* Remove the minimal AGC result for length < 50m */
6784 if (agc_value < IGP01E1000_PHY_CHANNEL_NUM * e1000_igp_cable_length_50) {
6785 agc_value -= min_agc_value;
6786
6787 /* Get the average length of the remaining 3 channels */
6788 agc_value /= (IGP01E1000_PHY_CHANNEL_NUM - 1);
6789 } else {
6790 /* Get the average length of all the 4 channels. */
6791 agc_value /= IGP01E1000_PHY_CHANNEL_NUM;
6792 }
6793
6794 /* Set the range of the calculated length. */
6795 *min_length = ((e1000_igp_cable_length_table[agc_value] -
6796 IGP01E1000_AGC_RANGE) > 0) ?
6797 (e1000_igp_cable_length_table[agc_value] -
6798 IGP01E1000_AGC_RANGE) : 0;
6799 *max_length = e1000_igp_cable_length_table[agc_value] +
6800 IGP01E1000_AGC_RANGE;
6801 } else if (hw->phy_type == e1000_phy_igp_2 ||
6802 hw->phy_type == e1000_phy_igp_3) {
6803 uint16_t cur_agc_index, max_agc_index = 0;
6804 uint16_t min_agc_index = IGP02E1000_AGC_LENGTH_TABLE_SIZE - 1;
6805 uint16_t agc_reg_array[IGP02E1000_PHY_CHANNEL_NUM] =
6806 {IGP02E1000_PHY_AGC_A,
6807 IGP02E1000_PHY_AGC_B,
6808 IGP02E1000_PHY_AGC_C,
6809 IGP02E1000_PHY_AGC_D};
6810 /* Read the AGC registers for all channels */
6811 for (i = 0; i < IGP02E1000_PHY_CHANNEL_NUM; i++) {
6812 ret_val = e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
6813 if (ret_val)
6814 return ret_val;
6815
6816 /* Getting bits 15:9, which represent the combination of course and
6817 * fine gain values. The result is a number that can be put into
6818 * the lookup table to obtain the approximate cable length. */
6819 cur_agc_index = (phy_data >> IGP02E1000_AGC_LENGTH_SHIFT) &
6820 IGP02E1000_AGC_LENGTH_MASK;
6821
6822 /* Array index bound check. */
6823 if ((cur_agc_index >= IGP02E1000_AGC_LENGTH_TABLE_SIZE) ||
6824 (cur_agc_index == 0))
6825 return -E1000_ERR_PHY;
6826
6827 /* Remove min & max AGC values from calculation. */
6828 if (e1000_igp_2_cable_length_table[min_agc_index] >
6829 e1000_igp_2_cable_length_table[cur_agc_index])
6830 min_agc_index = cur_agc_index;
6831 if (e1000_igp_2_cable_length_table[max_agc_index] <
6832 e1000_igp_2_cable_length_table[cur_agc_index])
6833 max_agc_index = cur_agc_index;
6834
6835 agc_value += e1000_igp_2_cable_length_table[cur_agc_index];
6836 }
6837
6838 agc_value -= (e1000_igp_2_cable_length_table[min_agc_index] +
6839 e1000_igp_2_cable_length_table[max_agc_index]);
6840 agc_value /= (IGP02E1000_PHY_CHANNEL_NUM - 2);
6841
6842 /* Calculate cable length with the error range of +/- 10 meters. */
6843 *min_length = ((agc_value - IGP02E1000_AGC_RANGE) > 0) ?
6844 (agc_value - IGP02E1000_AGC_RANGE) : 0;
6845 *max_length = agc_value + IGP02E1000_AGC_RANGE;
6846 }
6847
6848 return E1000_SUCCESS;
6849 }
6850
6851 /******************************************************************************
6852 * Check the cable polarity
6853 *
6854 * hw - Struct containing variables accessed by shared code
6855 * polarity - output parameter : 0 - Polarity is not reversed
6856 * 1 - Polarity is reversed.
6857 *
6858 * returns: - E1000_ERR_XXX
6859 * E1000_SUCCESS
6860 *
6861 * For phy's older then IGP, this function simply reads the polarity bit in the
6862 * Phy Status register. For IGP phy's, this bit is valid only if link speed is
6863 * 10 Mbps. If the link speed is 100 Mbps there is no polarity so this bit will
6864 * return 0. If the link speed is 1000 Mbps the polarity status is in the
6865 * IGP01E1000_PHY_PCS_INIT_REG.
6866 *****************************************************************************/
6867 static int32_t
6868 e1000_check_polarity(struct e1000_hw *hw,
6869 e1000_rev_polarity *polarity)
6870 {
6871 int32_t ret_val;
6872 uint16_t phy_data;
6873
6874 DEBUGFUNC("e1000_check_polarity");
6875
6876 if ((hw->phy_type == e1000_phy_m88) ||
6877 (hw->phy_type == e1000_phy_gg82563)) {
6878 /* return the Polarity bit in the Status register. */
6879 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6880 &phy_data);
6881 if (ret_val)
6882 return ret_val;
6883 *polarity = ((phy_data & M88E1000_PSSR_REV_POLARITY) >>
6884 M88E1000_PSSR_REV_POLARITY_SHIFT) ?
6885 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6886
6887 } else if (hw->phy_type == e1000_phy_igp ||
6888 hw->phy_type == e1000_phy_igp_3 ||
6889 hw->phy_type == e1000_phy_igp_2) {
6890 /* Read the Status register to check the speed */
6891 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS,
6892 &phy_data);
6893 if (ret_val)
6894 return ret_val;
6895
6896 /* If speed is 1000 Mbps, must read the IGP01E1000_PHY_PCS_INIT_REG to
6897 * find the polarity status */
6898 if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
6899 IGP01E1000_PSSR_SPEED_1000MBPS) {
6900
6901 /* Read the GIG initialization PCS register (0x00B4) */
6902 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG,
6903 &phy_data);
6904 if (ret_val)
6905 return ret_val;
6906
6907 /* Check the polarity bits */
6908 *polarity = (phy_data & IGP01E1000_PHY_POLARITY_MASK) ?
6909 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6910 } else {
6911 /* For 10 Mbps, read the polarity bit in the status register. (for
6912 * 100 Mbps this bit is always 0) */
6913 *polarity = (phy_data & IGP01E1000_PSSR_POLARITY_REVERSED) ?
6914 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6915 }
6916 } else if (hw->phy_type == e1000_phy_ife) {
6917 ret_val = e1000_read_phy_reg(hw, IFE_PHY_EXTENDED_STATUS_CONTROL,
6918 &phy_data);
6919 if (ret_val)
6920 return ret_val;
6921 *polarity = ((phy_data & IFE_PESC_POLARITY_REVERSED) >>
6922 IFE_PESC_POLARITY_REVERSED_SHIFT) ?
6923 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6924 }
6925 return E1000_SUCCESS;
6926 }
6927
6928 /******************************************************************************
6929 * Check if Downshift occured
6930 *
6931 * hw - Struct containing variables accessed by shared code
6932 * downshift - output parameter : 0 - No Downshift ocured.
6933 * 1 - Downshift ocured.
6934 *
6935 * returns: - E1000_ERR_XXX
6936 * E1000_SUCCESS
6937 *
6938 * For phy's older then IGP, this function reads the Downshift bit in the Phy
6939 * Specific Status register. For IGP phy's, it reads the Downgrade bit in the
6940 * Link Health register. In IGP this bit is latched high, so the driver must
6941 * read it immediately after link is established.
6942 *****************************************************************************/
6943 static int32_t
6944 e1000_check_downshift(struct e1000_hw *hw)
6945 {
6946 int32_t ret_val;
6947 uint16_t phy_data;
6948
6949 DEBUGFUNC("e1000_check_downshift");
6950
6951 if (hw->phy_type == e1000_phy_igp ||
6952 hw->phy_type == e1000_phy_igp_3 ||
6953 hw->phy_type == e1000_phy_igp_2) {
6954 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_LINK_HEALTH,
6955 &phy_data);
6956 if (ret_val)
6957 return ret_val;
6958
6959 hw->speed_downgraded = (phy_data & IGP01E1000_PLHR_SS_DOWNGRADE) ? 1 : 0;
6960 } else if ((hw->phy_type == e1000_phy_m88) ||
6961 (hw->phy_type == e1000_phy_gg82563)) {
6962 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6963 &phy_data);
6964 if (ret_val)
6965 return ret_val;
6966
6967 hw->speed_downgraded = (phy_data & M88E1000_PSSR_DOWNSHIFT) >>
6968 M88E1000_PSSR_DOWNSHIFT_SHIFT;
6969 } else if (hw->phy_type == e1000_phy_ife) {
6970 /* e1000_phy_ife supports 10/100 speed only */
6971 hw->speed_downgraded = FALSE;
6972 }
6973
6974 return E1000_SUCCESS;
6975 }
6976
6977 /*****************************************************************************
6978 *
6979 * 82541_rev_2 & 82547_rev_2 have the capability to configure the DSP when a
6980 * gigabit link is achieved to improve link quality.
6981 *
6982 * hw: Struct containing variables accessed by shared code
6983 *
6984 * returns: - E1000_ERR_PHY if fail to read/write the PHY
6985 * E1000_SUCCESS at any other case.
6986 *
6987 ****************************************************************************/
6988
6989 static int32_t
6990 e1000_config_dsp_after_link_change(struct e1000_hw *hw,
6991 boolean_t link_up)
6992 {
6993 int32_t ret_val;
6994 uint16_t phy_data, phy_saved_data, speed, duplex, i;
6995 uint16_t dsp_reg_array[IGP01E1000_PHY_CHANNEL_NUM] =
6996 {IGP01E1000_PHY_AGC_PARAM_A,
6997 IGP01E1000_PHY_AGC_PARAM_B,
6998 IGP01E1000_PHY_AGC_PARAM_C,
6999 IGP01E1000_PHY_AGC_PARAM_D};
7000 uint16_t min_length, max_length;
7001
7002 DEBUGFUNC("e1000_config_dsp_after_link_change");
7003
7004 if (hw->phy_type != e1000_phy_igp)
7005 return E1000_SUCCESS;
7006
7007 if (link_up) {
7008 ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
7009 if (ret_val) {
7010 DEBUGOUT("Error getting link speed and duplex\n");
7011 return ret_val;
7012 }
7013
7014 if (speed == SPEED_1000) {
7015
7016 ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
7017 if (ret_val)
7018 return ret_val;
7019
7020 if ((hw->dsp_config_state == e1000_dsp_config_enabled) &&
7021 min_length >= e1000_igp_cable_length_50) {
7022
7023 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
7024 ret_val = e1000_read_phy_reg(hw, dsp_reg_array[i],
7025 &phy_data);
7026 if (ret_val)
7027 return ret_val;
7028
7029 phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
7030
7031 ret_val = e1000_write_phy_reg(hw, dsp_reg_array[i],
7032 phy_data);
7033 if (ret_val)
7034 return ret_val;
7035 }
7036 hw->dsp_config_state = e1000_dsp_config_activated;
7037 }
7038
7039 if ((hw->ffe_config_state == e1000_ffe_config_enabled) &&
7040 (min_length < e1000_igp_cable_length_50)) {
7041
7042 uint16_t ffe_idle_err_timeout = FFE_IDLE_ERR_COUNT_TIMEOUT_20;
7043 uint32_t idle_errs = 0;
7044
7045 /* clear previous idle error counts */
7046 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS,
7047 &phy_data);
7048 if (ret_val)
7049 return ret_val;
7050
7051 for (i = 0; i < ffe_idle_err_timeout; i++) {
7052 udelay(1000);
7053 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS,
7054 &phy_data);
7055 if (ret_val)
7056 return ret_val;
7057
7058 idle_errs += (phy_data & SR_1000T_IDLE_ERROR_CNT);
7059 if (idle_errs > SR_1000T_PHY_EXCESSIVE_IDLE_ERR_COUNT) {
7060 hw->ffe_config_state = e1000_ffe_config_active;
7061
7062 ret_val = e1000_write_phy_reg(hw,
7063 IGP01E1000_PHY_DSP_FFE,
7064 IGP01E1000_PHY_DSP_FFE_CM_CP);
7065 if (ret_val)
7066 return ret_val;
7067 break;
7068 }
7069
7070 if (idle_errs)
7071 ffe_idle_err_timeout = FFE_IDLE_ERR_COUNT_TIMEOUT_100;
7072 }
7073 }
7074 }
7075 } else {
7076 if (hw->dsp_config_state == e1000_dsp_config_activated) {
7077 /* Save off the current value of register 0x2F5B to be restored at
7078 * the end of the routines. */
7079 ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
7080
7081 if (ret_val)
7082 return ret_val;
7083
7084 /* Disable the PHY transmitter */
7085 ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
7086
7087 if (ret_val)
7088 return ret_val;
7089
7090 mdelay(20);
7091
7092 ret_val = e1000_write_phy_reg(hw, 0x0000,
7093 IGP01E1000_IEEE_FORCE_GIGA);
7094 if (ret_val)
7095 return ret_val;
7096 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
7097 ret_val = e1000_read_phy_reg(hw, dsp_reg_array[i], &phy_data);
7098 if (ret_val)
7099 return ret_val;
7100
7101 phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
7102 phy_data |= IGP01E1000_PHY_EDAC_SIGN_EXT_9_BITS;
7103
7104 ret_val = e1000_write_phy_reg(hw,dsp_reg_array[i], phy_data);
7105 if (ret_val)
7106 return ret_val;
7107 }
7108
7109 ret_val = e1000_write_phy_reg(hw, 0x0000,
7110 IGP01E1000_IEEE_RESTART_AUTONEG);
7111 if (ret_val)
7112 return ret_val;
7113
7114 mdelay(20);
7115
7116 /* Now enable the transmitter */
7117 ret_val = e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
7118
7119 if (ret_val)
7120 return ret_val;
7121
7122 hw->dsp_config_state = e1000_dsp_config_enabled;
7123 }
7124
7125 if (hw->ffe_config_state == e1000_ffe_config_active) {
7126 /* Save off the current value of register 0x2F5B to be restored at
7127 * the end of the routines. */
7128 ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
7129
7130 if (ret_val)
7131 return ret_val;
7132
7133 /* Disable the PHY transmitter */
7134 ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
7135
7136 if (ret_val)
7137 return ret_val;
7138
7139 mdelay(20);
7140
7141 ret_val = e1000_write_phy_reg(hw, 0x0000,
7142 IGP01E1000_IEEE_FORCE_GIGA);
7143 if (ret_val)
7144 return ret_val;
7145 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_DSP_FFE,
7146 IGP01E1000_PHY_DSP_FFE_DEFAULT);
7147 if (ret_val)
7148 return ret_val;
7149
7150 ret_val = e1000_write_phy_reg(hw, 0x0000,
7151 IGP01E1000_IEEE_RESTART_AUTONEG);
7152 if (ret_val)
7153 return ret_val;
7154
7155 mdelay(20);
7156
7157 /* Now enable the transmitter */
7158 ret_val = e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
7159
7160 if (ret_val)
7161 return ret_val;
7162
7163 hw->ffe_config_state = e1000_ffe_config_enabled;
7164 }
7165 }
7166 return E1000_SUCCESS;
7167 }
7168
7169 /*****************************************************************************
7170 * Set PHY to class A mode
7171 * Assumes the following operations will follow to enable the new class mode.
7172 * 1. Do a PHY soft reset
7173 * 2. Restart auto-negotiation or force link.
7174 *
7175 * hw - Struct containing variables accessed by shared code
7176 ****************************************************************************/
7177 static int32_t
7178 e1000_set_phy_mode(struct e1000_hw *hw)
7179 {
7180 int32_t ret_val;
7181 uint16_t eeprom_data;
7182
7183 DEBUGFUNC("e1000_set_phy_mode");
7184
7185 if ((hw->mac_type == e1000_82545_rev_3) &&
7186 (hw->media_type == e1000_media_type_copper)) {
7187 ret_val = e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1, &eeprom_data);
7188 if (ret_val) {
7189 return ret_val;
7190 }
7191
7192 if ((eeprom_data != EEPROM_RESERVED_WORD) &&
7193 (eeprom_data & EEPROM_PHY_CLASS_A)) {
7194 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x000B);
7195 if (ret_val)
7196 return ret_val;
7197 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x8104);
7198 if (ret_val)
7199 return ret_val;
7200
7201 hw->phy_reset_disable = FALSE;
7202 }
7203 }
7204
7205 return E1000_SUCCESS;
7206 }
7207
7208 /*****************************************************************************
7209 *
7210 * This function sets the lplu state according to the active flag. When
7211 * activating lplu this function also disables smart speed and vise versa.
7212 * lplu will not be activated unless the device autonegotiation advertisment
7213 * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
7214 * hw: Struct containing variables accessed by shared code
7215 * active - true to enable lplu false to disable lplu.
7216 *
7217 * returns: - E1000_ERR_PHY if fail to read/write the PHY
7218 * E1000_SUCCESS at any other case.
7219 *
7220 ****************************************************************************/
7221
7222 static int32_t
7223 e1000_set_d3_lplu_state(struct e1000_hw *hw,
7224 boolean_t active)
7225 {
7226 uint32_t phy_ctrl = 0;
7227 int32_t ret_val;
7228 uint16_t phy_data;
7229 DEBUGFUNC("e1000_set_d3_lplu_state");
7230
7231 if (hw->phy_type != e1000_phy_igp && hw->phy_type != e1000_phy_igp_2
7232 && hw->phy_type != e1000_phy_igp_3)
7233 return E1000_SUCCESS;
7234
7235 /* During driver activity LPLU should not be used or it will attain link
7236 * from the lowest speeds starting from 10Mbps. The capability is used for
7237 * Dx transitions and states */
7238 if (hw->mac_type == e1000_82541_rev_2 || hw->mac_type == e1000_82547_rev_2) {
7239 ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data);
7240 if (ret_val)
7241 return ret_val;
7242 } else if (hw->mac_type == e1000_ich8lan) {
7243 /* MAC writes into PHY register based on the state transition
7244 * and start auto-negotiation. SW driver can overwrite the settings
7245 * in CSR PHY power control E1000_PHY_CTRL register. */
7246 phy_ctrl = E1000_READ_REG(hw, PHY_CTRL);
7247 } else {
7248 ret_val = e1000_read_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, &phy_data);
7249 if (ret_val)
7250 return ret_val;
7251 }
7252
7253 if (!active) {
7254 if (hw->mac_type == e1000_82541_rev_2 ||
7255 hw->mac_type == e1000_82547_rev_2) {
7256 phy_data &= ~IGP01E1000_GMII_FLEX_SPD;
7257 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO, phy_data);
7258 if (ret_val)
7259 return ret_val;
7260 } else {
7261 if (hw->mac_type == e1000_ich8lan) {
7262 phy_ctrl &= ~E1000_PHY_CTRL_NOND0A_LPLU;
7263 E1000_WRITE_REG(hw, PHY_CTRL, phy_ctrl);
7264 } else {
7265 phy_data &= ~IGP02E1000_PM_D3_LPLU;
7266 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
7267 phy_data);
7268 if (ret_val)
7269 return ret_val;
7270 }
7271 }
7272
7273 /* LPLU and SmartSpeed are mutually exclusive. LPLU is used during
7274 * Dx states where the power conservation is most important. During
7275 * driver activity we should enable SmartSpeed, so performance is
7276 * maintained. */
7277 if (hw->smart_speed == e1000_smart_speed_on) {
7278 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7279 &phy_data);
7280 if (ret_val)
7281 return ret_val;
7282
7283 phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
7284 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7285 phy_data);
7286 if (ret_val)
7287 return ret_val;
7288 } else if (hw->smart_speed == e1000_smart_speed_off) {
7289 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7290 &phy_data);
7291 if (ret_val)
7292 return ret_val;
7293
7294 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7295 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7296 phy_data);
7297 if (ret_val)
7298 return ret_val;
7299 }
7300
7301 } else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT) ||
7302 (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL ) ||
7303 (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_100_ALL)) {
7304
7305 if (hw->mac_type == e1000_82541_rev_2 ||
7306 hw->mac_type == e1000_82547_rev_2) {
7307 phy_data |= IGP01E1000_GMII_FLEX_SPD;
7308 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO, phy_data);
7309 if (ret_val)
7310 return ret_val;
7311 } else {
7312 if (hw->mac_type == e1000_ich8lan) {
7313 phy_ctrl |= E1000_PHY_CTRL_NOND0A_LPLU;
7314 E1000_WRITE_REG(hw, PHY_CTRL, phy_ctrl);
7315 } else {
7316 phy_data |= IGP02E1000_PM_D3_LPLU;
7317 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
7318 phy_data);
7319 if (ret_val)
7320 return ret_val;
7321 }
7322 }
7323
7324 /* When LPLU is enabled we should disable SmartSpeed */
7325 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, &phy_data);
7326 if (ret_val)
7327 return ret_val;
7328
7329 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7330 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, phy_data);
7331 if (ret_val)
7332 return ret_val;
7333
7334 }
7335 return E1000_SUCCESS;
7336 }
7337
7338 /*****************************************************************************
7339 *
7340 * This function sets the lplu d0 state according to the active flag. When
7341 * activating lplu this function also disables smart speed and vise versa.
7342 * lplu will not be activated unless the device autonegotiation advertisment
7343 * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
7344 * hw: Struct containing variables accessed by shared code
7345 * active - true to enable lplu false to disable lplu.
7346 *
7347 * returns: - E1000_ERR_PHY if fail to read/write the PHY
7348 * E1000_SUCCESS at any other case.
7349 *
7350 ****************************************************************************/
7351
7352 static int32_t
7353 e1000_set_d0_lplu_state(struct e1000_hw *hw,
7354 boolean_t active)
7355 {
7356 uint32_t phy_ctrl = 0;
7357 int32_t ret_val;
7358 uint16_t phy_data;
7359 DEBUGFUNC("e1000_set_d0_lplu_state");
7360
7361 if (hw->mac_type <= e1000_82547_rev_2)
7362 return E1000_SUCCESS;
7363
7364 if (hw->mac_type == e1000_ich8lan) {
7365 phy_ctrl = E1000_READ_REG(hw, PHY_CTRL);
7366 } else {
7367 ret_val = e1000_read_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, &phy_data);
7368 if (ret_val)
7369 return ret_val;
7370 }
7371
7372 if (!active) {
7373 if (hw->mac_type == e1000_ich8lan) {
7374 phy_ctrl &= ~E1000_PHY_CTRL_D0A_LPLU;
7375 E1000_WRITE_REG(hw, PHY_CTRL, phy_ctrl);
7376 } else {
7377 phy_data &= ~IGP02E1000_PM_D0_LPLU;
7378 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
7379 if (ret_val)
7380 return ret_val;
7381 }
7382
7383 /* LPLU and SmartSpeed are mutually exclusive. LPLU is used during
7384 * Dx states where the power conservation is most important. During
7385 * driver activity we should enable SmartSpeed, so performance is
7386 * maintained. */
7387 if (hw->smart_speed == e1000_smart_speed_on) {
7388 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7389 &phy_data);
7390 if (ret_val)
7391 return ret_val;
7392
7393 phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
7394 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7395 phy_data);
7396 if (ret_val)
7397 return ret_val;
7398 } else if (hw->smart_speed == e1000_smart_speed_off) {
7399 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7400 &phy_data);
7401 if (ret_val)
7402 return ret_val;
7403
7404 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7405 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7406 phy_data);
7407 if (ret_val)
7408 return ret_val;
7409 }
7410
7411
7412 } else {
7413
7414 if (hw->mac_type == e1000_ich8lan) {
7415 phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU;
7416 E1000_WRITE_REG(hw, PHY_CTRL, phy_ctrl);
7417 } else {
7418 phy_data |= IGP02E1000_PM_D0_LPLU;
7419 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
7420 if (ret_val)
7421 return ret_val;
7422 }
7423
7424 /* When LPLU is enabled we should disable SmartSpeed */
7425 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, &phy_data);
7426 if (ret_val)
7427 return ret_val;
7428
7429 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7430 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, phy_data);
7431 if (ret_val)
7432 return ret_val;
7433
7434 }
7435 return E1000_SUCCESS;
7436 }
7437
7438 /******************************************************************************
7439 * Change VCO speed register to improve Bit Error Rate performance of SERDES.
7440 *
7441 * hw - Struct containing variables accessed by shared code
7442 *****************************************************************************/
7443 static int32_t
7444 e1000_set_vco_speed(struct e1000_hw *hw)
7445 {
7446 int32_t ret_val;
7447 uint16_t default_page = 0;
7448 uint16_t phy_data;
7449
7450 DEBUGFUNC("e1000_set_vco_speed");
7451
7452 switch (hw->mac_type) {
7453 case e1000_82545_rev_3:
7454 case e1000_82546_rev_3:
7455 break;
7456 default:
7457 return E1000_SUCCESS;
7458 }
7459
7460 /* Set PHY register 30, page 5, bit 8 to 0 */
7461
7462 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, &default_page);
7463 if (ret_val)
7464 return ret_val;
7465
7466 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0005);
7467 if (ret_val)
7468 return ret_val;
7469
7470 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
7471 if (ret_val)
7472 return ret_val;
7473
7474 phy_data &= ~M88E1000_PHY_VCO_REG_BIT8;
7475 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
7476 if (ret_val)
7477 return ret_val;
7478
7479 /* Set PHY register 30, page 4, bit 11 to 1 */
7480
7481 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0004);
7482 if (ret_val)
7483 return ret_val;
7484
7485 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
7486 if (ret_val)
7487 return ret_val;
7488
7489 phy_data |= M88E1000_PHY_VCO_REG_BIT11;
7490 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
7491 if (ret_val)
7492 return ret_val;
7493
7494 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, default_page);
7495 if (ret_val)
7496 return ret_val;
7497
7498 return E1000_SUCCESS;
7499 }
7500
7501
7502 /*****************************************************************************
7503 * This function reads the cookie from ARC ram.
7504 *
7505 * returns: - E1000_SUCCESS .
7506 ****************************************************************************/
7507 static int32_t
7508 e1000_host_if_read_cookie(struct e1000_hw * hw, uint8_t *buffer)
7509 {
7510 uint8_t i;
7511 uint32_t offset = E1000_MNG_DHCP_COOKIE_OFFSET;
7512 uint8_t length = E1000_MNG_DHCP_COOKIE_LENGTH;
7513
7514 length = (length >> 2);
7515 offset = (offset >> 2);
7516
7517 for (i = 0; i < length; i++) {
7518 *((uint32_t *) buffer + i) =
7519 E1000_READ_REG_ARRAY_DWORD(hw, HOST_IF, offset + i);
7520 }
7521 return E1000_SUCCESS;
7522 }
7523
7524
7525 /*****************************************************************************
7526 * This function checks whether the HOST IF is enabled for command operaton
7527 * and also checks whether the previous command is completed.
7528 * It busy waits in case of previous command is not completed.
7529 *
7530 * returns: - E1000_ERR_HOST_INTERFACE_COMMAND in case if is not ready or
7531 * timeout
7532 * - E1000_SUCCESS for success.
7533 ****************************************************************************/
7534 static int32_t
7535 e1000_mng_enable_host_if(struct e1000_hw * hw)
7536 {
7537 uint32_t hicr;
7538 uint8_t i;
7539
7540 /* Check that the host interface is enabled. */
7541 hicr = E1000_READ_REG(hw, HICR);
7542 if ((hicr & E1000_HICR_EN) == 0) {
7543 DEBUGOUT("E1000_HOST_EN bit disabled.\n");
7544 return -E1000_ERR_HOST_INTERFACE_COMMAND;
7545 }
7546 /* check the previous command is completed */
7547 for (i = 0; i < E1000_MNG_DHCP_COMMAND_TIMEOUT; i++) {
7548 hicr = E1000_READ_REG(hw, HICR);
7549 if (!(hicr & E1000_HICR_C))
7550 break;
7551 mdelay(1);
7552 }
7553
7554 if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {
7555 DEBUGOUT("Previous command timeout failed .\n");
7556 return -E1000_ERR_HOST_INTERFACE_COMMAND;
7557 }
7558 return E1000_SUCCESS;
7559 }
7560
7561 /*****************************************************************************
7562 * This function writes the buffer content at the offset given on the host if.
7563 * It also does alignment considerations to do the writes in most efficient way.
7564 * Also fills up the sum of the buffer in *buffer parameter.
7565 *
7566 * returns - E1000_SUCCESS for success.
7567 ****************************************************************************/
7568 static int32_t
7569 e1000_mng_host_if_write(struct e1000_hw * hw, uint8_t *buffer,
7570 uint16_t length, uint16_t offset, uint8_t *sum)
7571 {
7572 uint8_t *tmp;
7573 uint8_t *bufptr = buffer;
7574 uint32_t data = 0;
7575 uint16_t remaining, i, j, prev_bytes;
7576
7577 /* sum = only sum of the data and it is not checksum */
7578
7579 if (length == 0 || offset + length > E1000_HI_MAX_MNG_DATA_LENGTH) {
7580 return -E1000_ERR_PARAM;
7581 }
7582
7583 tmp = (uint8_t *)&data;
7584 prev_bytes = offset & 0x3;
7585 offset &= 0xFFFC;
7586 offset >>= 2;
7587
7588 if (prev_bytes) {
7589 data = E1000_READ_REG_ARRAY_DWORD(hw, HOST_IF, offset);
7590 for (j = prev_bytes; j < sizeof(uint32_t); j++) {
7591 *(tmp + j) = *bufptr++;
7592 *sum += *(tmp + j);
7593 }
7594 E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset, data);
7595 length -= j - prev_bytes;
7596 offset++;
7597 }
7598
7599 remaining = length & 0x3;
7600 length -= remaining;
7601
7602 /* Calculate length in DWORDs */
7603 length >>= 2;
7604
7605 /* The device driver writes the relevant command block into the
7606 * ram area. */
7607 for (i = 0; i < length; i++) {
7608 for (j = 0; j < sizeof(uint32_t); j++) {
7609 *(tmp + j) = *bufptr++;
7610 *sum += *(tmp + j);
7611 }
7612
7613 E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset + i, data);
7614 }
7615 if (remaining) {
7616 for (j = 0; j < sizeof(uint32_t); j++) {
7617 if (j < remaining)
7618 *(tmp + j) = *bufptr++;
7619 else
7620 *(tmp + j) = 0;
7621
7622 *sum += *(tmp + j);
7623 }
7624 E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset + i, data);
7625 }
7626
7627 return E1000_SUCCESS;
7628 }
7629
7630
7631 /*****************************************************************************
7632 * This function writes the command header after does the checksum calculation.
7633 *
7634 * returns - E1000_SUCCESS for success.
7635 ****************************************************************************/
7636 static int32_t
7637 e1000_mng_write_cmd_header(struct e1000_hw * hw,
7638 struct e1000_host_mng_command_header * hdr)
7639 {
7640 uint16_t i;
7641 uint8_t sum;
7642 uint8_t *buffer;
7643
7644 /* Write the whole command header structure which includes sum of
7645 * the buffer */
7646
7647 uint16_t length = sizeof(struct e1000_host_mng_command_header);
7648
7649 sum = hdr->checksum;
7650 hdr->checksum = 0;
7651
7652 buffer = (uint8_t *) hdr;
7653 i = length;
7654 while (i--)
7655 sum += buffer[i];
7656
7657 hdr->checksum = 0 - sum;
7658
7659 length >>= 2;
7660 /* The device driver writes the relevant command block into the ram area. */
7661 for (i = 0; i < length; i++) {
7662 E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, i, *((uint32_t *) hdr + i));
7663 E1000_WRITE_FLUSH(hw);
7664 }
7665
7666 return E1000_SUCCESS;
7667 }
7668
7669
7670 /*****************************************************************************
7671 * This function indicates to ARC that a new command is pending which completes
7672 * one write operation by the driver.
7673 *
7674 * returns - E1000_SUCCESS for success.
7675 ****************************************************************************/
7676 static int32_t
7677 e1000_mng_write_commit(struct e1000_hw * hw)
7678 {
7679 uint32_t hicr;
7680
7681 hicr = E1000_READ_REG(hw, HICR);
7682 /* Setting this bit tells the ARC that a new command is pending. */
7683 E1000_WRITE_REG(hw, HICR, hicr | E1000_HICR_C);
7684
7685 return E1000_SUCCESS;
7686 }
7687
7688
7689 /*****************************************************************************
7690 * This function checks the mode of the firmware.
7691 *
7692 * returns - TRUE when the mode is IAMT or FALSE.
7693 ****************************************************************************/
7694 boolean_t
7695 e1000_check_mng_mode(struct e1000_hw *hw)
7696 {
7697 uint32_t fwsm;
7698
7699 fwsm = E1000_READ_REG(hw, FWSM);
7700
7701 if (hw->mac_type == e1000_ich8lan) {
7702 if ((fwsm & E1000_FWSM_MODE_MASK) ==
7703 (E1000_MNG_ICH_IAMT_MODE << E1000_FWSM_MODE_SHIFT))
7704 return TRUE;
7705 } else if ((fwsm & E1000_FWSM_MODE_MASK) ==
7706 (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT))
7707 return TRUE;
7708
7709 return FALSE;
7710 }
7711
7712
7713 /*****************************************************************************
7714 * This function writes the dhcp info .
7715 ****************************************************************************/
7716 int32_t
7717 e1000_mng_write_dhcp_info(struct e1000_hw * hw, uint8_t *buffer,
7718 uint16_t length)
7719 {
7720 int32_t ret_val;
7721 struct e1000_host_mng_command_header hdr;
7722
7723 hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD;
7724 hdr.command_length = length;
7725 hdr.reserved1 = 0;
7726 hdr.reserved2 = 0;
7727 hdr.checksum = 0;
7728
7729 ret_val = e1000_mng_enable_host_if(hw);
7730 if (ret_val == E1000_SUCCESS) {
7731 ret_val = e1000_mng_host_if_write(hw, buffer, length, sizeof(hdr),
7732 &(hdr.checksum));
7733 if (ret_val == E1000_SUCCESS) {
7734 ret_val = e1000_mng_write_cmd_header(hw, &hdr);
7735 if (ret_val == E1000_SUCCESS)
7736 ret_val = e1000_mng_write_commit(hw);
7737 }
7738 }
7739 return ret_val;
7740 }
7741
7742
7743 /*****************************************************************************
7744 * This function calculates the checksum.
7745 *
7746 * returns - checksum of buffer contents.
7747 ****************************************************************************/
7748 static uint8_t
7749 e1000_calculate_mng_checksum(char *buffer, uint32_t length)
7750 {
7751 uint8_t sum = 0;
7752 uint32_t i;
7753
7754 if (!buffer)
7755 return 0;
7756
7757 for (i=0; i < length; i++)
7758 sum += buffer[i];
7759
7760 return (uint8_t) (0 - sum);
7761 }
7762
7763 /*****************************************************************************
7764 * This function checks whether tx pkt filtering needs to be enabled or not.
7765 *
7766 * returns - TRUE for packet filtering or FALSE.
7767 ****************************************************************************/
7768 boolean_t
7769 e1000_enable_tx_pkt_filtering(struct e1000_hw *hw)
7770 {
7771 /* called in init as well as watchdog timer functions */
7772
7773 int32_t ret_val, checksum;
7774 boolean_t tx_filter = FALSE;
7775 struct e1000_host_mng_dhcp_cookie *hdr = &(hw->mng_cookie);
7776 uint8_t *buffer = (uint8_t *) &(hw->mng_cookie);
7777
7778 if (e1000_check_mng_mode(hw)) {
7779 ret_val = e1000_mng_enable_host_if(hw);
7780 if (ret_val == E1000_SUCCESS) {
7781 ret_val = e1000_host_if_read_cookie(hw, buffer);
7782 if (ret_val == E1000_SUCCESS) {
7783 checksum = hdr->checksum;
7784 hdr->checksum = 0;
7785 if ((hdr->signature == E1000_IAMT_SIGNATURE) &&
7786 checksum == e1000_calculate_mng_checksum((char *)buffer,
7787 E1000_MNG_DHCP_COOKIE_LENGTH)) {
7788 if (hdr->status &
7789 E1000_MNG_DHCP_COOKIE_STATUS_PARSING_SUPPORT)
7790 tx_filter = TRUE;
7791 } else
7792 tx_filter = TRUE;
7793 } else
7794 tx_filter = TRUE;
7795 }
7796 }
7797
7798 hw->tx_pkt_filtering = tx_filter;
7799 return tx_filter;
7800 }
7801
7802 /******************************************************************************
7803 * Verifies the hardware needs to allow ARPs to be processed by the host
7804 *
7805 * hw - Struct containing variables accessed by shared code
7806 *
7807 * returns: - TRUE/FALSE
7808 *
7809 *****************************************************************************/
7810 uint32_t
7811 e1000_enable_mng_pass_thru(struct e1000_hw *hw)
7812 {
7813 uint32_t manc;
7814 uint32_t fwsm, factps;
7815
7816 if (hw->asf_firmware_present) {
7817 manc = E1000_READ_REG(hw, MANC);
7818
7819 if (!(manc & E1000_MANC_RCV_TCO_EN) ||
7820 !(manc & E1000_MANC_EN_MAC_ADDR_FILTER))
7821 return FALSE;
7822 if (e1000_arc_subsystem_valid(hw) == TRUE) {
7823 fwsm = E1000_READ_REG(hw, FWSM);
7824 factps = E1000_READ_REG(hw, FACTPS);
7825
7826 if ((((fwsm & E1000_FWSM_MODE_MASK) >> E1000_FWSM_MODE_SHIFT) ==
7827 e1000_mng_mode_pt) && !(factps & E1000_FACTPS_MNGCG))
7828 return TRUE;
7829 } else
7830 if ((manc & E1000_MANC_SMBUS_EN) && !(manc & E1000_MANC_ASF_EN))
7831 return TRUE;
7832 }
7833 return FALSE;
7834 }
7835
7836 static int32_t
7837 e1000_polarity_reversal_workaround(struct e1000_hw *hw)
7838 {
7839 int32_t ret_val;
7840 uint16_t mii_status_reg;
7841 uint16_t i;
7842
7843 /* Polarity reversal workaround for forced 10F/10H links. */
7844
7845 /* Disable the transmitter on the PHY */
7846
7847 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
7848 if (ret_val)
7849 return ret_val;
7850 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFFF);
7851 if (ret_val)
7852 return ret_val;
7853
7854 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
7855 if (ret_val)
7856 return ret_val;
7857
7858 /* This loop will early-out if the NO link condition has been met. */
7859 for (i = PHY_FORCE_TIME; i > 0; i--) {
7860 /* Read the MII Status Register and wait for Link Status bit
7861 * to be clear.
7862 */
7863
7864 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7865 if (ret_val)
7866 return ret_val;
7867
7868 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7869 if (ret_val)
7870 return ret_val;
7871
7872 if ((mii_status_reg & ~MII_SR_LINK_STATUS) == 0) break;
7873 mdelay(100);
7874 }
7875
7876 /* Recommended delay time after link has been lost */
7877 mdelay(1000);
7878
7879 /* Now we will re-enable th transmitter on the PHY */
7880
7881 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
7882 if (ret_val)
7883 return ret_val;
7884 mdelay(50);
7885 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFF0);
7886 if (ret_val)
7887 return ret_val;
7888 mdelay(50);
7889 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFF00);
7890 if (ret_val)
7891 return ret_val;
7892 mdelay(50);
7893 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x0000);
7894 if (ret_val)
7895 return ret_val;
7896
7897 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
7898 if (ret_val)
7899 return ret_val;
7900
7901 /* This loop will early-out if the link condition has been met. */
7902 for (i = PHY_FORCE_TIME; i > 0; i--) {
7903 /* Read the MII Status Register and wait for Link Status bit
7904 * to be set.
7905 */
7906
7907 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7908 if (ret_val)
7909 return ret_val;
7910
7911 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7912 if (ret_val)
7913 return ret_val;
7914
7915 if (mii_status_reg & MII_SR_LINK_STATUS) break;
7916 mdelay(100);
7917 }
7918 return E1000_SUCCESS;
7919 }
7920
7921 /***************************************************************************
7922 *
7923 * Disables PCI-Express master access.
7924 *
7925 * hw: Struct containing variables accessed by shared code
7926 *
7927 * returns: - none.
7928 *
7929 ***************************************************************************/
7930 static void
7931 e1000_set_pci_express_master_disable(struct e1000_hw *hw)
7932 {
7933 uint32_t ctrl;
7934
7935 DEBUGFUNC("e1000_set_pci_express_master_disable");
7936
7937 if (hw->bus_type != e1000_bus_type_pci_express)
7938 return;
7939
7940 ctrl = E1000_READ_REG(hw, CTRL);
7941 ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
7942 E1000_WRITE_REG(hw, CTRL, ctrl);
7943 }
7944
7945 /*******************************************************************************
7946 *
7947 * Disables PCI-Express master access and verifies there are no pending requests
7948 *
7949 * hw: Struct containing variables accessed by shared code
7950 *
7951 * returns: - E1000_ERR_MASTER_REQUESTS_PENDING if master disable bit hasn't
7952 * caused the master requests to be disabled.
7953 * E1000_SUCCESS master requests disabled.
7954 *
7955 ******************************************************************************/
7956 int32_t
7957 e1000_disable_pciex_master(struct e1000_hw *hw)
7958 {
7959 int32_t timeout = MASTER_DISABLE_TIMEOUT; /* 80ms */
7960
7961 DEBUGFUNC("e1000_disable_pciex_master");
7962
7963 if (hw->bus_type != e1000_bus_type_pci_express)
7964 return E1000_SUCCESS;
7965
7966 e1000_set_pci_express_master_disable(hw);
7967
7968 while (timeout) {
7969 if (!(E1000_READ_REG(hw, STATUS) & E1000_STATUS_GIO_MASTER_ENABLE))
7970 break;
7971 else
7972 udelay(100);
7973 timeout--;
7974 }
7975
7976 if (!timeout) {
7977 DEBUGOUT("Master requests are pending.\n");
7978 return -E1000_ERR_MASTER_REQUESTS_PENDING;
7979 }
7980
7981 return E1000_SUCCESS;
7982 }
7983
7984 /*******************************************************************************
7985 *
7986 * Check for EEPROM Auto Read bit done.
7987 *
7988 * hw: Struct containing variables accessed by shared code
7989 *
7990 * returns: - E1000_ERR_RESET if fail to reset MAC
7991 * E1000_SUCCESS at any other case.
7992 *
7993 ******************************************************************************/
7994 static int32_t
7995 e1000_get_auto_rd_done(struct e1000_hw *hw)
7996 {
7997 int32_t timeout = AUTO_READ_DONE_TIMEOUT;
7998
7999 DEBUGFUNC("e1000_get_auto_rd_done");
8000
8001 switch (hw->mac_type) {
8002 default:
8003 msleep(5);
8004 break;
8005 case e1000_82571:
8006 case e1000_82572:
8007 case e1000_82573:
8008 case e1000_80003es2lan:
8009 case e1000_ich8lan:
8010 while (timeout) {
8011 if (E1000_READ_REG(hw, EECD) & E1000_EECD_AUTO_RD)
8012 break;
8013 else msleep(1);
8014 timeout--;
8015 }
8016
8017 if (!timeout) {
8018 DEBUGOUT("Auto read by HW from EEPROM has not completed.\n");
8019 return -E1000_ERR_RESET;
8020 }
8021 break;
8022 }
8023
8024 /* PHY configuration from NVM just starts after EECD_AUTO_RD sets to high.
8025 * Need to wait for PHY configuration completion before accessing NVM
8026 * and PHY. */
8027 if (hw->mac_type == e1000_82573)
8028 msleep(25);
8029
8030 return E1000_SUCCESS;
8031 }
8032
8033 /***************************************************************************
8034 * Checks if the PHY configuration is done
8035 *
8036 * hw: Struct containing variables accessed by shared code
8037 *
8038 * returns: - E1000_ERR_RESET if fail to reset MAC
8039 * E1000_SUCCESS at any other case.
8040 *
8041 ***************************************************************************/
8042 static int32_t
8043 e1000_get_phy_cfg_done(struct e1000_hw *hw)
8044 {
8045 int32_t timeout = PHY_CFG_TIMEOUT;
8046 uint32_t cfg_mask = E1000_EEPROM_CFG_DONE;
8047
8048 DEBUGFUNC("e1000_get_phy_cfg_done");
8049
8050 switch (hw->mac_type) {
8051 default:
8052 mdelay(10);
8053 break;
8054 case e1000_80003es2lan:
8055 /* Separate *_CFG_DONE_* bit for each port */
8056 if (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)
8057 cfg_mask = E1000_EEPROM_CFG_DONE_PORT_1;
8058 /* Fall Through */
8059 case e1000_82571:
8060 case e1000_82572:
8061 while (timeout) {
8062 if (E1000_READ_REG(hw, EEMNGCTL) & cfg_mask)
8063 break;
8064 else
8065 msleep(1);
8066 timeout--;
8067 }
8068 if (!timeout) {
8069 DEBUGOUT("MNG configuration cycle has not completed.\n");
8070 return -E1000_ERR_RESET;
8071 }
8072 break;
8073 }
8074
8075 return E1000_SUCCESS;
8076 }
8077
8078 /***************************************************************************
8079 *
8080 * Using the combination of SMBI and SWESMBI semaphore bits when resetting
8081 * adapter or Eeprom access.
8082 *
8083 * hw: Struct containing variables accessed by shared code
8084 *
8085 * returns: - E1000_ERR_EEPROM if fail to access EEPROM.
8086 * E1000_SUCCESS at any other case.
8087 *
8088 ***************************************************************************/
8089 static int32_t
8090 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw)
8091 {
8092 int32_t timeout;
8093 uint32_t swsm;
8094
8095 DEBUGFUNC("e1000_get_hw_eeprom_semaphore");
8096
8097 if (!hw->eeprom_semaphore_present)
8098 return E1000_SUCCESS;
8099
8100 if (hw->mac_type == e1000_80003es2lan) {
8101 /* Get the SW semaphore. */
8102 if (e1000_get_software_semaphore(hw) != E1000_SUCCESS)
8103 return -E1000_ERR_EEPROM;
8104 }
8105
8106 /* Get the FW semaphore. */
8107 timeout = hw->eeprom.word_size + 1;
8108 while (timeout) {
8109 swsm = E1000_READ_REG(hw, SWSM);
8110 swsm |= E1000_SWSM_SWESMBI;
8111 E1000_WRITE_REG(hw, SWSM, swsm);
8112 /* if we managed to set the bit we got the semaphore. */
8113 swsm = E1000_READ_REG(hw, SWSM);
8114 if (swsm & E1000_SWSM_SWESMBI)
8115 break;
8116
8117 udelay(50);
8118 timeout--;
8119 }
8120
8121 if (!timeout) {
8122 /* Release semaphores */
8123 e1000_put_hw_eeprom_semaphore(hw);
8124 DEBUGOUT("Driver can't access the Eeprom - SWESMBI bit is set.\n");
8125 return -E1000_ERR_EEPROM;
8126 }
8127
8128 return E1000_SUCCESS;
8129 }
8130
8131 /***************************************************************************
8132 * This function clears HW semaphore bits.
8133 *
8134 * hw: Struct containing variables accessed by shared code
8135 *
8136 * returns: - None.
8137 *
8138 ***************************************************************************/
8139 static void
8140 e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw)
8141 {
8142 uint32_t swsm;
8143
8144 DEBUGFUNC("e1000_put_hw_eeprom_semaphore");
8145
8146 if (!hw->eeprom_semaphore_present)
8147 return;
8148
8149 swsm = E1000_READ_REG(hw, SWSM);
8150 if (hw->mac_type == e1000_80003es2lan) {
8151 /* Release both semaphores. */
8152 swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
8153 } else
8154 swsm &= ~(E1000_SWSM_SWESMBI);
8155 E1000_WRITE_REG(hw, SWSM, swsm);
8156 }
8157
8158 /***************************************************************************
8159 *
8160 * Obtaining software semaphore bit (SMBI) before resetting PHY.
8161 *
8162 * hw: Struct containing variables accessed by shared code
8163 *
8164 * returns: - E1000_ERR_RESET if fail to obtain semaphore.
8165 * E1000_SUCCESS at any other case.
8166 *
8167 ***************************************************************************/
8168 static int32_t
8169 e1000_get_software_semaphore(struct e1000_hw *hw)
8170 {
8171 int32_t timeout = hw->eeprom.word_size + 1;
8172 uint32_t swsm;
8173
8174 DEBUGFUNC("e1000_get_software_semaphore");
8175
8176 if (hw->mac_type != e1000_80003es2lan) {
8177 return E1000_SUCCESS;
8178 }
8179
8180 while (timeout) {
8181 swsm = E1000_READ_REG(hw, SWSM);
8182 /* If SMBI bit cleared, it is now set and we hold the semaphore */
8183 if (!(swsm & E1000_SWSM_SMBI))
8184 break;
8185 mdelay(1);
8186 timeout--;
8187 }
8188
8189 if (!timeout) {
8190 DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
8191 return -E1000_ERR_RESET;
8192 }
8193
8194 return E1000_SUCCESS;
8195 }
8196
8197 /***************************************************************************
8198 *
8199 * Release semaphore bit (SMBI).
8200 *
8201 * hw: Struct containing variables accessed by shared code
8202 *
8203 ***************************************************************************/
8204 static void
8205 e1000_release_software_semaphore(struct e1000_hw *hw)
8206 {
8207 uint32_t swsm;
8208
8209 DEBUGFUNC("e1000_release_software_semaphore");
8210
8211 if (hw->mac_type != e1000_80003es2lan) {
8212 return;
8213 }
8214
8215 swsm = E1000_READ_REG(hw, SWSM);
8216 /* Release the SW semaphores.*/
8217 swsm &= ~E1000_SWSM_SMBI;
8218 E1000_WRITE_REG(hw, SWSM, swsm);
8219 }
8220
8221 /******************************************************************************
8222 * Checks if PHY reset is blocked due to SOL/IDER session, for example.
8223 * Returning E1000_BLK_PHY_RESET isn't necessarily an error. But it's up to
8224 * the caller to figure out how to deal with it.
8225 *
8226 * hw - Struct containing variables accessed by shared code
8227 *
8228 * returns: - E1000_BLK_PHY_RESET
8229 * E1000_SUCCESS
8230 *
8231 *****************************************************************************/
8232 int32_t
8233 e1000_check_phy_reset_block(struct e1000_hw *hw)
8234 {
8235 uint32_t manc = 0;
8236 uint32_t fwsm = 0;
8237
8238 if (hw->mac_type == e1000_ich8lan) {
8239 fwsm = E1000_READ_REG(hw, FWSM);
8240 return (fwsm & E1000_FWSM_RSPCIPHY) ? E1000_SUCCESS
8241 : E1000_BLK_PHY_RESET;
8242 }
8243
8244 if (hw->mac_type > e1000_82547_rev_2)
8245 manc = E1000_READ_REG(hw, MANC);
8246 return (manc & E1000_MANC_BLK_PHY_RST_ON_IDE) ?
8247 E1000_BLK_PHY_RESET : E1000_SUCCESS;
8248 }
8249
8250 static uint8_t
8251 e1000_arc_subsystem_valid(struct e1000_hw *hw)
8252 {
8253 uint32_t fwsm;
8254
8255 /* On 8257x silicon, registers in the range of 0x8800 - 0x8FFC
8256 * may not be provided a DMA clock when no manageability features are
8257 * enabled. We do not want to perform any reads/writes to these registers
8258 * if this is the case. We read FWSM to determine the manageability mode.
8259 */
8260 switch (hw->mac_type) {
8261 case e1000_82571:
8262 case e1000_82572:
8263 case e1000_82573:
8264 case e1000_80003es2lan:
8265 fwsm = E1000_READ_REG(hw, FWSM);
8266 if ((fwsm & E1000_FWSM_MODE_MASK) != 0)
8267 return TRUE;
8268 break;
8269 case e1000_ich8lan:
8270 return TRUE;
8271 default:
8272 break;
8273 }
8274 return FALSE;
8275 }
8276
8277
8278 /******************************************************************************
8279 * Configure PCI-Ex no-snoop
8280 *
8281 * hw - Struct containing variables accessed by shared code.
8282 * no_snoop - Bitmap of no-snoop events.
8283 *
8284 * returns: E1000_SUCCESS
8285 *
8286 *****************************************************************************/
8287 static int32_t
8288 e1000_set_pci_ex_no_snoop(struct e1000_hw *hw, uint32_t no_snoop)
8289 {
8290 uint32_t gcr_reg = 0;
8291
8292 DEBUGFUNC("e1000_set_pci_ex_no_snoop");
8293
8294 if (hw->bus_type == e1000_bus_type_unknown)
8295 e1000_get_bus_info(hw);
8296
8297 if (hw->bus_type != e1000_bus_type_pci_express)
8298 return E1000_SUCCESS;
8299
8300 if (no_snoop) {
8301 gcr_reg = E1000_READ_REG(hw, GCR);
8302 gcr_reg &= ~(PCI_EX_NO_SNOOP_ALL);
8303 gcr_reg |= no_snoop;
8304 E1000_WRITE_REG(hw, GCR, gcr_reg);
8305 }
8306 if (hw->mac_type == e1000_ich8lan) {
8307 uint32_t ctrl_ext;
8308
8309 E1000_WRITE_REG(hw, GCR, PCI_EX_82566_SNOOP_ALL);
8310
8311 ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
8312 ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
8313 E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
8314 }
8315
8316 return E1000_SUCCESS;
8317 }
8318
8319 /***************************************************************************
8320 *
8321 * Get software semaphore FLAG bit (SWFLAG).
8322 * SWFLAG is used to synchronize the access to all shared resource between
8323 * SW, FW and HW.
8324 *
8325 * hw: Struct containing variables accessed by shared code
8326 *
8327 ***************************************************************************/
8328 static int32_t
8329 e1000_get_software_flag(struct e1000_hw *hw)
8330 {
8331 int32_t timeout = PHY_CFG_TIMEOUT;
8332 uint32_t extcnf_ctrl;
8333
8334 DEBUGFUNC("e1000_get_software_flag");
8335
8336 if (hw->mac_type == e1000_ich8lan) {
8337 while (timeout) {
8338 extcnf_ctrl = E1000_READ_REG(hw, EXTCNF_CTRL);
8339 extcnf_ctrl |= E1000_EXTCNF_CTRL_SWFLAG;
8340 E1000_WRITE_REG(hw, EXTCNF_CTRL, extcnf_ctrl);
8341
8342 extcnf_ctrl = E1000_READ_REG(hw, EXTCNF_CTRL);
8343 if (extcnf_ctrl & E1000_EXTCNF_CTRL_SWFLAG)
8344 break;
8345 mdelay(1);
8346 timeout--;
8347 }
8348
8349 if (!timeout) {
8350 DEBUGOUT("FW or HW locks the resource too long.\n");
8351 return -E1000_ERR_CONFIG;
8352 }
8353 }
8354
8355 return E1000_SUCCESS;
8356 }
8357
8358 /***************************************************************************
8359 *
8360 * Release software semaphore FLAG bit (SWFLAG).
8361 * SWFLAG is used to synchronize the access to all shared resource between
8362 * SW, FW and HW.
8363 *
8364 * hw: Struct containing variables accessed by shared code
8365 *
8366 ***************************************************************************/
8367 static void
8368 e1000_release_software_flag(struct e1000_hw *hw)
8369 {
8370 uint32_t extcnf_ctrl;
8371
8372 DEBUGFUNC("e1000_release_software_flag");
8373
8374 if (hw->mac_type == e1000_ich8lan) {
8375 extcnf_ctrl= E1000_READ_REG(hw, EXTCNF_CTRL);
8376 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
8377 E1000_WRITE_REG(hw, EXTCNF_CTRL, extcnf_ctrl);
8378 }
8379
8380 return;
8381 }
8382
8383 /******************************************************************************
8384 * Reads a 16 bit word or words from the EEPROM using the ICH8's flash access
8385 * register.
8386 *
8387 * hw - Struct containing variables accessed by shared code
8388 * offset - offset of word in the EEPROM to read
8389 * data - word read from the EEPROM
8390 * words - number of words to read
8391 *****************************************************************************/
8392 static int32_t
8393 e1000_read_eeprom_ich8(struct e1000_hw *hw, uint16_t offset, uint16_t words,
8394 uint16_t *data)
8395 {
8396 int32_t error = E1000_SUCCESS;
8397 uint32_t flash_bank = 0;
8398 uint32_t act_offset = 0;
8399 uint32_t bank_offset = 0;
8400 uint16_t word = 0;
8401 uint16_t i = 0;
8402
8403 /* We need to know which is the valid flash bank. In the event
8404 * that we didn't allocate eeprom_shadow_ram, we may not be
8405 * managing flash_bank. So it cannot be trusted and needs
8406 * to be updated with each read.
8407 */
8408 /* Value of bit 22 corresponds to the flash bank we're on. */
8409 flash_bank = (E1000_READ_REG(hw, EECD) & E1000_EECD_SEC1VAL) ? 1 : 0;
8410
8411 /* Adjust offset appropriately if we're on bank 1 - adjust for word size */
8412 bank_offset = flash_bank * (hw->flash_bank_size * 2);
8413
8414 error = e1000_get_software_flag(hw);
8415 if (error != E1000_SUCCESS)
8416 return error;
8417
8418 for (i = 0; i < words; i++) {
8419 if (hw->eeprom_shadow_ram != NULL &&
8420 hw->eeprom_shadow_ram[offset+i].modified == TRUE) {
8421 data[i] = hw->eeprom_shadow_ram[offset+i].eeprom_word;
8422 } else {
8423 /* The NVM part needs a byte offset, hence * 2 */
8424 act_offset = bank_offset + ((offset + i) * 2);
8425 error = e1000_read_ich8_word(hw, act_offset, &word);
8426 if (error != E1000_SUCCESS)
8427 break;
8428 data[i] = word;
8429 }
8430 }
8431
8432 e1000_release_software_flag(hw);
8433
8434 return error;
8435 }
8436
8437 /******************************************************************************
8438 * Writes a 16 bit word or words to the EEPROM using the ICH8's flash access
8439 * register. Actually, writes are written to the shadow ram cache in the hw
8440 * structure hw->e1000_shadow_ram. e1000_commit_shadow_ram flushes this to
8441 * the NVM, which occurs when the NVM checksum is updated.
8442 *
8443 * hw - Struct containing variables accessed by shared code
8444 * offset - offset of word in the EEPROM to write
8445 * words - number of words to write
8446 * data - words to write to the EEPROM
8447 *****************************************************************************/
8448 static int32_t
8449 e1000_write_eeprom_ich8(struct e1000_hw *hw, uint16_t offset, uint16_t words,
8450 uint16_t *data)
8451 {
8452 uint32_t i = 0;
8453 int32_t error = E1000_SUCCESS;
8454
8455 error = e1000_get_software_flag(hw);
8456 if (error != E1000_SUCCESS)
8457 return error;
8458
8459 /* A driver can write to the NVM only if it has eeprom_shadow_ram
8460 * allocated. Subsequent reads to the modified words are read from
8461 * this cached structure as well. Writes will only go into this
8462 * cached structure unless it's followed by a call to
8463 * e1000_update_eeprom_checksum() where it will commit the changes
8464 * and clear the "modified" field.
8465 */
8466 if (hw->eeprom_shadow_ram != NULL) {
8467 for (i = 0; i < words; i++) {
8468 if ((offset + i) < E1000_SHADOW_RAM_WORDS) {
8469 hw->eeprom_shadow_ram[offset+i].modified = TRUE;
8470 hw->eeprom_shadow_ram[offset+i].eeprom_word = data[i];
8471 } else {
8472 error = -E1000_ERR_EEPROM;
8473 break;
8474 }
8475 }
8476 } else {
8477 /* Drivers have the option to not allocate eeprom_shadow_ram as long
8478 * as they don't perform any NVM writes. An attempt in doing so
8479 * will result in this error.
8480 */
8481 error = -E1000_ERR_EEPROM;
8482 }
8483
8484 e1000_release_software_flag(hw);
8485
8486 return error;
8487 }
8488
8489 /******************************************************************************
8490 * This function does initial flash setup so that a new read/write/erase cycle
8491 * can be started.
8492 *
8493 * hw - The pointer to the hw structure
8494 ****************************************************************************/
8495 static int32_t
8496 e1000_ich8_cycle_init(struct e1000_hw *hw)
8497 {
8498 union ich8_hws_flash_status hsfsts;
8499 int32_t error = E1000_ERR_EEPROM;
8500 int32_t i = 0;
8501
8502 DEBUGFUNC("e1000_ich8_cycle_init");
8503
8504 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8505
8506 /* May be check the Flash Des Valid bit in Hw status */
8507 if (hsfsts.hsf_status.fldesvalid == 0) {
8508 DEBUGOUT("Flash descriptor invalid. SW Sequencing must be used.");
8509 return error;
8510 }
8511
8512 /* Clear FCERR in Hw status by writing 1 */
8513 /* Clear DAEL in Hw status by writing a 1 */
8514 hsfsts.hsf_status.flcerr = 1;
8515 hsfsts.hsf_status.dael = 1;
8516
8517 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8518
8519 /* Either we should have a hardware SPI cycle in progress bit to check
8520 * against, in order to start a new cycle or FDONE bit should be changed
8521 * in the hardware so that it is 1 after harware reset, which can then be
8522 * used as an indication whether a cycle is in progress or has been
8523 * completed .. we should also have some software semaphore mechanism to
8524 * guard FDONE or the cycle in progress bit so that two threads access to
8525 * those bits can be sequentiallized or a way so that 2 threads dont
8526 * start the cycle at the same time */
8527
8528 if (hsfsts.hsf_status.flcinprog == 0) {
8529 /* There is no cycle running at present, so we can start a cycle */
8530 /* Begin by setting Flash Cycle Done. */
8531 hsfsts.hsf_status.flcdone = 1;
8532 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8533 error = E1000_SUCCESS;
8534 } else {
8535 /* otherwise poll for sometime so the current cycle has a chance
8536 * to end before giving up. */
8537 for (i = 0; i < ICH_FLASH_COMMAND_TIMEOUT; i++) {
8538 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8539 if (hsfsts.hsf_status.flcinprog == 0) {
8540 error = E1000_SUCCESS;
8541 break;
8542 }
8543 udelay(1);
8544 }
8545 if (error == E1000_SUCCESS) {
8546 /* Successful in waiting for previous cycle to timeout,
8547 * now set the Flash Cycle Done. */
8548 hsfsts.hsf_status.flcdone = 1;
8549 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8550 } else {
8551 DEBUGOUT("Flash controller busy, cannot get access");
8552 }
8553 }
8554 return error;
8555 }
8556
8557 /******************************************************************************
8558 * This function starts a flash cycle and waits for its completion
8559 *
8560 * hw - The pointer to the hw structure
8561 ****************************************************************************/
8562 static int32_t
8563 e1000_ich8_flash_cycle(struct e1000_hw *hw, uint32_t timeout)
8564 {
8565 union ich8_hws_flash_ctrl hsflctl;
8566 union ich8_hws_flash_status hsfsts;
8567 int32_t error = E1000_ERR_EEPROM;
8568 uint32_t i = 0;
8569
8570 /* Start a cycle by writing 1 in Flash Cycle Go in Hw Flash Control */
8571 hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8572 hsflctl.hsf_ctrl.flcgo = 1;
8573 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8574
8575 /* wait till FDONE bit is set to 1 */
8576 do {
8577 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8578 if (hsfsts.hsf_status.flcdone == 1)
8579 break;
8580 udelay(1);
8581 i++;
8582 } while (i < timeout);
8583 if (hsfsts.hsf_status.flcdone == 1 && hsfsts.hsf_status.flcerr == 0) {
8584 error = E1000_SUCCESS;
8585 }
8586 return error;
8587 }
8588
8589 /******************************************************************************
8590 * Reads a byte or word from the NVM using the ICH8 flash access registers.
8591 *
8592 * hw - The pointer to the hw structure
8593 * index - The index of the byte or word to read.
8594 * size - Size of data to read, 1=byte 2=word
8595 * data - Pointer to the word to store the value read.
8596 *****************************************************************************/
8597 static int32_t
8598 e1000_read_ich8_data(struct e1000_hw *hw, uint32_t index,
8599 uint32_t size, uint16_t* data)
8600 {
8601 union ich8_hws_flash_status hsfsts;
8602 union ich8_hws_flash_ctrl hsflctl;
8603 uint32_t flash_linear_address;
8604 uint32_t flash_data = 0;
8605 int32_t error = -E1000_ERR_EEPROM;
8606 int32_t count = 0;
8607
8608 DEBUGFUNC("e1000_read_ich8_data");
8609
8610 if (size < 1 || size > 2 || data == NULL ||
8611 index > ICH_FLASH_LINEAR_ADDR_MASK)
8612 return error;
8613
8614 flash_linear_address = (ICH_FLASH_LINEAR_ADDR_MASK & index) +
8615 hw->flash_base_addr;
8616
8617 do {
8618 udelay(1);
8619 /* Steps */
8620 error = e1000_ich8_cycle_init(hw);
8621 if (error != E1000_SUCCESS)
8622 break;
8623
8624 hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8625 /* 0b/1b corresponds to 1 or 2 byte size, respectively. */
8626 hsflctl.hsf_ctrl.fldbcount = size - 1;
8627 hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_READ;
8628 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8629
8630 /* Write the last 24 bits of index into Flash Linear address field in
8631 * Flash Address */
8632 /* TODO: TBD maybe check the index against the size of flash */
8633
8634 E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8635
8636 error = e1000_ich8_flash_cycle(hw, ICH_FLASH_COMMAND_TIMEOUT);
8637
8638 /* Check if FCERR is set to 1, if set to 1, clear it and try the whole
8639 * sequence a few more times, else read in (shift in) the Flash Data0,
8640 * the order is least significant byte first msb to lsb */
8641 if (error == E1000_SUCCESS) {
8642 flash_data = E1000_READ_ICH_FLASH_REG(hw, ICH_FLASH_FDATA0);
8643 if (size == 1) {
8644 *data = (uint8_t)(flash_data & 0x000000FF);
8645 } else if (size == 2) {
8646 *data = (uint16_t)(flash_data & 0x0000FFFF);
8647 }
8648 break;
8649 } else {
8650 /* If we've gotten here, then things are probably completely hosed,
8651 * but if the error condition is detected, it won't hurt to give
8652 * it another try...ICH_FLASH_CYCLE_REPEAT_COUNT times.
8653 */
8654 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8655 if (hsfsts.hsf_status.flcerr == 1) {
8656 /* Repeat for some time before giving up. */
8657 continue;
8658 } else if (hsfsts.hsf_status.flcdone == 0) {
8659 DEBUGOUT("Timeout error - flash cycle did not complete.");
8660 break;
8661 }
8662 }
8663 } while (count++ < ICH_FLASH_CYCLE_REPEAT_COUNT);
8664
8665 return error;
8666 }
8667
8668 /******************************************************************************
8669 * Writes One /two bytes to the NVM using the ICH8 flash access registers.
8670 *
8671 * hw - The pointer to the hw structure
8672 * index - The index of the byte/word to read.
8673 * size - Size of data to read, 1=byte 2=word
8674 * data - The byte(s) to write to the NVM.
8675 *****************************************************************************/
8676 static int32_t
8677 e1000_write_ich8_data(struct e1000_hw *hw, uint32_t index, uint32_t size,
8678 uint16_t data)
8679 {
8680 union ich8_hws_flash_status hsfsts;
8681 union ich8_hws_flash_ctrl hsflctl;
8682 uint32_t flash_linear_address;
8683 uint32_t flash_data = 0;
8684 int32_t error = -E1000_ERR_EEPROM;
8685 int32_t count = 0;
8686
8687 DEBUGFUNC("e1000_write_ich8_data");
8688
8689 if (size < 1 || size > 2 || data > size * 0xff ||
8690 index > ICH_FLASH_LINEAR_ADDR_MASK)
8691 return error;
8692
8693 flash_linear_address = (ICH_FLASH_LINEAR_ADDR_MASK & index) +
8694 hw->flash_base_addr;
8695
8696 do {
8697 udelay(1);
8698 /* Steps */
8699 error = e1000_ich8_cycle_init(hw);
8700 if (error != E1000_SUCCESS)
8701 break;
8702
8703 hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8704 /* 0b/1b corresponds to 1 or 2 byte size, respectively. */
8705 hsflctl.hsf_ctrl.fldbcount = size -1;
8706 hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_WRITE;
8707 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8708
8709 /* Write the last 24 bits of index into Flash Linear address field in
8710 * Flash Address */
8711 E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8712
8713 if (size == 1)
8714 flash_data = (uint32_t)data & 0x00FF;
8715 else
8716 flash_data = (uint32_t)data;
8717
8718 E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FDATA0, flash_data);
8719
8720 /* check if FCERR is set to 1 , if set to 1, clear it and try the whole
8721 * sequence a few more times else done */
8722 error = e1000_ich8_flash_cycle(hw, ICH_FLASH_COMMAND_TIMEOUT);
8723 if (error == E1000_SUCCESS) {
8724 break;
8725 } else {
8726 /* If we're here, then things are most likely completely hosed,
8727 * but if the error condition is detected, it won't hurt to give
8728 * it another try...ICH_FLASH_CYCLE_REPEAT_COUNT times.
8729 */
8730 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8731 if (hsfsts.hsf_status.flcerr == 1) {
8732 /* Repeat for some time before giving up. */
8733 continue;
8734 } else if (hsfsts.hsf_status.flcdone == 0) {
8735 DEBUGOUT("Timeout error - flash cycle did not complete.");
8736 break;
8737 }
8738 }
8739 } while (count++ < ICH_FLASH_CYCLE_REPEAT_COUNT);
8740
8741 return error;
8742 }
8743
8744 /******************************************************************************
8745 * Reads a single byte from the NVM using the ICH8 flash access registers.
8746 *
8747 * hw - pointer to e1000_hw structure
8748 * index - The index of the byte to read.
8749 * data - Pointer to a byte to store the value read.
8750 *****************************************************************************/
8751 static int32_t
8752 e1000_read_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t* data)
8753 {
8754 int32_t status = E1000_SUCCESS;
8755 uint16_t word = 0;
8756
8757 status = e1000_read_ich8_data(hw, index, 1, &word);
8758 if (status == E1000_SUCCESS) {
8759 *data = (uint8_t)word;
8760 }
8761
8762 return status;
8763 }
8764
8765 /******************************************************************************
8766 * Writes a single byte to the NVM using the ICH8 flash access registers.
8767 * Performs verification by reading back the value and then going through
8768 * a retry algorithm before giving up.
8769 *
8770 * hw - pointer to e1000_hw structure
8771 * index - The index of the byte to write.
8772 * byte - The byte to write to the NVM.
8773 *****************************************************************************/
8774 static int32_t
8775 e1000_verify_write_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t byte)
8776 {
8777 int32_t error = E1000_SUCCESS;
8778 int32_t program_retries = 0;
8779
8780 DEBUGOUT2("Byte := %2.2X Offset := %d\n", byte, index);
8781
8782 error = e1000_write_ich8_byte(hw, index, byte);
8783
8784 if (error != E1000_SUCCESS) {
8785 for (program_retries = 0; program_retries < 100; program_retries++) {
8786 DEBUGOUT2("Retrying \t Byte := %2.2X Offset := %d\n", byte, index);
8787 error = e1000_write_ich8_byte(hw, index, byte);
8788 udelay(100);
8789 if (error == E1000_SUCCESS)
8790 break;
8791 }
8792 }
8793
8794 if (program_retries == 100)
8795 error = E1000_ERR_EEPROM;
8796
8797 return error;
8798 }
8799
8800 /******************************************************************************
8801 * Writes a single byte to the NVM using the ICH8 flash access registers.
8802 *
8803 * hw - pointer to e1000_hw structure
8804 * index - The index of the byte to read.
8805 * data - The byte to write to the NVM.
8806 *****************************************************************************/
8807 static int32_t
8808 e1000_write_ich8_byte(struct e1000_hw *hw, uint32_t index, uint8_t data)
8809 {
8810 int32_t status = E1000_SUCCESS;
8811 uint16_t word = (uint16_t)data;
8812
8813 status = e1000_write_ich8_data(hw, index, 1, word);
8814
8815 return status;
8816 }
8817
8818 /******************************************************************************
8819 * Reads a word from the NVM using the ICH8 flash access registers.
8820 *
8821 * hw - pointer to e1000_hw structure
8822 * index - The starting byte index of the word to read.
8823 * data - Pointer to a word to store the value read.
8824 *****************************************************************************/
8825 static int32_t
8826 e1000_read_ich8_word(struct e1000_hw *hw, uint32_t index, uint16_t *data)
8827 {
8828 int32_t status = E1000_SUCCESS;
8829 status = e1000_read_ich8_data(hw, index, 2, data);
8830 return status;
8831 }
8832
8833 /******************************************************************************
8834 * Erases the bank specified. Each bank may be a 4, 8 or 64k block. Banks are 0
8835 * based.
8836 *
8837 * hw - pointer to e1000_hw structure
8838 * bank - 0 for first bank, 1 for second bank
8839 *
8840 * Note that this function may actually erase as much as 8 or 64 KBytes. The
8841 * amount of NVM used in each bank is a *minimum* of 4 KBytes, but in fact the
8842 * bank size may be 4, 8 or 64 KBytes
8843 *****************************************************************************/
8844 static int32_t
8845 e1000_erase_ich8_4k_segment(struct e1000_hw *hw, uint32_t bank)
8846 {
8847 union ich8_hws_flash_status hsfsts;
8848 union ich8_hws_flash_ctrl hsflctl;
8849 uint32_t flash_linear_address;
8850 int32_t count = 0;
8851 int32_t error = E1000_ERR_EEPROM;
8852 int32_t iteration;
8853 int32_t sub_sector_size = 0;
8854 int32_t bank_size;
8855 int32_t j = 0;
8856 int32_t error_flag = 0;
8857
8858 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8859
8860 /* Determine HW Sector size: Read BERASE bits of Hw flash Status register */
8861 /* 00: The Hw sector is 256 bytes, hence we need to erase 16
8862 * consecutive sectors. The start index for the nth Hw sector can be
8863 * calculated as bank * 4096 + n * 256
8864 * 01: The Hw sector is 4K bytes, hence we need to erase 1 sector.
8865 * The start index for the nth Hw sector can be calculated
8866 * as bank * 4096
8867 * 10: The HW sector is 8K bytes
8868 * 11: The Hw sector size is 64K bytes */
8869 if (hsfsts.hsf_status.berasesz == 0x0) {
8870 /* Hw sector size 256 */
8871 sub_sector_size = ICH_FLASH_SEG_SIZE_256;
8872 bank_size = ICH_FLASH_SECTOR_SIZE;
8873 iteration = ICH_FLASH_SECTOR_SIZE / ICH_FLASH_SEG_SIZE_256;
8874 } else if (hsfsts.hsf_status.berasesz == 0x1) {
8875 bank_size = ICH_FLASH_SEG_SIZE_4K;
8876 iteration = 1;
8877 } else if (hsfsts.hsf_status.berasesz == 0x3) {
8878 bank_size = ICH_FLASH_SEG_SIZE_64K;
8879 iteration = 1;
8880 } else {
8881 return error;
8882 }
8883
8884 for (j = 0; j < iteration ; j++) {
8885 do {
8886 count++;
8887 /* Steps */
8888 error = e1000_ich8_cycle_init(hw);
8889 if (error != E1000_SUCCESS) {
8890 error_flag = 1;
8891 break;
8892 }
8893
8894 /* Write a value 11 (block Erase) in Flash Cycle field in Hw flash
8895 * Control */
8896 hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8897 hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_ERASE;
8898 E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8899
8900 /* Write the last 24 bits of an index within the block into Flash
8901 * Linear address field in Flash Address. This probably needs to
8902 * be calculated here based off the on-chip erase sector size and
8903 * the software bank size (4, 8 or 64 KBytes) */
8904 flash_linear_address = bank * bank_size + j * sub_sector_size;
8905 flash_linear_address += hw->flash_base_addr;
8906 flash_linear_address &= ICH_FLASH_LINEAR_ADDR_MASK;
8907
8908 E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8909
8910 error = e1000_ich8_flash_cycle(hw, ICH_FLASH_ERASE_TIMEOUT);
8911 /* Check if FCERR is set to 1. If 1, clear it and try the whole
8912 * sequence a few more times else Done */
8913 if (error == E1000_SUCCESS) {
8914 break;
8915 } else {
8916 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8917 if (hsfsts.hsf_status.flcerr == 1) {
8918 /* repeat for some time before giving up */
8919 continue;
8920 } else if (hsfsts.hsf_status.flcdone == 0) {
8921 error_flag = 1;
8922 break;
8923 }
8924 }
8925 } while ((count < ICH_FLASH_CYCLE_REPEAT_COUNT) && !error_flag);
8926 if (error_flag == 1)
8927 break;
8928 }
8929 if (error_flag != 1)
8930 error = E1000_SUCCESS;
8931 return error;
8932 }
8933
8934 static int32_t
8935 e1000_init_lcd_from_nvm_config_region(struct e1000_hw *hw,
8936 uint32_t cnf_base_addr, uint32_t cnf_size)
8937 {
8938 uint32_t ret_val = E1000_SUCCESS;
8939 uint16_t word_addr, reg_data, reg_addr;
8940 uint16_t i;
8941
8942 /* cnf_base_addr is in DWORD */
8943 word_addr = (uint16_t)(cnf_base_addr << 1);
8944
8945 /* cnf_size is returned in size of dwords */
8946 for (i = 0; i < cnf_size; i++) {
8947 ret_val = e1000_read_eeprom(hw, (word_addr + i*2), 1, &reg_data);
8948 if (ret_val)
8949 return ret_val;
8950
8951 ret_val = e1000_read_eeprom(hw, (word_addr + i*2 + 1), 1, &reg_addr);
8952 if (ret_val)
8953 return ret_val;
8954
8955 ret_val = e1000_get_software_flag(hw);
8956 if (ret_val != E1000_SUCCESS)
8957 return ret_val;
8958
8959 ret_val = e1000_write_phy_reg_ex(hw, (uint32_t)reg_addr, reg_data);
8960
8961 e1000_release_software_flag(hw);
8962 }
8963
8964 return ret_val;
8965 }
8966
8967
8968 /******************************************************************************
8969 * This function initializes the PHY from the NVM on ICH8 platforms. This
8970 * is needed due to an issue where the NVM configuration is not properly
8971 * autoloaded after power transitions. Therefore, after each PHY reset, we
8972 * will load the configuration data out of the NVM manually.
8973 *
8974 * hw: Struct containing variables accessed by shared code
8975 *****************************************************************************/
8976 static int32_t
8977 e1000_init_lcd_from_nvm(struct e1000_hw *hw)
8978 {
8979 uint32_t reg_data, cnf_base_addr, cnf_size, ret_val, loop;
8980
8981 if (hw->phy_type != e1000_phy_igp_3)
8982 return E1000_SUCCESS;
8983
8984 /* Check if SW needs configure the PHY */
8985 reg_data = E1000_READ_REG(hw, FEXTNVM);
8986 if (!(reg_data & FEXTNVM_SW_CONFIG))
8987 return E1000_SUCCESS;
8988
8989 /* Wait for basic configuration completes before proceeding*/
8990 loop = 0;
8991 do {
8992 reg_data = E1000_READ_REG(hw, STATUS) & E1000_STATUS_LAN_INIT_DONE;
8993 udelay(100);
8994 loop++;
8995 } while ((!reg_data) && (loop < 50));
8996
8997 /* Clear the Init Done bit for the next init event */
8998 reg_data = E1000_READ_REG(hw, STATUS);
8999 reg_data &= ~E1000_STATUS_LAN_INIT_DONE;
9000 E1000_WRITE_REG(hw, STATUS, reg_data);
9001
9002 /* Make sure HW does not configure LCD from PHY extended configuration
9003 before SW configuration */
9004 reg_data = E1000_READ_REG(hw, EXTCNF_CTRL);
9005 if ((reg_data & E1000_EXTCNF_CTRL_LCD_WRITE_ENABLE) == 0x0000) {
9006 reg_data = E1000_READ_REG(hw, EXTCNF_SIZE);
9007 cnf_size = reg_data & E1000_EXTCNF_SIZE_EXT_PCIE_LENGTH;
9008 cnf_size >>= 16;
9009 if (cnf_size) {
9010 reg_data = E1000_READ_REG(hw, EXTCNF_CTRL);
9011 cnf_base_addr = reg_data & E1000_EXTCNF_CTRL_EXT_CNF_POINTER;
9012 /* cnf_base_addr is in DWORD */
9013 cnf_base_addr >>= 16;
9014
9015 /* Configure LCD from extended configuration region. */
9016 ret_val = e1000_init_lcd_from_nvm_config_region(hw, cnf_base_addr,
9017 cnf_size);
9018 if (ret_val)
9019 return ret_val;
9020 }
9021 }
9022
9023 return E1000_SUCCESS;
9024 }
9025
WRT350N Kernel Patches