?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
IPVS: fix netns if reading ip_vs_* procfs entries
[linux-2.6/linux-mips.git] / drivers / net / e1000 / e1000_hw.c
blob7501d977d992ae142f5b7b078be2d1bebce9c247
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 #include "e1000.h"
34
35 static s32 e1000_check_downshift(struct e1000_hw *hw);
36 static s32 e1000_check_polarity(struct e1000_hw *hw,
37 e1000_rev_polarity *polarity);
38 static void e1000_clear_hw_cntrs(struct e1000_hw *hw);
39 static void e1000_clear_vfta(struct e1000_hw *hw);
40 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw,
41 bool link_up);
42 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw);
43 static s32 e1000_detect_gig_phy(struct e1000_hw *hw);
44 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw);
45 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
46 u16 *max_length);
47 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
48 static s32 e1000_id_led_init(struct e1000_hw *hw);
49 static void e1000_init_rx_addrs(struct e1000_hw *hw);
50 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
51 struct e1000_phy_info *phy_info);
52 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
53 struct e1000_phy_info *phy_info);
54 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
55 static s32 e1000_wait_autoneg(struct e1000_hw *hw);
56 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value);
57 static s32 e1000_set_phy_type(struct e1000_hw *hw);
58 static void e1000_phy_init_script(struct e1000_hw *hw);
59 static s32 e1000_setup_copper_link(struct e1000_hw *hw);
60 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw);
61 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw);
62 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);
63 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw);
64 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
65 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
66 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data, u16 count);
67 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw);
68 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw);
69 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset,
70 u16 words, u16 *data);
71 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
72 u16 words, u16 *data);
73 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw);
74 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd);
75 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd);
76 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count);
77 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
78 u16 phy_data);
79 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
80 u16 *phy_data);
81 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count);
82 static s32 e1000_acquire_eeprom(struct e1000_hw *hw);
83 static void e1000_release_eeprom(struct e1000_hw *hw);
84 static void e1000_standby_eeprom(struct e1000_hw *hw);
85 static s32 e1000_set_vco_speed(struct e1000_hw *hw);
86 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw);
87 static s32 e1000_set_phy_mode(struct e1000_hw *hw);
88 static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
89 u16 *data);
90 static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
91 u16 *data);
92
93 /* IGP cable length table */
94 static const
95 u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] = {
96 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
97 5, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 25, 25, 25,
98 25, 25, 25, 25, 30, 30, 30, 30, 40, 40, 40, 40, 40, 40, 40, 40,
99 40, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60,
100 60, 70, 70, 70, 70, 70, 70, 80, 80, 80, 80, 80, 80, 90, 90, 90,
101 90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 100, 100, 100,
102 100,
103 100, 100, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
104 110, 110,
105 110, 110, 110, 110, 110, 110, 120, 120, 120, 120, 120, 120, 120, 120,
106 120, 120
107 };
108
109 static DEFINE_SPINLOCK(e1000_eeprom_lock);
110
111 /**
112 * e1000_set_phy_type - Set the phy type member in the hw struct.
113 * @hw: Struct containing variables accessed by shared code
114 */
115 static s32 e1000_set_phy_type(struct e1000_hw *hw)
116 {
117 e_dbg("e1000_set_phy_type");
118
119 if (hw->mac_type == e1000_undefined)
120 return -E1000_ERR_PHY_TYPE;
121
122 switch (hw->phy_id) {
123 case M88E1000_E_PHY_ID:
124 case M88E1000_I_PHY_ID:
125 case M88E1011_I_PHY_ID:
126 case M88E1111_I_PHY_ID:
127 case M88E1118_E_PHY_ID:
128 hw->phy_type = e1000_phy_m88;
129 break;
130 case IGP01E1000_I_PHY_ID:
131 if (hw->mac_type == e1000_82541 ||
132 hw->mac_type == e1000_82541_rev_2 ||
133 hw->mac_type == e1000_82547 ||
134 hw->mac_type == e1000_82547_rev_2)
135 hw->phy_type = e1000_phy_igp;
136 break;
137 case RTL8211B_PHY_ID:
138 hw->phy_type = e1000_phy_8211;
139 break;
140 case RTL8201N_PHY_ID:
141 hw->phy_type = e1000_phy_8201;
142 break;
143 default:
144 /* Should never have loaded on this device */
145 hw->phy_type = e1000_phy_undefined;
146 return -E1000_ERR_PHY_TYPE;
147 }
148
149 return E1000_SUCCESS;
150 }
151
152 /**
153 * e1000_phy_init_script - IGP phy init script - initializes the GbE PHY
154 * @hw: Struct containing variables accessed by shared code
155 */
156 static void e1000_phy_init_script(struct e1000_hw *hw)
157 {
158 u32 ret_val;
159 u16 phy_saved_data;
160
161 e_dbg("e1000_phy_init_script");
162
163 if (hw->phy_init_script) {
164 msleep(20);
165
166 /* Save off the current value of register 0x2F5B to be restored at
167 * the end of this routine. */
168 ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
169
170 /* Disabled the PHY transmitter */
171 e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
172 msleep(20);
173
174 e1000_write_phy_reg(hw, 0x0000, 0x0140);
175 msleep(5);
176
177 switch (hw->mac_type) {
178 case e1000_82541:
179 case e1000_82547:
180 e1000_write_phy_reg(hw, 0x1F95, 0x0001);
181 e1000_write_phy_reg(hw, 0x1F71, 0xBD21);
182 e1000_write_phy_reg(hw, 0x1F79, 0x0018);
183 e1000_write_phy_reg(hw, 0x1F30, 0x1600);
184 e1000_write_phy_reg(hw, 0x1F31, 0x0014);
185 e1000_write_phy_reg(hw, 0x1F32, 0x161C);
186 e1000_write_phy_reg(hw, 0x1F94, 0x0003);
187 e1000_write_phy_reg(hw, 0x1F96, 0x003F);
188 e1000_write_phy_reg(hw, 0x2010, 0x0008);
189 break;
190
191 case e1000_82541_rev_2:
192 case e1000_82547_rev_2:
193 e1000_write_phy_reg(hw, 0x1F73, 0x0099);
194 break;
195 default:
196 break;
197 }
198
199 e1000_write_phy_reg(hw, 0x0000, 0x3300);
200 msleep(20);
201
202 /* Now enable the transmitter */
203 e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
204
205 if (hw->mac_type == e1000_82547) {
206 u16 fused, fine, coarse;
207
208 /* Move to analog registers page */
209 e1000_read_phy_reg(hw,
210 IGP01E1000_ANALOG_SPARE_FUSE_STATUS,
211 &fused);
212
213 if (!(fused & IGP01E1000_ANALOG_SPARE_FUSE_ENABLED)) {
214 e1000_read_phy_reg(hw,
215 IGP01E1000_ANALOG_FUSE_STATUS,
216 &fused);
217
218 fine = fused & IGP01E1000_ANALOG_FUSE_FINE_MASK;
219 coarse =
220 fused & IGP01E1000_ANALOG_FUSE_COARSE_MASK;
221
222 if (coarse >
223 IGP01E1000_ANALOG_FUSE_COARSE_THRESH) {
224 coarse -=
225 IGP01E1000_ANALOG_FUSE_COARSE_10;
226 fine -= IGP01E1000_ANALOG_FUSE_FINE_1;
227 } else if (coarse ==
228 IGP01E1000_ANALOG_FUSE_COARSE_THRESH)
229 fine -= IGP01E1000_ANALOG_FUSE_FINE_10;
230
231 fused =
232 (fused & IGP01E1000_ANALOG_FUSE_POLY_MASK) |
233 (fine & IGP01E1000_ANALOG_FUSE_FINE_MASK) |
234 (coarse &
235 IGP01E1000_ANALOG_FUSE_COARSE_MASK);
236
237 e1000_write_phy_reg(hw,
238 IGP01E1000_ANALOG_FUSE_CONTROL,
239 fused);
240 e1000_write_phy_reg(hw,
241 IGP01E1000_ANALOG_FUSE_BYPASS,
242 IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL);
243 }
244 }
245 }
246 }
247
248 /**
249 * e1000_set_mac_type - Set the mac type member in the hw struct.
250 * @hw: Struct containing variables accessed by shared code
251 */
252 s32 e1000_set_mac_type(struct e1000_hw *hw)
253 {
254 e_dbg("e1000_set_mac_type");
255
256 switch (hw->device_id) {
257 case E1000_DEV_ID_82542:
258 switch (hw->revision_id) {
259 case E1000_82542_2_0_REV_ID:
260 hw->mac_type = e1000_82542_rev2_0;
261 break;
262 case E1000_82542_2_1_REV_ID:
263 hw->mac_type = e1000_82542_rev2_1;
264 break;
265 default:
266 /* Invalid 82542 revision ID */
267 return -E1000_ERR_MAC_TYPE;
268 }
269 break;
270 case E1000_DEV_ID_82543GC_FIBER:
271 case E1000_DEV_ID_82543GC_COPPER:
272 hw->mac_type = e1000_82543;
273 break;
274 case E1000_DEV_ID_82544EI_COPPER:
275 case E1000_DEV_ID_82544EI_FIBER:
276 case E1000_DEV_ID_82544GC_COPPER:
277 case E1000_DEV_ID_82544GC_LOM:
278 hw->mac_type = e1000_82544;
279 break;
280 case E1000_DEV_ID_82540EM:
281 case E1000_DEV_ID_82540EM_LOM:
282 case E1000_DEV_ID_82540EP:
283 case E1000_DEV_ID_82540EP_LOM:
284 case E1000_DEV_ID_82540EP_LP:
285 hw->mac_type = e1000_82540;
286 break;
287 case E1000_DEV_ID_82545EM_COPPER:
288 case E1000_DEV_ID_82545EM_FIBER:
289 hw->mac_type = e1000_82545;
290 break;
291 case E1000_DEV_ID_82545GM_COPPER:
292 case E1000_DEV_ID_82545GM_FIBER:
293 case E1000_DEV_ID_82545GM_SERDES:
294 hw->mac_type = e1000_82545_rev_3;
295 break;
296 case E1000_DEV_ID_82546EB_COPPER:
297 case E1000_DEV_ID_82546EB_FIBER:
298 case E1000_DEV_ID_82546EB_QUAD_COPPER:
299 hw->mac_type = e1000_82546;
300 break;
301 case E1000_DEV_ID_82546GB_COPPER:
302 case E1000_DEV_ID_82546GB_FIBER:
303 case E1000_DEV_ID_82546GB_SERDES:
304 case E1000_DEV_ID_82546GB_PCIE:
305 case E1000_DEV_ID_82546GB_QUAD_COPPER:
306 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
307 hw->mac_type = e1000_82546_rev_3;
308 break;
309 case E1000_DEV_ID_82541EI:
310 case E1000_DEV_ID_82541EI_MOBILE:
311 case E1000_DEV_ID_82541ER_LOM:
312 hw->mac_type = e1000_82541;
313 break;
314 case E1000_DEV_ID_82541ER:
315 case E1000_DEV_ID_82541GI:
316 case E1000_DEV_ID_82541GI_LF:
317 case E1000_DEV_ID_82541GI_MOBILE:
318 hw->mac_type = e1000_82541_rev_2;
319 break;
320 case E1000_DEV_ID_82547EI:
321 case E1000_DEV_ID_82547EI_MOBILE:
322 hw->mac_type = e1000_82547;
323 break;
324 case E1000_DEV_ID_82547GI:
325 hw->mac_type = e1000_82547_rev_2;
326 break;
327 case E1000_DEV_ID_INTEL_CE4100_GBE:
328 hw->mac_type = e1000_ce4100;
329 break;
330 default:
331 /* Should never have loaded on this device */
332 return -E1000_ERR_MAC_TYPE;
333 }
334
335 switch (hw->mac_type) {
336 case e1000_82541:
337 case e1000_82547:
338 case e1000_82541_rev_2:
339 case e1000_82547_rev_2:
340 hw->asf_firmware_present = true;
341 break;
342 default:
343 break;
344 }
345
346 /* The 82543 chip does not count tx_carrier_errors properly in
347 * FD mode
348 */
349 if (hw->mac_type == e1000_82543)
350 hw->bad_tx_carr_stats_fd = true;
351
352 if (hw->mac_type > e1000_82544)
353 hw->has_smbus = true;
354
355 return E1000_SUCCESS;
356 }
357
358 /**
359 * e1000_set_media_type - Set media type and TBI compatibility.
360 * @hw: Struct containing variables accessed by shared code
361 */
362 void e1000_set_media_type(struct e1000_hw *hw)
363 {
364 u32 status;
365
366 e_dbg("e1000_set_media_type");
367
368 if (hw->mac_type != e1000_82543) {
369 /* tbi_compatibility is only valid on 82543 */
370 hw->tbi_compatibility_en = false;
371 }
372
373 switch (hw->device_id) {
374 case E1000_DEV_ID_82545GM_SERDES:
375 case E1000_DEV_ID_82546GB_SERDES:
376 hw->media_type = e1000_media_type_internal_serdes;
377 break;
378 default:
379 switch (hw->mac_type) {
380 case e1000_82542_rev2_0:
381 case e1000_82542_rev2_1:
382 hw->media_type = e1000_media_type_fiber;
383 break;
384 case e1000_ce4100:
385 hw->media_type = e1000_media_type_copper;
386 break;
387 default:
388 status = er32(STATUS);
389 if (status & E1000_STATUS_TBIMODE) {
390 hw->media_type = e1000_media_type_fiber;
391 /* tbi_compatibility not valid on fiber */
392 hw->tbi_compatibility_en = false;
393 } else {
394 hw->media_type = e1000_media_type_copper;
395 }
396 break;
397 }
398 }
399 }
400
401 /**
402 * e1000_reset_hw: reset the hardware completely
403 * @hw: Struct containing variables accessed by shared code
404 *
405 * Reset the transmit and receive units; mask and clear all interrupts.
406 */
407 s32 e1000_reset_hw(struct e1000_hw *hw)
408 {
409 u32 ctrl;
410 u32 ctrl_ext;
411 u32 icr;
412 u32 manc;
413 u32 led_ctrl;
414 s32 ret_val;
415
416 e_dbg("e1000_reset_hw");
417
418 /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
419 if (hw->mac_type == e1000_82542_rev2_0) {
420 e_dbg("Disabling MWI on 82542 rev 2.0\n");
421 e1000_pci_clear_mwi(hw);
422 }
423
424 /* Clear interrupt mask to stop board from generating interrupts */
425 e_dbg("Masking off all interrupts\n");
426 ew32(IMC, 0xffffffff);
427
428 /* Disable the Transmit and Receive units. Then delay to allow
429 * any pending transactions to complete before we hit the MAC with
430 * the global reset.
431 */
432 ew32(RCTL, 0);
433 ew32(TCTL, E1000_TCTL_PSP);
434 E1000_WRITE_FLUSH();
435
436 /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
437 hw->tbi_compatibility_on = false;
438
439 /* Delay to allow any outstanding PCI transactions to complete before
440 * resetting the device
441 */
442 msleep(10);
443
444 ctrl = er32(CTRL);
445
446 /* Must reset the PHY before resetting the MAC */
447 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
448 ew32(CTRL, (ctrl | E1000_CTRL_PHY_RST));
449 msleep(5);
450 }
451
452 /* Issue a global reset to the MAC. This will reset the chip's
453 * transmit, receive, DMA, and link units. It will not effect
454 * the current PCI configuration. The global reset bit is self-
455 * clearing, and should clear within a microsecond.
456 */
457 e_dbg("Issuing a global reset to MAC\n");
458
459 switch (hw->mac_type) {
460 case e1000_82544:
461 case e1000_82540:
462 case e1000_82545:
463 case e1000_82546:
464 case e1000_82541:
465 case e1000_82541_rev_2:
466 /* These controllers can't ack the 64-bit write when issuing the
467 * reset, so use IO-mapping as a workaround to issue the reset */
468 E1000_WRITE_REG_IO(hw, CTRL, (ctrl | E1000_CTRL_RST));
469 break;
470 case e1000_82545_rev_3:
471 case e1000_82546_rev_3:
472 /* Reset is performed on a shadow of the control register */
473 ew32(CTRL_DUP, (ctrl | E1000_CTRL_RST));
474 break;
475 case e1000_ce4100:
476 default:
477 ew32(CTRL, (ctrl | E1000_CTRL_RST));
478 break;
479 }
480
481 /* After MAC reset, force reload of EEPROM to restore power-on settings to
482 * device. Later controllers reload the EEPROM automatically, so just wait
483 * for reload to complete.
484 */
485 switch (hw->mac_type) {
486 case e1000_82542_rev2_0:
487 case e1000_82542_rev2_1:
488 case e1000_82543:
489 case e1000_82544:
490 /* Wait for reset to complete */
491 udelay(10);
492 ctrl_ext = er32(CTRL_EXT);
493 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
494 ew32(CTRL_EXT, ctrl_ext);
495 E1000_WRITE_FLUSH();
496 /* Wait for EEPROM reload */
497 msleep(2);
498 break;
499 case e1000_82541:
500 case e1000_82541_rev_2:
501 case e1000_82547:
502 case e1000_82547_rev_2:
503 /* Wait for EEPROM reload */
504 msleep(20);
505 break;
506 default:
507 /* Auto read done will delay 5ms or poll based on mac type */
508 ret_val = e1000_get_auto_rd_done(hw);
509 if (ret_val)
510 return ret_val;
511 break;
512 }
513
514 /* Disable HW ARPs on ASF enabled adapters */
515 if (hw->mac_type >= e1000_82540) {
516 manc = er32(MANC);
517 manc &= ~(E1000_MANC_ARP_EN);
518 ew32(MANC, manc);
519 }
520
521 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
522 e1000_phy_init_script(hw);
523
524 /* Configure activity LED after PHY reset */
525 led_ctrl = er32(LEDCTL);
526 led_ctrl &= IGP_ACTIVITY_LED_MASK;
527 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
528 ew32(LEDCTL, led_ctrl);
529 }
530
531 /* Clear interrupt mask to stop board from generating interrupts */
532 e_dbg("Masking off all interrupts\n");
533 ew32(IMC, 0xffffffff);
534
535 /* Clear any pending interrupt events. */
536 icr = er32(ICR);
537
538 /* If MWI was previously enabled, reenable it. */
539 if (hw->mac_type == e1000_82542_rev2_0) {
540 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
541 e1000_pci_set_mwi(hw);
542 }
543
544 return E1000_SUCCESS;
545 }
546
547 /**
548 * e1000_init_hw: Performs basic configuration of the adapter.
549 * @hw: Struct containing variables accessed by shared code
550 *
551 * Assumes that the controller has previously been reset and is in a
552 * post-reset uninitialized state. Initializes the receive address registers,
553 * multicast table, and VLAN filter table. Calls routines to setup link
554 * configuration and flow control settings. Clears all on-chip counters. Leaves
555 * the transmit and receive units disabled and uninitialized.
556 */
557 s32 e1000_init_hw(struct e1000_hw *hw)
558 {
559 u32 ctrl;
560 u32 i;
561 s32 ret_val;
562 u32 mta_size;
563 u32 ctrl_ext;
564
565 e_dbg("e1000_init_hw");
566
567 /* Initialize Identification LED */
568 ret_val = e1000_id_led_init(hw);
569 if (ret_val) {
570 e_dbg("Error Initializing Identification LED\n");
571 return ret_val;
572 }
573
574 /* Set the media type and TBI compatibility */
575 e1000_set_media_type(hw);
576
577 /* Disabling VLAN filtering. */
578 e_dbg("Initializing the IEEE VLAN\n");
579 if (hw->mac_type < e1000_82545_rev_3)
580 ew32(VET, 0);
581 e1000_clear_vfta(hw);
582
583 /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
584 if (hw->mac_type == e1000_82542_rev2_0) {
585 e_dbg("Disabling MWI on 82542 rev 2.0\n");
586 e1000_pci_clear_mwi(hw);
587 ew32(RCTL, E1000_RCTL_RST);
588 E1000_WRITE_FLUSH();
589 msleep(5);
590 }
591
592 /* Setup the receive address. This involves initializing all of the Receive
593 * Address Registers (RARs 0 - 15).
594 */
595 e1000_init_rx_addrs(hw);
596
597 /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
598 if (hw->mac_type == e1000_82542_rev2_0) {
599 ew32(RCTL, 0);
600 E1000_WRITE_FLUSH();
601 msleep(1);
602 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
603 e1000_pci_set_mwi(hw);
604 }
605
606 /* Zero out the Multicast HASH table */
607 e_dbg("Zeroing the MTA\n");
608 mta_size = E1000_MC_TBL_SIZE;
609 for (i = 0; i < mta_size; i++) {
610 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
611 /* use write flush to prevent Memory Write Block (MWB) from
612 * occurring when accessing our register space */
613 E1000_WRITE_FLUSH();
614 }
615
616 /* Set the PCI priority bit correctly in the CTRL register. This
617 * determines if the adapter gives priority to receives, or if it
618 * gives equal priority to transmits and receives. Valid only on
619 * 82542 and 82543 silicon.
620 */
621 if (hw->dma_fairness && hw->mac_type <= e1000_82543) {
622 ctrl = er32(CTRL);
623 ew32(CTRL, ctrl | E1000_CTRL_PRIOR);
624 }
625
626 switch (hw->mac_type) {
627 case e1000_82545_rev_3:
628 case e1000_82546_rev_3:
629 break;
630 default:
631 /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
632 if (hw->bus_type == e1000_bus_type_pcix
633 && e1000_pcix_get_mmrbc(hw) > 2048)
634 e1000_pcix_set_mmrbc(hw, 2048);
635 break;
636 }
637
638 /* Call a subroutine to configure the link and setup flow control. */
639 ret_val = e1000_setup_link(hw);
640
641 /* Set the transmit descriptor write-back policy */
642 if (hw->mac_type > e1000_82544) {
643 ctrl = er32(TXDCTL);
644 ctrl =
645 (ctrl & ~E1000_TXDCTL_WTHRESH) |
646 E1000_TXDCTL_FULL_TX_DESC_WB;
647 ew32(TXDCTL, ctrl);
648 }
649
650 /* Clear all of the statistics registers (clear on read). It is
651 * important that we do this after we have tried to establish link
652 * because the symbol error count will increment wildly if there
653 * is no link.
654 */
655 e1000_clear_hw_cntrs(hw);
656
657 if (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER ||
658 hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3) {
659 ctrl_ext = er32(CTRL_EXT);
660 /* Relaxed ordering must be disabled to avoid a parity
661 * error crash in a PCI slot. */
662 ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
663 ew32(CTRL_EXT, ctrl_ext);
664 }
665
666 return ret_val;
667 }
668
669 /**
670 * e1000_adjust_serdes_amplitude - Adjust SERDES output amplitude based on EEPROM setting.
671 * @hw: Struct containing variables accessed by shared code.
672 */
673 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
674 {
675 u16 eeprom_data;
676 s32 ret_val;
677
678 e_dbg("e1000_adjust_serdes_amplitude");
679
680 if (hw->media_type != e1000_media_type_internal_serdes)
681 return E1000_SUCCESS;
682
683 switch (hw->mac_type) {
684 case e1000_82545_rev_3:
685 case e1000_82546_rev_3:
686 break;
687 default:
688 return E1000_SUCCESS;
689 }
690
691 ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1,
692 &eeprom_data);
693 if (ret_val) {
694 return ret_val;
695 }
696
697 if (eeprom_data != EEPROM_RESERVED_WORD) {
698 /* Adjust SERDES output amplitude only. */
699 eeprom_data &= EEPROM_SERDES_AMPLITUDE_MASK;
700 ret_val =
701 e1000_write_phy_reg(hw, M88E1000_PHY_EXT_CTRL, eeprom_data);
702 if (ret_val)
703 return ret_val;
704 }
705
706 return E1000_SUCCESS;
707 }
708
709 /**
710 * e1000_setup_link - Configures flow control and link settings.
711 * @hw: Struct containing variables accessed by shared code
712 *
713 * Determines which flow control settings to use. Calls the appropriate media-
714 * specific link configuration function. Configures the flow control settings.
715 * Assuming the adapter has a valid link partner, a valid link should be
716 * established. Assumes the hardware has previously been reset and the
717 * transmitter and receiver are not enabled.
718 */
719 s32 e1000_setup_link(struct e1000_hw *hw)
720 {
721 u32 ctrl_ext;
722 s32 ret_val;
723 u16 eeprom_data;
724
725 e_dbg("e1000_setup_link");
726
727 /* Read and store word 0x0F of the EEPROM. This word contains bits
728 * that determine the hardware's default PAUSE (flow control) mode,
729 * a bit that determines whether the HW defaults to enabling or
730 * disabling auto-negotiation, and the direction of the
731 * SW defined pins. If there is no SW over-ride of the flow
732 * control setting, then the variable hw->fc will
733 * be initialized based on a value in the EEPROM.
734 */
735 if (hw->fc == E1000_FC_DEFAULT) {
736 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
737 1, &eeprom_data);
738 if (ret_val) {
739 e_dbg("EEPROM Read Error\n");
740 return -E1000_ERR_EEPROM;
741 }
742 if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0)
743 hw->fc = E1000_FC_NONE;
744 else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) ==
745 EEPROM_WORD0F_ASM_DIR)
746 hw->fc = E1000_FC_TX_PAUSE;
747 else
748 hw->fc = E1000_FC_FULL;
749 }
750
751 /* We want to save off the original Flow Control configuration just
752 * in case we get disconnected and then reconnected into a different
753 * hub or switch with different Flow Control capabilities.
754 */
755 if (hw->mac_type == e1000_82542_rev2_0)
756 hw->fc &= (~E1000_FC_TX_PAUSE);
757
758 if ((hw->mac_type < e1000_82543) && (hw->report_tx_early == 1))
759 hw->fc &= (~E1000_FC_RX_PAUSE);
760
761 hw->original_fc = hw->fc;
762
763 e_dbg("After fix-ups FlowControl is now = %x\n", hw->fc);
764
765 /* Take the 4 bits from EEPROM word 0x0F that determine the initial
766 * polarity value for the SW controlled pins, and setup the
767 * Extended Device Control reg with that info.
768 * This is needed because one of the SW controlled pins is used for
769 * signal detection. So this should be done before e1000_setup_pcs_link()
770 * or e1000_phy_setup() is called.
771 */
772 if (hw->mac_type == e1000_82543) {
773 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
774 1, &eeprom_data);
775 if (ret_val) {
776 e_dbg("EEPROM Read Error\n");
777 return -E1000_ERR_EEPROM;
778 }
779 ctrl_ext = ((eeprom_data & EEPROM_WORD0F_SWPDIO_EXT) <<
780 SWDPIO__EXT_SHIFT);
781 ew32(CTRL_EXT, ctrl_ext);
782 }
783
784 /* Call the necessary subroutine to configure the link. */
785 ret_val = (hw->media_type == e1000_media_type_copper) ?
786 e1000_setup_copper_link(hw) : e1000_setup_fiber_serdes_link(hw);
787
788 /* Initialize the flow control address, type, and PAUSE timer
789 * registers to their default values. This is done even if flow
790 * control is disabled, because it does not hurt anything to
791 * initialize these registers.
792 */
793 e_dbg("Initializing the Flow Control address, type and timer regs\n");
794
795 ew32(FCT, FLOW_CONTROL_TYPE);
796 ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
797 ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
798
799 ew32(FCTTV, hw->fc_pause_time);
800
801 /* Set the flow control receive threshold registers. Normally,
802 * these registers will be set to a default threshold that may be
803 * adjusted later by the driver's runtime code. However, if the
804 * ability to transmit pause frames in not enabled, then these
805 * registers will be set to 0.
806 */
807 if (!(hw->fc & E1000_FC_TX_PAUSE)) {
808 ew32(FCRTL, 0);
809 ew32(FCRTH, 0);
810 } else {
811 /* We need to set up the Receive Threshold high and low water marks
812 * as well as (optionally) enabling the transmission of XON frames.
813 */
814 if (hw->fc_send_xon) {
815 ew32(FCRTL, (hw->fc_low_water | E1000_FCRTL_XONE));
816 ew32(FCRTH, hw->fc_high_water);
817 } else {
818 ew32(FCRTL, hw->fc_low_water);
819 ew32(FCRTH, hw->fc_high_water);
820 }
821 }
822 return ret_val;
823 }
824
825 /**
826 * e1000_setup_fiber_serdes_link - prepare fiber or serdes link
827 * @hw: Struct containing variables accessed by shared code
828 *
829 * Manipulates Physical Coding Sublayer functions in order to configure
830 * link. Assumes the hardware has been previously reset and the transmitter
831 * and receiver are not enabled.
832 */
833 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
834 {
835 u32 ctrl;
836 u32 status;
837 u32 txcw = 0;
838 u32 i;
839 u32 signal = 0;
840 s32 ret_val;
841
842 e_dbg("e1000_setup_fiber_serdes_link");
843
844 /* On adapters with a MAC newer than 82544, SWDP 1 will be
845 * set when the optics detect a signal. On older adapters, it will be
846 * cleared when there is a signal. This applies to fiber media only.
847 * If we're on serdes media, adjust the output amplitude to value
848 * set in the EEPROM.
849 */
850 ctrl = er32(CTRL);
851 if (hw->media_type == e1000_media_type_fiber)
852 signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
853
854 ret_val = e1000_adjust_serdes_amplitude(hw);
855 if (ret_val)
856 return ret_val;
857
858 /* Take the link out of reset */
859 ctrl &= ~(E1000_CTRL_LRST);
860
861 /* Adjust VCO speed to improve BER performance */
862 ret_val = e1000_set_vco_speed(hw);
863 if (ret_val)
864 return ret_val;
865
866 e1000_config_collision_dist(hw);
867
868 /* Check for a software override of the flow control settings, and setup
869 * the device accordingly. If auto-negotiation is enabled, then software
870 * will have to set the "PAUSE" bits to the correct value in the Tranmsit
871 * Config Word Register (TXCW) and re-start auto-negotiation. However, if
872 * auto-negotiation is disabled, then software will have to manually
873 * configure the two flow control enable bits in the CTRL register.
874 *
875 * The possible values of the "fc" parameter are:
876 * 0: Flow control is completely disabled
877 * 1: Rx flow control is enabled (we can receive pause frames, but
878 * not send pause frames).
879 * 2: Tx flow control is enabled (we can send pause frames but we do
880 * not support receiving pause frames).
881 * 3: Both Rx and TX flow control (symmetric) are enabled.
882 */
883 switch (hw->fc) {
884 case E1000_FC_NONE:
885 /* Flow control is completely disabled by a software over-ride. */
886 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
887 break;
888 case E1000_FC_RX_PAUSE:
889 /* RX Flow control is enabled and TX Flow control is disabled by a
890 * software over-ride. Since there really isn't a way to advertise
891 * that we are capable of RX Pause ONLY, we will advertise that we
892 * support both symmetric and asymmetric RX PAUSE. Later, we will
893 * disable the adapter's ability to send PAUSE frames.
894 */
895 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
896 break;
897 case E1000_FC_TX_PAUSE:
898 /* TX Flow control is enabled, and RX Flow control is disabled, by a
899 * software over-ride.
900 */
901 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
902 break;
903 case E1000_FC_FULL:
904 /* Flow control (both RX and TX) is enabled by a software over-ride. */
905 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
906 break;
907 default:
908 e_dbg("Flow control param set incorrectly\n");
909 return -E1000_ERR_CONFIG;
910 break;
911 }
912
913 /* Since auto-negotiation is enabled, take the link out of reset (the link
914 * will be in reset, because we previously reset the chip). This will
915 * restart auto-negotiation. If auto-negotiation is successful then the
916 * link-up status bit will be set and the flow control enable bits (RFCE
917 * and TFCE) will be set according to their negotiated value.
918 */
919 e_dbg("Auto-negotiation enabled\n");
920
921 ew32(TXCW, txcw);
922 ew32(CTRL, ctrl);
923 E1000_WRITE_FLUSH();
924
925 hw->txcw = txcw;
926 msleep(1);
927
928 /* If we have a signal (the cable is plugged in) then poll for a "Link-Up"
929 * indication in the Device Status Register. Time-out if a link isn't
930 * seen in 500 milliseconds seconds (Auto-negotiation should complete in
931 * less than 500 milliseconds even if the other end is doing it in SW).
932 * For internal serdes, we just assume a signal is present, then poll.
933 */
934 if (hw->media_type == e1000_media_type_internal_serdes ||
935 (er32(CTRL) & E1000_CTRL_SWDPIN1) == signal) {
936 e_dbg("Looking for Link\n");
937 for (i = 0; i < (LINK_UP_TIMEOUT / 10); i++) {
938 msleep(10);
939 status = er32(STATUS);
940 if (status & E1000_STATUS_LU)
941 break;
942 }
943 if (i == (LINK_UP_TIMEOUT / 10)) {
944 e_dbg("Never got a valid link from auto-neg!!!\n");
945 hw->autoneg_failed = 1;
946 /* AutoNeg failed to achieve a link, so we'll call
947 * e1000_check_for_link. This routine will force the link up if
948 * we detect a signal. This will allow us to communicate with
949 * non-autonegotiating link partners.
950 */
951 ret_val = e1000_check_for_link(hw);
952 if (ret_val) {
953 e_dbg("Error while checking for link\n");
954 return ret_val;
955 }
956 hw->autoneg_failed = 0;
957 } else {
958 hw->autoneg_failed = 0;
959 e_dbg("Valid Link Found\n");
960 }
961 } else {
962 e_dbg("No Signal Detected\n");
963 }
964 return E1000_SUCCESS;
965 }
966
967 /**
968 * e1000_copper_link_rtl_setup - Copper link setup for e1000_phy_rtl series.
969 * @hw: Struct containing variables accessed by shared code
970 *
971 * Commits changes to PHY configuration by calling e1000_phy_reset().
972 */
973 static s32 e1000_copper_link_rtl_setup(struct e1000_hw *hw)
974 {
975 s32 ret_val;
976
977 /* SW reset the PHY so all changes take effect */
978 ret_val = e1000_phy_reset(hw);
979 if (ret_val) {
980 e_dbg("Error Resetting the PHY\n");
981 return ret_val;
982 }
983
984 return E1000_SUCCESS;
985 }
986
987 static s32 gbe_dhg_phy_setup(struct e1000_hw *hw)
988 {
989 s32 ret_val;
990 u32 ctrl_aux;
991
992 switch (hw->phy_type) {
993 case e1000_phy_8211:
994 ret_val = e1000_copper_link_rtl_setup(hw);
995 if (ret_val) {
996 e_dbg("e1000_copper_link_rtl_setup failed!\n");
997 return ret_val;
998 }
999 break;
1000 case e1000_phy_8201:
1001 /* Set RMII mode */
1002 ctrl_aux = er32(CTL_AUX);
1003 ctrl_aux |= E1000_CTL_AUX_RMII;
1004 ew32(CTL_AUX, ctrl_aux);
1005 E1000_WRITE_FLUSH();
1006
1007 /* Disable the J/K bits required for receive */
1008 ctrl_aux = er32(CTL_AUX);
1009 ctrl_aux |= 0x4;
1010 ctrl_aux &= ~0x2;
1011 ew32(CTL_AUX, ctrl_aux);
1012 E1000_WRITE_FLUSH();
1013 ret_val = e1000_copper_link_rtl_setup(hw);
1014
1015 if (ret_val) {
1016 e_dbg("e1000_copper_link_rtl_setup failed!\n");
1017 return ret_val;
1018 }
1019 break;
1020 default:
1021 e_dbg("Error Resetting the PHY\n");
1022 return E1000_ERR_PHY_TYPE;
1023 }
1024
1025 return E1000_SUCCESS;
1026 }
1027
1028 /**
1029 * e1000_copper_link_preconfig - early configuration for copper
1030 * @hw: Struct containing variables accessed by shared code
1031 *
1032 * Make sure we have a valid PHY and change PHY mode before link setup.
1033 */
1034 static s32 e1000_copper_link_preconfig(struct e1000_hw *hw)
1035 {
1036 u32 ctrl;
1037 s32 ret_val;
1038 u16 phy_data;
1039
1040 e_dbg("e1000_copper_link_preconfig");
1041
1042 ctrl = er32(CTRL);
1043 /* With 82543, we need to force speed and duplex on the MAC equal to what
1044 * the PHY speed and duplex configuration is. In addition, we need to
1045 * perform a hardware reset on the PHY to take it out of reset.
1046 */
1047 if (hw->mac_type > e1000_82543) {
1048 ctrl |= E1000_CTRL_SLU;
1049 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1050 ew32(CTRL, ctrl);
1051 } else {
1052 ctrl |=
1053 (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
1054 ew32(CTRL, ctrl);
1055 ret_val = e1000_phy_hw_reset(hw);
1056 if (ret_val)
1057 return ret_val;
1058 }
1059
1060 /* Make sure we have a valid PHY */
1061 ret_val = e1000_detect_gig_phy(hw);
1062 if (ret_val) {
1063 e_dbg("Error, did not detect valid phy.\n");
1064 return ret_val;
1065 }
1066 e_dbg("Phy ID = %x\n", hw->phy_id);
1067
1068 /* Set PHY to class A mode (if necessary) */
1069 ret_val = e1000_set_phy_mode(hw);
1070 if (ret_val)
1071 return ret_val;
1072
1073 if ((hw->mac_type == e1000_82545_rev_3) ||
1074 (hw->mac_type == e1000_82546_rev_3)) {
1075 ret_val =
1076 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1077 phy_data |= 0x00000008;
1078 ret_val =
1079 e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1080 }
1081
1082 if (hw->mac_type <= e1000_82543 ||
1083 hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
1084 hw->mac_type == e1000_82541_rev_2
1085 || hw->mac_type == e1000_82547_rev_2)
1086 hw->phy_reset_disable = false;
1087
1088 return E1000_SUCCESS;
1089 }
1090
1091 /**
1092 * e1000_copper_link_igp_setup - Copper link setup for e1000_phy_igp series.
1093 * @hw: Struct containing variables accessed by shared code
1094 */
1095 static s32 e1000_copper_link_igp_setup(struct e1000_hw *hw)
1096 {
1097 u32 led_ctrl;
1098 s32 ret_val;
1099 u16 phy_data;
1100
1101 e_dbg("e1000_copper_link_igp_setup");
1102
1103 if (hw->phy_reset_disable)
1104 return E1000_SUCCESS;
1105
1106 ret_val = e1000_phy_reset(hw);
1107 if (ret_val) {
1108 e_dbg("Error Resetting the PHY\n");
1109 return ret_val;
1110 }
1111
1112 /* Wait 15ms for MAC to configure PHY from eeprom settings */
1113 msleep(15);
1114 /* Configure activity LED after PHY reset */
1115 led_ctrl = er32(LEDCTL);
1116 led_ctrl &= IGP_ACTIVITY_LED_MASK;
1117 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
1118 ew32(LEDCTL, led_ctrl);
1119
1120 /* The NVM settings will configure LPLU in D3 for IGP2 and IGP3 PHYs */
1121 if (hw->phy_type == e1000_phy_igp) {
1122 /* disable lplu d3 during driver init */
1123 ret_val = e1000_set_d3_lplu_state(hw, false);
1124 if (ret_val) {
1125 e_dbg("Error Disabling LPLU D3\n");
1126 return ret_val;
1127 }
1128 }
1129
1130 /* Configure mdi-mdix settings */
1131 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1132 if (ret_val)
1133 return ret_val;
1134
1135 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
1136 hw->dsp_config_state = e1000_dsp_config_disabled;
1137 /* Force MDI for earlier revs of the IGP PHY */
1138 phy_data &=
1139 ~(IGP01E1000_PSCR_AUTO_MDIX |
1140 IGP01E1000_PSCR_FORCE_MDI_MDIX);
1141 hw->mdix = 1;
1142
1143 } else {
1144 hw->dsp_config_state = e1000_dsp_config_enabled;
1145 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1146
1147 switch (hw->mdix) {
1148 case 1:
1149 phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1150 break;
1151 case 2:
1152 phy_data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1153 break;
1154 case 0:
1155 default:
1156 phy_data |= IGP01E1000_PSCR_AUTO_MDIX;
1157 break;
1158 }
1159 }
1160 ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1161 if (ret_val)
1162 return ret_val;
1163
1164 /* set auto-master slave resolution settings */
1165 if (hw->autoneg) {
1166 e1000_ms_type phy_ms_setting = hw->master_slave;
1167
1168 if (hw->ffe_config_state == e1000_ffe_config_active)
1169 hw->ffe_config_state = e1000_ffe_config_enabled;
1170
1171 if (hw->dsp_config_state == e1000_dsp_config_activated)
1172 hw->dsp_config_state = e1000_dsp_config_enabled;
1173
1174 /* when autonegotiation advertisement is only 1000Mbps then we
1175 * should disable SmartSpeed and enable Auto MasterSlave
1176 * resolution as hardware default. */
1177 if (hw->autoneg_advertised == ADVERTISE_1000_FULL) {
1178 /* Disable SmartSpeed */
1179 ret_val =
1180 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1181 &phy_data);
1182 if (ret_val)
1183 return ret_val;
1184 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1185 ret_val =
1186 e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1187 phy_data);
1188 if (ret_val)
1189 return ret_val;
1190 /* Set auto Master/Slave resolution process */
1191 ret_val =
1192 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1193 if (ret_val)
1194 return ret_val;
1195 phy_data &= ~CR_1000T_MS_ENABLE;
1196 ret_val =
1197 e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1198 if (ret_val)
1199 return ret_val;
1200 }
1201
1202 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1203 if (ret_val)
1204 return ret_val;
1205
1206 /* load defaults for future use */
1207 hw->original_master_slave = (phy_data & CR_1000T_MS_ENABLE) ?
1208 ((phy_data & CR_1000T_MS_VALUE) ?
1209 e1000_ms_force_master :
1210 e1000_ms_force_slave) : e1000_ms_auto;
1211
1212 switch (phy_ms_setting) {
1213 case e1000_ms_force_master:
1214 phy_data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
1215 break;
1216 case e1000_ms_force_slave:
1217 phy_data |= CR_1000T_MS_ENABLE;
1218 phy_data &= ~(CR_1000T_MS_VALUE);
1219 break;
1220 case e1000_ms_auto:
1221 phy_data &= ~CR_1000T_MS_ENABLE;
1222 default:
1223 break;
1224 }
1225 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1226 if (ret_val)
1227 return ret_val;
1228 }
1229
1230 return E1000_SUCCESS;
1231 }
1232
1233 /**
1234 * e1000_copper_link_mgp_setup - Copper link setup for e1000_phy_m88 series.
1235 * @hw: Struct containing variables accessed by shared code
1236 */
1237 static s32 e1000_copper_link_mgp_setup(struct e1000_hw *hw)
1238 {
1239 s32 ret_val;
1240 u16 phy_data;
1241
1242 e_dbg("e1000_copper_link_mgp_setup");
1243
1244 if (hw->phy_reset_disable)
1245 return E1000_SUCCESS;
1246
1247 /* Enable CRS on TX. This must be set for half-duplex operation. */
1248 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1249 if (ret_val)
1250 return ret_val;
1251
1252 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1253
1254 /* Options:
1255 * MDI/MDI-X = 0 (default)
1256 * 0 - Auto for all speeds
1257 * 1 - MDI mode
1258 * 2 - MDI-X mode
1259 * 3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1260 */
1261 phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1262
1263 switch (hw->mdix) {
1264 case 1:
1265 phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
1266 break;
1267 case 2:
1268 phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
1269 break;
1270 case 3:
1271 phy_data |= M88E1000_PSCR_AUTO_X_1000T;
1272 break;
1273 case 0:
1274 default:
1275 phy_data |= M88E1000_PSCR_AUTO_X_MODE;
1276 break;
1277 }
1278
1279 /* Options:
1280 * disable_polarity_correction = 0 (default)
1281 * Automatic Correction for Reversed Cable Polarity
1282 * 0 - Disabled
1283 * 1 - Enabled
1284 */
1285 phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
1286 if (hw->disable_polarity_correction == 1)
1287 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
1288 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1289 if (ret_val)
1290 return ret_val;
1291
1292 if (hw->phy_revision < M88E1011_I_REV_4) {
1293 /* Force TX_CLK in the Extended PHY Specific Control Register
1294 * to 25MHz clock.
1295 */
1296 ret_val =
1297 e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1298 &phy_data);
1299 if (ret_val)
1300 return ret_val;
1301
1302 phy_data |= M88E1000_EPSCR_TX_CLK_25;
1303
1304 if ((hw->phy_revision == E1000_REVISION_2) &&
1305 (hw->phy_id == M88E1111_I_PHY_ID)) {
1306 /* Vidalia Phy, set the downshift counter to 5x */
1307 phy_data &= ~(M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK);
1308 phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
1309 ret_val = e1000_write_phy_reg(hw,
1310 M88E1000_EXT_PHY_SPEC_CTRL,
1311 phy_data);
1312 if (ret_val)
1313 return ret_val;
1314 } else {
1315 /* Configure Master and Slave downshift values */
1316 phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
1317 M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
1318 phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
1319 M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
1320 ret_val = e1000_write_phy_reg(hw,
1321 M88E1000_EXT_PHY_SPEC_CTRL,
1322 phy_data);
1323 if (ret_val)
1324 return ret_val;
1325 }
1326 }
1327
1328 /* SW Reset the PHY so all changes take effect */
1329 ret_val = e1000_phy_reset(hw);
1330 if (ret_val) {
1331 e_dbg("Error Resetting the PHY\n");
1332 return ret_val;
1333 }
1334
1335 return E1000_SUCCESS;
1336 }
1337
1338 /**
1339 * e1000_copper_link_autoneg - setup auto-neg
1340 * @hw: Struct containing variables accessed by shared code
1341 *
1342 * Setup auto-negotiation and flow control advertisements,
1343 * and then perform auto-negotiation.
1344 */
1345 static s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
1346 {
1347 s32 ret_val;
1348 u16 phy_data;
1349
1350 e_dbg("e1000_copper_link_autoneg");
1351
1352 /* Perform some bounds checking on the hw->autoneg_advertised
1353 * parameter. If this variable is zero, then set it to the default.
1354 */
1355 hw->autoneg_advertised &= AUTONEG_ADVERTISE_SPEED_DEFAULT;
1356
1357 /* If autoneg_advertised is zero, we assume it was not defaulted
1358 * by the calling code so we set to advertise full capability.
1359 */
1360 if (hw->autoneg_advertised == 0)
1361 hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
1362
1363 /* IFE/RTL8201N PHY only supports 10/100 */
1364 if (hw->phy_type == e1000_phy_8201)
1365 hw->autoneg_advertised &= AUTONEG_ADVERTISE_10_100_ALL;
1366
1367 e_dbg("Reconfiguring auto-neg advertisement params\n");
1368 ret_val = e1000_phy_setup_autoneg(hw);
1369 if (ret_val) {
1370 e_dbg("Error Setting up Auto-Negotiation\n");
1371 return ret_val;
1372 }
1373 e_dbg("Restarting Auto-Neg\n");
1374
1375 /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1376 * the Auto Neg Restart bit in the PHY control register.
1377 */
1378 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1379 if (ret_val)
1380 return ret_val;
1381
1382 phy_data |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
1383 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
1384 if (ret_val)
1385 return ret_val;
1386
1387 /* Does the user want to wait for Auto-Neg to complete here, or
1388 * check at a later time (for example, callback routine).
1389 */
1390 if (hw->wait_autoneg_complete) {
1391 ret_val = e1000_wait_autoneg(hw);
1392 if (ret_val) {
1393 e_dbg
1394 ("Error while waiting for autoneg to complete\n");
1395 return ret_val;
1396 }
1397 }
1398
1399 hw->get_link_status = true;
1400
1401 return E1000_SUCCESS;
1402 }
1403
1404 /**
1405 * e1000_copper_link_postconfig - post link setup
1406 * @hw: Struct containing variables accessed by shared code
1407 *
1408 * Config the MAC and the PHY after link is up.
1409 * 1) Set up the MAC to the current PHY speed/duplex
1410 * if we are on 82543. If we
1411 * are on newer silicon, we only need to configure
1412 * collision distance in the Transmit Control Register.
1413 * 2) Set up flow control on the MAC to that established with
1414 * the link partner.
1415 * 3) Config DSP to improve Gigabit link quality for some PHY revisions.
1416 */
1417 static s32 e1000_copper_link_postconfig(struct e1000_hw *hw)
1418 {
1419 s32 ret_val;
1420 e_dbg("e1000_copper_link_postconfig");
1421
1422 if ((hw->mac_type >= e1000_82544) && (hw->mac_type != e1000_ce4100)) {
1423 e1000_config_collision_dist(hw);
1424 } else {
1425 ret_val = e1000_config_mac_to_phy(hw);
1426 if (ret_val) {
1427 e_dbg("Error configuring MAC to PHY settings\n");
1428 return ret_val;
1429 }
1430 }
1431 ret_val = e1000_config_fc_after_link_up(hw);
1432 if (ret_val) {
1433 e_dbg("Error Configuring Flow Control\n");
1434 return ret_val;
1435 }
1436
1437 /* Config DSP to improve Giga link quality */
1438 if (hw->phy_type == e1000_phy_igp) {
1439 ret_val = e1000_config_dsp_after_link_change(hw, true);
1440 if (ret_val) {
1441 e_dbg("Error Configuring DSP after link up\n");
1442 return ret_val;
1443 }
1444 }
1445
1446 return E1000_SUCCESS;
1447 }
1448
1449 /**
1450 * e1000_setup_copper_link - phy/speed/duplex setting
1451 * @hw: Struct containing variables accessed by shared code
1452 *
1453 * Detects which PHY is present and sets up the speed and duplex
1454 */
1455 static s32 e1000_setup_copper_link(struct e1000_hw *hw)
1456 {
1457 s32 ret_val;
1458 u16 i;
1459 u16 phy_data;
1460
1461 e_dbg("e1000_setup_copper_link");
1462
1463 /* Check if it is a valid PHY and set PHY mode if necessary. */
1464 ret_val = e1000_copper_link_preconfig(hw);
1465 if (ret_val)
1466 return ret_val;
1467
1468 if (hw->phy_type == e1000_phy_igp) {
1469 ret_val = e1000_copper_link_igp_setup(hw);
1470 if (ret_val)
1471 return ret_val;
1472 } else if (hw->phy_type == e1000_phy_m88) {
1473 ret_val = e1000_copper_link_mgp_setup(hw);
1474 if (ret_val)
1475 return ret_val;
1476 } else {
1477 ret_val = gbe_dhg_phy_setup(hw);
1478 if (ret_val) {
1479 e_dbg("gbe_dhg_phy_setup failed!\n");
1480 return ret_val;
1481 }
1482 }
1483
1484 if (hw->autoneg) {
1485 /* Setup autoneg and flow control advertisement
1486 * and perform autonegotiation */
1487 ret_val = e1000_copper_link_autoneg(hw);
1488 if (ret_val)
1489 return ret_val;
1490 } else {
1491 /* PHY will be set to 10H, 10F, 100H,or 100F
1492 * depending on value from forced_speed_duplex. */
1493 e_dbg("Forcing speed and duplex\n");
1494 ret_val = e1000_phy_force_speed_duplex(hw);
1495 if (ret_val) {
1496 e_dbg("Error Forcing Speed and Duplex\n");
1497 return ret_val;
1498 }
1499 }
1500
1501 /* Check link status. Wait up to 100 microseconds for link to become
1502 * valid.
1503 */
1504 for (i = 0; i < 10; i++) {
1505 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
1506 if (ret_val)
1507 return ret_val;
1508 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
1509 if (ret_val)
1510 return ret_val;
1511
1512 if (phy_data & MII_SR_LINK_STATUS) {
1513 /* Config the MAC and PHY after link is up */
1514 ret_val = e1000_copper_link_postconfig(hw);
1515 if (ret_val)
1516 return ret_val;
1517
1518 e_dbg("Valid link established!!!\n");
1519 return E1000_SUCCESS;
1520 }
1521 udelay(10);
1522 }
1523
1524 e_dbg("Unable to establish link!!!\n");
1525 return E1000_SUCCESS;
1526 }
1527
1528 /**
1529 * e1000_phy_setup_autoneg - phy settings
1530 * @hw: Struct containing variables accessed by shared code
1531 *
1532 * Configures PHY autoneg and flow control advertisement settings
1533 */
1534 s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
1535 {
1536 s32 ret_val;
1537 u16 mii_autoneg_adv_reg;
1538 u16 mii_1000t_ctrl_reg;
1539
1540 e_dbg("e1000_phy_setup_autoneg");
1541
1542 /* Read the MII Auto-Neg Advertisement Register (Address 4). */
1543 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
1544 if (ret_val)
1545 return ret_val;
1546
1547 /* Read the MII 1000Base-T Control Register (Address 9). */
1548 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &mii_1000t_ctrl_reg);
1549 if (ret_val)
1550 return ret_val;
1551 else if (hw->phy_type == e1000_phy_8201)
1552 mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
1553
1554 /* Need to parse both autoneg_advertised and fc and set up
1555 * the appropriate PHY registers. First we will parse for
1556 * autoneg_advertised software override. Since we can advertise
1557 * a plethora of combinations, we need to check each bit
1558 * individually.
1559 */
1560
1561 /* First we clear all the 10/100 mb speed bits in the Auto-Neg
1562 * Advertisement Register (Address 4) and the 1000 mb speed bits in
1563 * the 1000Base-T Control Register (Address 9).
1564 */
1565 mii_autoneg_adv_reg &= ~REG4_SPEED_MASK;
1566 mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
1567
1568 e_dbg("autoneg_advertised %x\n", hw->autoneg_advertised);
1569
1570 /* Do we want to advertise 10 Mb Half Duplex? */
1571 if (hw->autoneg_advertised & ADVERTISE_10_HALF) {
1572 e_dbg("Advertise 10mb Half duplex\n");
1573 mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
1574 }
1575
1576 /* Do we want to advertise 10 Mb Full Duplex? */
1577 if (hw->autoneg_advertised & ADVERTISE_10_FULL) {
1578 e_dbg("Advertise 10mb Full duplex\n");
1579 mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
1580 }
1581
1582 /* Do we want to advertise 100 Mb Half Duplex? */
1583 if (hw->autoneg_advertised & ADVERTISE_100_HALF) {
1584 e_dbg("Advertise 100mb Half duplex\n");
1585 mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
1586 }
1587
1588 /* Do we want to advertise 100 Mb Full Duplex? */
1589 if (hw->autoneg_advertised & ADVERTISE_100_FULL) {
1590 e_dbg("Advertise 100mb Full duplex\n");
1591 mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
1592 }
1593
1594 /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
1595 if (hw->autoneg_advertised & ADVERTISE_1000_HALF) {
1596 e_dbg
1597 ("Advertise 1000mb Half duplex requested, request denied!\n");
1598 }
1599
1600 /* Do we want to advertise 1000 Mb Full Duplex? */
1601 if (hw->autoneg_advertised & ADVERTISE_1000_FULL) {
1602 e_dbg("Advertise 1000mb Full duplex\n");
1603 mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
1604 }
1605
1606 /* Check for a software override of the flow control settings, and
1607 * setup the PHY advertisement registers accordingly. If
1608 * auto-negotiation is enabled, then software will have to set the
1609 * "PAUSE" bits to the correct value in the Auto-Negotiation
1610 * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
1611 *
1612 * The possible values of the "fc" parameter are:
1613 * 0: Flow control is completely disabled
1614 * 1: Rx flow control is enabled (we can receive pause frames
1615 * but not send pause frames).
1616 * 2: Tx flow control is enabled (we can send pause frames
1617 * but we do not support receiving pause frames).
1618 * 3: Both Rx and TX flow control (symmetric) are enabled.
1619 * other: No software override. The flow control configuration
1620 * in the EEPROM is used.
1621 */
1622 switch (hw->fc) {
1623 case E1000_FC_NONE: /* 0 */
1624 /* Flow control (RX & TX) is completely disabled by a
1625 * software over-ride.
1626 */
1627 mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1628 break;
1629 case E1000_FC_RX_PAUSE: /* 1 */
1630 /* RX Flow control is enabled, and TX Flow control is
1631 * disabled, by a software over-ride.
1632 */
1633 /* Since there really isn't a way to advertise that we are
1634 * capable of RX Pause ONLY, we will advertise that we
1635 * support both symmetric and asymmetric RX PAUSE. Later
1636 * (in e1000_config_fc_after_link_up) we will disable the
1637 *hw's ability to send PAUSE frames.
1638 */
1639 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1640 break;
1641 case E1000_FC_TX_PAUSE: /* 2 */
1642 /* TX Flow control is enabled, and RX Flow control is
1643 * disabled, by a software over-ride.
1644 */
1645 mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
1646 mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
1647 break;
1648 case E1000_FC_FULL: /* 3 */
1649 /* Flow control (both RX and TX) is enabled by a software
1650 * over-ride.
1651 */
1652 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1653 break;
1654 default:
1655 e_dbg("Flow control param set incorrectly\n");
1656 return -E1000_ERR_CONFIG;
1657 }
1658
1659 ret_val = e1000_write_phy_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
1660 if (ret_val)
1661 return ret_val;
1662
1663 e_dbg("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
1664
1665 if (hw->phy_type == e1000_phy_8201) {
1666 mii_1000t_ctrl_reg = 0;
1667 } else {
1668 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL,
1669 mii_1000t_ctrl_reg);
1670 if (ret_val)
1671 return ret_val;
1672 }
1673
1674 return E1000_SUCCESS;
1675 }
1676
1677 /**
1678 * e1000_phy_force_speed_duplex - force link settings
1679 * @hw: Struct containing variables accessed by shared code
1680 *
1681 * Force PHY speed and duplex settings to hw->forced_speed_duplex
1682 */
1683 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
1684 {
1685 u32 ctrl;
1686 s32 ret_val;
1687 u16 mii_ctrl_reg;
1688 u16 mii_status_reg;
1689 u16 phy_data;
1690 u16 i;
1691
1692 e_dbg("e1000_phy_force_speed_duplex");
1693
1694 /* Turn off Flow control if we are forcing speed and duplex. */
1695 hw->fc = E1000_FC_NONE;
1696
1697 e_dbg("hw->fc = %d\n", hw->fc);
1698
1699 /* Read the Device Control Register. */
1700 ctrl = er32(CTRL);
1701
1702 /* Set the bits to Force Speed and Duplex in the Device Ctrl Reg. */
1703 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1704 ctrl &= ~(DEVICE_SPEED_MASK);
1705
1706 /* Clear the Auto Speed Detect Enable bit. */
1707 ctrl &= ~E1000_CTRL_ASDE;
1708
1709 /* Read the MII Control Register. */
1710 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &mii_ctrl_reg);
1711 if (ret_val)
1712 return ret_val;
1713
1714 /* We need to disable autoneg in order to force link and duplex. */
1715
1716 mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
1717
1718 /* Are we forcing Full or Half Duplex? */
1719 if (hw->forced_speed_duplex == e1000_100_full ||
1720 hw->forced_speed_duplex == e1000_10_full) {
1721 /* We want to force full duplex so we SET the full duplex bits in the
1722 * Device and MII Control Registers.
1723 */
1724 ctrl |= E1000_CTRL_FD;
1725 mii_ctrl_reg |= MII_CR_FULL_DUPLEX;
1726 e_dbg("Full Duplex\n");
1727 } else {
1728 /* We want to force half duplex so we CLEAR the full duplex bits in
1729 * the Device and MII Control Registers.
1730 */
1731 ctrl &= ~E1000_CTRL_FD;
1732 mii_ctrl_reg &= ~MII_CR_FULL_DUPLEX;
1733 e_dbg("Half Duplex\n");
1734 }
1735
1736 /* Are we forcing 100Mbps??? */
1737 if (hw->forced_speed_duplex == e1000_100_full ||
1738 hw->forced_speed_duplex == e1000_100_half) {
1739 /* Set the 100Mb bit and turn off the 1000Mb and 10Mb bits. */
1740 ctrl |= E1000_CTRL_SPD_100;
1741 mii_ctrl_reg |= MII_CR_SPEED_100;
1742 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
1743 e_dbg("Forcing 100mb ");
1744 } else {
1745 /* Set the 10Mb bit and turn off the 1000Mb and 100Mb bits. */
1746 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1747 mii_ctrl_reg |= MII_CR_SPEED_10;
1748 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
1749 e_dbg("Forcing 10mb ");
1750 }
1751
1752 e1000_config_collision_dist(hw);
1753
1754 /* Write the configured values back to the Device Control Reg. */
1755 ew32(CTRL, ctrl);
1756
1757 if (hw->phy_type == e1000_phy_m88) {
1758 ret_val =
1759 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1760 if (ret_val)
1761 return ret_val;
1762
1763 /* Clear Auto-Crossover to force MDI manually. M88E1000 requires MDI
1764 * forced whenever speed are duplex are forced.
1765 */
1766 phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1767 ret_val =
1768 e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1769 if (ret_val)
1770 return ret_val;
1771
1772 e_dbg("M88E1000 PSCR: %x\n", phy_data);
1773
1774 /* Need to reset the PHY or these changes will be ignored */
1775 mii_ctrl_reg |= MII_CR_RESET;
1776
1777 /* Disable MDI-X support for 10/100 */
1778 } else {
1779 /* Clear Auto-Crossover to force MDI manually. IGP requires MDI
1780 * forced whenever speed or duplex are forced.
1781 */
1782 ret_val =
1783 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1784 if (ret_val)
1785 return ret_val;
1786
1787 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1788 phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1789
1790 ret_val =
1791 e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1792 if (ret_val)
1793 return ret_val;
1794 }
1795
1796 /* Write back the modified PHY MII control register. */
1797 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, mii_ctrl_reg);
1798 if (ret_val)
1799 return ret_val;
1800
1801 udelay(1);
1802
1803 /* The wait_autoneg_complete flag may be a little misleading here.
1804 * Since we are forcing speed and duplex, Auto-Neg is not enabled.
1805 * But we do want to delay for a period while forcing only so we
1806 * don't generate false No Link messages. So we will wait here
1807 * only if the user has set wait_autoneg_complete to 1, which is
1808 * the default.
1809 */
1810 if (hw->wait_autoneg_complete) {
1811 /* We will wait for autoneg to complete. */
1812 e_dbg("Waiting for forced speed/duplex link.\n");
1813 mii_status_reg = 0;
1814
1815 /* We will wait for autoneg to complete or 4.5 seconds to expire. */
1816 for (i = PHY_FORCE_TIME; i > 0; i--) {
1817 /* Read the MII Status Register and wait for Auto-Neg Complete bit
1818 * to be set.
1819 */
1820 ret_val =
1821 e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1822 if (ret_val)
1823 return ret_val;
1824
1825 ret_val =
1826 e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1827 if (ret_val)
1828 return ret_val;
1829
1830 if (mii_status_reg & MII_SR_LINK_STATUS)
1831 break;
1832 msleep(100);
1833 }
1834 if ((i == 0) && (hw->phy_type == e1000_phy_m88)) {
1835 /* We didn't get link. Reset the DSP and wait again for link. */
1836 ret_val = e1000_phy_reset_dsp(hw);
1837 if (ret_val) {
1838 e_dbg("Error Resetting PHY DSP\n");
1839 return ret_val;
1840 }
1841 }
1842 /* This loop will early-out if the link condition has been met. */
1843 for (i = PHY_FORCE_TIME; i > 0; i--) {
1844 if (mii_status_reg & MII_SR_LINK_STATUS)
1845 break;
1846 msleep(100);
1847 /* Read the MII Status Register and wait for Auto-Neg Complete bit
1848 * to be set.
1849 */
1850 ret_val =
1851 e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1852 if (ret_val)
1853 return ret_val;
1854
1855 ret_val =
1856 e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1857 if (ret_val)
1858 return ret_val;
1859 }
1860 }
1861
1862 if (hw->phy_type == e1000_phy_m88) {
1863 /* Because we reset the PHY above, we need to re-force TX_CLK in the
1864 * Extended PHY Specific Control Register to 25MHz clock. This value
1865 * defaults back to a 2.5MHz clock when the PHY is reset.
1866 */
1867 ret_val =
1868 e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1869 &phy_data);
1870 if (ret_val)
1871 return ret_val;
1872
1873 phy_data |= M88E1000_EPSCR_TX_CLK_25;
1874 ret_val =
1875 e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1876 phy_data);
1877 if (ret_val)
1878 return ret_val;
1879
1880 /* In addition, because of the s/w reset above, we need to enable CRS on
1881 * TX. This must be set for both full and half duplex operation.
1882 */
1883 ret_val =
1884 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1885 if (ret_val)
1886 return ret_val;
1887
1888 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1889 ret_val =
1890 e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1891 if (ret_val)
1892 return ret_val;
1893
1894 if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543)
1895 && (!hw->autoneg)
1896 && (hw->forced_speed_duplex == e1000_10_full
1897 || hw->forced_speed_duplex == e1000_10_half)) {
1898 ret_val = e1000_polarity_reversal_workaround(hw);
1899 if (ret_val)
1900 return ret_val;
1901 }
1902 }
1903 return E1000_SUCCESS;
1904 }
1905
1906 /**
1907 * e1000_config_collision_dist - set collision distance register
1908 * @hw: Struct containing variables accessed by shared code
1909 *
1910 * Sets the collision distance in the Transmit Control register.
1911 * Link should have been established previously. Reads the speed and duplex
1912 * information from the Device Status register.
1913 */
1914 void e1000_config_collision_dist(struct e1000_hw *hw)
1915 {
1916 u32 tctl, coll_dist;
1917
1918 e_dbg("e1000_config_collision_dist");
1919
1920 if (hw->mac_type < e1000_82543)
1921 coll_dist = E1000_COLLISION_DISTANCE_82542;
1922 else
1923 coll_dist = E1000_COLLISION_DISTANCE;
1924
1925 tctl = er32(TCTL);
1926
1927 tctl &= ~E1000_TCTL_COLD;
1928 tctl |= coll_dist << E1000_COLD_SHIFT;
1929
1930 ew32(TCTL, tctl);
1931 E1000_WRITE_FLUSH();
1932 }
1933
1934 /**
1935 * e1000_config_mac_to_phy - sync phy and mac settings
1936 * @hw: Struct containing variables accessed by shared code
1937 * @mii_reg: data to write to the MII control register
1938 *
1939 * Sets MAC speed and duplex settings to reflect the those in the PHY
1940 * The contents of the PHY register containing the needed information need to
1941 * be passed in.
1942 */
1943 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw)
1944 {
1945 u32 ctrl;
1946 s32 ret_val;
1947 u16 phy_data;
1948
1949 e_dbg("e1000_config_mac_to_phy");
1950
1951 /* 82544 or newer MAC, Auto Speed Detection takes care of
1952 * MAC speed/duplex configuration.*/
1953 if ((hw->mac_type >= e1000_82544) && (hw->mac_type != e1000_ce4100))
1954 return E1000_SUCCESS;
1955
1956 /* Read the Device Control Register and set the bits to Force Speed
1957 * and Duplex.
1958 */
1959 ctrl = er32(CTRL);
1960 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1961 ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
1962
1963 switch (hw->phy_type) {
1964 case e1000_phy_8201:
1965 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1966 if (ret_val)
1967 return ret_val;
1968
1969 if (phy_data & RTL_PHY_CTRL_FD)
1970 ctrl |= E1000_CTRL_FD;
1971 else
1972 ctrl &= ~E1000_CTRL_FD;
1973
1974 if (phy_data & RTL_PHY_CTRL_SPD_100)
1975 ctrl |= E1000_CTRL_SPD_100;
1976 else
1977 ctrl |= E1000_CTRL_SPD_10;
1978
1979 e1000_config_collision_dist(hw);
1980 break;
1981 default:
1982 /* Set up duplex in the Device Control and Transmit Control
1983 * registers depending on negotiated values.
1984 */
1985 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
1986 &phy_data);
1987 if (ret_val)
1988 return ret_val;
1989
1990 if (phy_data & M88E1000_PSSR_DPLX)
1991 ctrl |= E1000_CTRL_FD;
1992 else
1993 ctrl &= ~E1000_CTRL_FD;
1994
1995 e1000_config_collision_dist(hw);
1996
1997 /* Set up speed in the Device Control register depending on
1998 * negotiated values.
1999 */
2000 if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
2001 ctrl |= E1000_CTRL_SPD_1000;
2002 else if ((phy_data & M88E1000_PSSR_SPEED) ==
2003 M88E1000_PSSR_100MBS)
2004 ctrl |= E1000_CTRL_SPD_100;
2005 }
2006
2007 /* Write the configured values back to the Device Control Reg. */
2008 ew32(CTRL, ctrl);
2009 return E1000_SUCCESS;
2010 }
2011
2012 /**
2013 * e1000_force_mac_fc - force flow control settings
2014 * @hw: Struct containing variables accessed by shared code
2015 *
2016 * Forces the MAC's flow control settings.
2017 * Sets the TFCE and RFCE bits in the device control register to reflect
2018 * the adapter settings. TFCE and RFCE need to be explicitly set by
2019 * software when a Copper PHY is used because autonegotiation is managed
2020 * by the PHY rather than the MAC. Software must also configure these
2021 * bits when link is forced on a fiber connection.
2022 */
2023 s32 e1000_force_mac_fc(struct e1000_hw *hw)
2024 {
2025 u32 ctrl;
2026
2027 e_dbg("e1000_force_mac_fc");
2028
2029 /* Get the current configuration of the Device Control Register */
2030 ctrl = er32(CTRL);
2031
2032 /* Because we didn't get link via the internal auto-negotiation
2033 * mechanism (we either forced link or we got link via PHY
2034 * auto-neg), we have to manually enable/disable transmit an
2035 * receive flow control.
2036 *
2037 * The "Case" statement below enables/disable flow control
2038 * according to the "hw->fc" parameter.
2039 *
2040 * The possible values of the "fc" parameter are:
2041 * 0: Flow control is completely disabled
2042 * 1: Rx flow control is enabled (we can receive pause
2043 * frames but not send pause frames).
2044 * 2: Tx flow control is enabled (we can send pause frames
2045 * frames but we do not receive pause frames).
2046 * 3: Both Rx and TX flow control (symmetric) is enabled.
2047 * other: No other values should be possible at this point.
2048 */
2049
2050 switch (hw->fc) {
2051 case E1000_FC_NONE:
2052 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
2053 break;
2054 case E1000_FC_RX_PAUSE:
2055 ctrl &= (~E1000_CTRL_TFCE);
2056 ctrl |= E1000_CTRL_RFCE;
2057 break;
2058 case E1000_FC_TX_PAUSE:
2059 ctrl &= (~E1000_CTRL_RFCE);
2060 ctrl |= E1000_CTRL_TFCE;
2061 break;
2062 case E1000_FC_FULL:
2063 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
2064 break;
2065 default:
2066 e_dbg("Flow control param set incorrectly\n");
2067 return -E1000_ERR_CONFIG;
2068 }
2069
2070 /* Disable TX Flow Control for 82542 (rev 2.0) */
2071 if (hw->mac_type == e1000_82542_rev2_0)
2072 ctrl &= (~E1000_CTRL_TFCE);
2073
2074 ew32(CTRL, ctrl);
2075 return E1000_SUCCESS;
2076 }
2077
2078 /**
2079 * e1000_config_fc_after_link_up - configure flow control after autoneg
2080 * @hw: Struct containing variables accessed by shared code
2081 *
2082 * Configures flow control settings after link is established
2083 * Should be called immediately after a valid link has been established.
2084 * Forces MAC flow control settings if link was forced. When in MII/GMII mode
2085 * and autonegotiation is enabled, the MAC flow control settings will be set
2086 * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
2087 * and RFCE bits will be automatically set to the negotiated flow control mode.
2088 */
2089 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
2090 {
2091 s32 ret_val;
2092 u16 mii_status_reg;
2093 u16 mii_nway_adv_reg;
2094 u16 mii_nway_lp_ability_reg;
2095 u16 speed;
2096 u16 duplex;
2097
2098 e_dbg("e1000_config_fc_after_link_up");
2099
2100 /* Check for the case where we have fiber media and auto-neg failed
2101 * so we had to force link. In this case, we need to force the
2102 * configuration of the MAC to match the "fc" parameter.
2103 */
2104 if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed))
2105 || ((hw->media_type == e1000_media_type_internal_serdes)
2106 && (hw->autoneg_failed))
2107 || ((hw->media_type == e1000_media_type_copper)
2108 && (!hw->autoneg))) {
2109 ret_val = e1000_force_mac_fc(hw);
2110 if (ret_val) {
2111 e_dbg("Error forcing flow control settings\n");
2112 return ret_val;
2113 }
2114 }
2115
2116 /* Check for the case where we have copper media and auto-neg is
2117 * enabled. In this case, we need to check and see if Auto-Neg
2118 * has completed, and if so, how the PHY and link partner has
2119 * flow control configured.
2120 */
2121 if ((hw->media_type == e1000_media_type_copper) && hw->autoneg) {
2122 /* Read the MII Status Register and check to see if AutoNeg
2123 * has completed. We read this twice because this reg has
2124 * some "sticky" (latched) bits.
2125 */
2126 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2127 if (ret_val)
2128 return ret_val;
2129 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2130 if (ret_val)
2131 return ret_val;
2132
2133 if (mii_status_reg & MII_SR_AUTONEG_COMPLETE) {
2134 /* The AutoNeg process has completed, so we now need to
2135 * read both the Auto Negotiation Advertisement Register
2136 * (Address 4) and the Auto_Negotiation Base Page Ability
2137 * Register (Address 5) to determine how flow control was
2138 * negotiated.
2139 */
2140 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV,
2141 &mii_nway_adv_reg);
2142 if (ret_val)
2143 return ret_val;
2144 ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY,
2145 &mii_nway_lp_ability_reg);
2146 if (ret_val)
2147 return ret_val;
2148
2149 /* Two bits in the Auto Negotiation Advertisement Register
2150 * (Address 4) and two bits in the Auto Negotiation Base
2151 * Page Ability Register (Address 5) determine flow control
2152 * for both the PHY and the link partner. The following
2153 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
2154 * 1999, describes these PAUSE resolution bits and how flow
2155 * control is determined based upon these settings.
2156 * NOTE: DC = Don't Care
2157 *
2158 * LOCAL DEVICE | LINK PARTNER
2159 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
2160 *-------|---------|-------|---------|--------------------
2161 * 0 | 0 | DC | DC | E1000_FC_NONE
2162 * 0 | 1 | 0 | DC | E1000_FC_NONE
2163 * 0 | 1 | 1 | 0 | E1000_FC_NONE
2164 * 0 | 1 | 1 | 1 | E1000_FC_TX_PAUSE
2165 * 1 | 0 | 0 | DC | E1000_FC_NONE
2166 * 1 | DC | 1 | DC | E1000_FC_FULL
2167 * 1 | 1 | 0 | 0 | E1000_FC_NONE
2168 * 1 | 1 | 0 | 1 | E1000_FC_RX_PAUSE
2169 *
2170 */
2171 /* Are both PAUSE bits set to 1? If so, this implies
2172 * Symmetric Flow Control is enabled at both ends. The
2173 * ASM_DIR bits are irrelevant per the spec.
2174 *
2175 * For Symmetric Flow Control:
2176 *
2177 * LOCAL DEVICE | LINK PARTNER
2178 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2179 *-------|---------|-------|---------|--------------------
2180 * 1 | DC | 1 | DC | E1000_FC_FULL
2181 *
2182 */
2183 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2184 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
2185 /* Now we need to check if the user selected RX ONLY
2186 * of pause frames. In this case, we had to advertise
2187 * FULL flow control because we could not advertise RX
2188 * ONLY. Hence, we must now check to see if we need to
2189 * turn OFF the TRANSMISSION of PAUSE frames.
2190 */
2191 if (hw->original_fc == E1000_FC_FULL) {
2192 hw->fc = E1000_FC_FULL;
2193 e_dbg("Flow Control = FULL.\n");
2194 } else {
2195 hw->fc = E1000_FC_RX_PAUSE;
2196 e_dbg
2197 ("Flow Control = RX PAUSE frames only.\n");
2198 }
2199 }
2200 /* For receiving PAUSE frames ONLY.
2201 *
2202 * LOCAL DEVICE | LINK PARTNER
2203 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2204 *-------|---------|-------|---------|--------------------
2205 * 0 | 1 | 1 | 1 | E1000_FC_TX_PAUSE
2206 *
2207 */
2208 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2209 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2210 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2211 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR))
2212 {
2213 hw->fc = E1000_FC_TX_PAUSE;
2214 e_dbg
2215 ("Flow Control = TX PAUSE frames only.\n");
2216 }
2217 /* For transmitting PAUSE frames ONLY.
2218 *
2219 * LOCAL DEVICE | LINK PARTNER
2220 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2221 *-------|---------|-------|---------|--------------------
2222 * 1 | 1 | 0 | 1 | E1000_FC_RX_PAUSE
2223 *
2224 */
2225 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2226 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2227 !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2228 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR))
2229 {
2230 hw->fc = E1000_FC_RX_PAUSE;
2231 e_dbg
2232 ("Flow Control = RX PAUSE frames only.\n");
2233 }
2234 /* Per the IEEE spec, at this point flow control should be
2235 * disabled. However, we want to consider that we could
2236 * be connected to a legacy switch that doesn't advertise
2237 * desired flow control, but can be forced on the link
2238 * partner. So if we advertised no flow control, that is
2239 * what we will resolve to. If we advertised some kind of
2240 * receive capability (Rx Pause Only or Full Flow Control)
2241 * and the link partner advertised none, we will configure
2242 * ourselves to enable Rx Flow Control only. We can do
2243 * this safely for two reasons: If the link partner really
2244 * didn't want flow control enabled, and we enable Rx, no
2245 * harm done since we won't be receiving any PAUSE frames
2246 * anyway. If the intent on the link partner was to have
2247 * flow control enabled, then by us enabling RX only, we
2248 * can at least receive pause frames and process them.
2249 * This is a good idea because in most cases, since we are
2250 * predominantly a server NIC, more times than not we will
2251 * be asked to delay transmission of packets than asking
2252 * our link partner to pause transmission of frames.
2253 */
2254 else if ((hw->original_fc == E1000_FC_NONE ||
2255 hw->original_fc == E1000_FC_TX_PAUSE) ||
2256 hw->fc_strict_ieee) {
2257 hw->fc = E1000_FC_NONE;
2258 e_dbg("Flow Control = NONE.\n");
2259 } else {
2260 hw->fc = E1000_FC_RX_PAUSE;
2261 e_dbg
2262 ("Flow Control = RX PAUSE frames only.\n");
2263 }
2264
2265 /* Now we need to do one last check... If we auto-
2266 * negotiated to HALF DUPLEX, flow control should not be
2267 * enabled per IEEE 802.3 spec.
2268 */
2269 ret_val =
2270 e1000_get_speed_and_duplex(hw, &speed, &duplex);
2271 if (ret_val) {
2272 e_dbg
2273 ("Error getting link speed and duplex\n");
2274 return ret_val;
2275 }
2276
2277 if (duplex == HALF_DUPLEX)
2278 hw->fc = E1000_FC_NONE;
2279
2280 /* Now we call a subroutine to actually force the MAC
2281 * controller to use the correct flow control settings.
2282 */
2283 ret_val = e1000_force_mac_fc(hw);
2284 if (ret_val) {
2285 e_dbg
2286 ("Error forcing flow control settings\n");
2287 return ret_val;
2288 }
2289 } else {
2290 e_dbg
2291 ("Copper PHY and Auto Neg has not completed.\n");
2292 }
2293 }
2294 return E1000_SUCCESS;
2295 }
2296
2297 /**
2298 * e1000_check_for_serdes_link_generic - Check for link (Serdes)
2299 * @hw: pointer to the HW structure
2300 *
2301 * Checks for link up on the hardware. If link is not up and we have
2302 * a signal, then we need to force link up.
2303 */
2304 static s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
2305 {
2306 u32 rxcw;
2307 u32 ctrl;
2308 u32 status;
2309 s32 ret_val = E1000_SUCCESS;
2310
2311 e_dbg("e1000_check_for_serdes_link_generic");
2312
2313 ctrl = er32(CTRL);
2314 status = er32(STATUS);
2315 rxcw = er32(RXCW);
2316
2317 /*
2318 * If we don't have link (auto-negotiation failed or link partner
2319 * cannot auto-negotiate), and our link partner is not trying to
2320 * auto-negotiate with us (we are receiving idles or data),
2321 * we need to force link up. We also need to give auto-negotiation
2322 * time to complete.
2323 */
2324 /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
2325 if ((!(status & E1000_STATUS_LU)) && (!(rxcw & E1000_RXCW_C))) {
2326 if (hw->autoneg_failed == 0) {
2327 hw->autoneg_failed = 1;
2328 goto out;
2329 }
2330 e_dbg("NOT RXing /C/, disable AutoNeg and force link.\n");
2331
2332 /* Disable auto-negotiation in the TXCW register */
2333 ew32(TXCW, (hw->txcw & ~E1000_TXCW_ANE));
2334
2335 /* Force link-up and also force full-duplex. */
2336 ctrl = er32(CTRL);
2337 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
2338 ew32(CTRL, ctrl);
2339
2340 /* Configure Flow Control after forcing link up. */
2341 ret_val = e1000_config_fc_after_link_up(hw);
2342 if (ret_val) {
2343 e_dbg("Error configuring flow control\n");
2344 goto out;
2345 }
2346 } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
2347 /*
2348 * If we are forcing link and we are receiving /C/ ordered
2349 * sets, re-enable auto-negotiation in the TXCW register
2350 * and disable forced link in the Device Control register
2351 * in an attempt to auto-negotiate with our link partner.
2352 */
2353 e_dbg("RXing /C/, enable AutoNeg and stop forcing link.\n");
2354 ew32(TXCW, hw->txcw);
2355 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
2356
2357 hw->serdes_has_link = true;
2358 } else if (!(E1000_TXCW_ANE & er32(TXCW))) {
2359 /*
2360 * If we force link for non-auto-negotiation switch, check
2361 * link status based on MAC synchronization for internal
2362 * serdes media type.
2363 */
2364 /* SYNCH bit and IV bit are sticky. */
2365 udelay(10);
2366 rxcw = er32(RXCW);
2367 if (rxcw & E1000_RXCW_SYNCH) {
2368 if (!(rxcw & E1000_RXCW_IV)) {
2369 hw->serdes_has_link = true;
2370 e_dbg("SERDES: Link up - forced.\n");
2371 }
2372 } else {
2373 hw->serdes_has_link = false;
2374 e_dbg("SERDES: Link down - force failed.\n");
2375 }
2376 }
2377
2378 if (E1000_TXCW_ANE & er32(TXCW)) {
2379 status = er32(STATUS);
2380 if (status & E1000_STATUS_LU) {
2381 /* SYNCH bit and IV bit are sticky, so reread rxcw. */
2382 udelay(10);
2383 rxcw = er32(RXCW);
2384 if (rxcw & E1000_RXCW_SYNCH) {
2385 if (!(rxcw & E1000_RXCW_IV)) {
2386 hw->serdes_has_link = true;
2387 e_dbg("SERDES: Link up - autoneg "
2388 "completed successfully.\n");
2389 } else {
2390 hw->serdes_has_link = false;
2391 e_dbg("SERDES: Link down - invalid"
2392 "codewords detected in autoneg.\n");
2393 }
2394 } else {
2395 hw->serdes_has_link = false;
2396 e_dbg("SERDES: Link down - no sync.\n");
2397 }
2398 } else {
2399 hw->serdes_has_link = false;
2400 e_dbg("SERDES: Link down - autoneg failed\n");
2401 }
2402 }
2403
2404 out:
2405 return ret_val;
2406 }
2407
2408 /**
2409 * e1000_check_for_link
2410 * @hw: Struct containing variables accessed by shared code
2411 *
2412 * Checks to see if the link status of the hardware has changed.
2413 * Called by any function that needs to check the link status of the adapter.
2414 */
2415 s32 e1000_check_for_link(struct e1000_hw *hw)
2416 {
2417 u32 rxcw = 0;
2418 u32 ctrl;
2419 u32 status;
2420 u32 rctl;
2421 u32 icr;
2422 u32 signal = 0;
2423 s32 ret_val;
2424 u16 phy_data;
2425
2426 e_dbg("e1000_check_for_link");
2427
2428 ctrl = er32(CTRL);
2429 status = er32(STATUS);
2430
2431 /* On adapters with a MAC newer than 82544, SW Definable pin 1 will be
2432 * set when the optics detect a signal. On older adapters, it will be
2433 * cleared when there is a signal. This applies to fiber media only.
2434 */
2435 if ((hw->media_type == e1000_media_type_fiber) ||
2436 (hw->media_type == e1000_media_type_internal_serdes)) {
2437 rxcw = er32(RXCW);
2438
2439 if (hw->media_type == e1000_media_type_fiber) {
2440 signal =
2441 (hw->mac_type >
2442 e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
2443 if (status & E1000_STATUS_LU)
2444 hw->get_link_status = false;
2445 }
2446 }
2447
2448 /* If we have a copper PHY then we only want to go out to the PHY
2449 * registers to see if Auto-Neg has completed and/or if our link
2450 * status has changed. The get_link_status flag will be set if we
2451 * receive a Link Status Change interrupt or we have Rx Sequence
2452 * Errors.
2453 */
2454 if ((hw->media_type == e1000_media_type_copper) && hw->get_link_status) {
2455 /* First we want to see if the MII Status Register reports
2456 * link. If so, then we want to get the current speed/duplex
2457 * of the PHY.
2458 * Read the register twice since the link bit is sticky.
2459 */
2460 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2461 if (ret_val)
2462 return ret_val;
2463 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2464 if (ret_val)
2465 return ret_val;
2466
2467 if (phy_data & MII_SR_LINK_STATUS) {
2468 hw->get_link_status = false;
2469 /* Check if there was DownShift, must be checked immediately after
2470 * link-up */
2471 e1000_check_downshift(hw);
2472
2473 /* If we are on 82544 or 82543 silicon and speed/duplex
2474 * are forced to 10H or 10F, then we will implement the polarity
2475 * reversal workaround. We disable interrupts first, and upon
2476 * returning, place the devices interrupt state to its previous
2477 * value except for the link status change interrupt which will
2478 * happen due to the execution of this workaround.
2479 */
2480
2481 if ((hw->mac_type == e1000_82544
2482 || hw->mac_type == e1000_82543) && (!hw->autoneg)
2483 && (hw->forced_speed_duplex == e1000_10_full
2484 || hw->forced_speed_duplex == e1000_10_half)) {
2485 ew32(IMC, 0xffffffff);
2486 ret_val =
2487 e1000_polarity_reversal_workaround(hw);
2488 icr = er32(ICR);
2489 ew32(ICS, (icr & ~E1000_ICS_LSC));
2490 ew32(IMS, IMS_ENABLE_MASK);
2491 }
2492
2493 } else {
2494 /* No link detected */
2495 e1000_config_dsp_after_link_change(hw, false);
2496 return 0;
2497 }
2498
2499 /* If we are forcing speed/duplex, then we simply return since
2500 * we have already determined whether we have link or not.
2501 */
2502 if (!hw->autoneg)
2503 return -E1000_ERR_CONFIG;
2504
2505 /* optimize the dsp settings for the igp phy */
2506 e1000_config_dsp_after_link_change(hw, true);
2507
2508 /* We have a M88E1000 PHY and Auto-Neg is enabled. If we
2509 * have Si on board that is 82544 or newer, Auto
2510 * Speed Detection takes care of MAC speed/duplex
2511 * configuration. So we only need to configure Collision
2512 * Distance in the MAC. Otherwise, we need to force
2513 * speed/duplex on the MAC to the current PHY speed/duplex
2514 * settings.
2515 */
2516 if ((hw->mac_type >= e1000_82544) &&
2517 (hw->mac_type != e1000_ce4100))
2518 e1000_config_collision_dist(hw);
2519 else {
2520 ret_val = e1000_config_mac_to_phy(hw);
2521 if (ret_val) {
2522 e_dbg
2523 ("Error configuring MAC to PHY settings\n");
2524 return ret_val;
2525 }
2526 }
2527
2528 /* Configure Flow Control now that Auto-Neg has completed. First, we
2529 * need to restore the desired flow control settings because we may
2530 * have had to re-autoneg with a different link partner.
2531 */
2532 ret_val = e1000_config_fc_after_link_up(hw);
2533 if (ret_val) {
2534 e_dbg("Error configuring flow control\n");
2535 return ret_val;
2536 }
2537
2538 /* At this point we know that we are on copper and we have
2539 * auto-negotiated link. These are conditions for checking the link
2540 * partner capability register. We use the link speed to determine if
2541 * TBI compatibility needs to be turned on or off. If the link is not
2542 * at gigabit speed, then TBI compatibility is not needed. If we are
2543 * at gigabit speed, we turn on TBI compatibility.
2544 */
2545 if (hw->tbi_compatibility_en) {
2546 u16 speed, duplex;
2547 ret_val =
2548 e1000_get_speed_and_duplex(hw, &speed, &duplex);
2549 if (ret_val) {
2550 e_dbg
2551 ("Error getting link speed and duplex\n");
2552 return ret_val;
2553 }
2554 if (speed != SPEED_1000) {
2555 /* If link speed is not set to gigabit speed, we do not need
2556 * to enable TBI compatibility.
2557 */
2558 if (hw->tbi_compatibility_on) {
2559 /* If we previously were in the mode, turn it off. */
2560 rctl = er32(RCTL);
2561 rctl &= ~E1000_RCTL_SBP;
2562 ew32(RCTL, rctl);
2563 hw->tbi_compatibility_on = false;
2564 }
2565 } else {
2566 /* If TBI compatibility is was previously off, turn it on. For
2567 * compatibility with a TBI link partner, we will store bad
2568 * packets. Some frames have an additional byte on the end and
2569 * will look like CRC errors to to the hardware.
2570 */
2571 if (!hw->tbi_compatibility_on) {
2572 hw->tbi_compatibility_on = true;
2573 rctl = er32(RCTL);
2574 rctl |= E1000_RCTL_SBP;
2575 ew32(RCTL, rctl);
2576 }
2577 }
2578 }
2579 }
2580
2581 if ((hw->media_type == e1000_media_type_fiber) ||
2582 (hw->media_type == e1000_media_type_internal_serdes))
2583 e1000_check_for_serdes_link_generic(hw);
2584
2585 return E1000_SUCCESS;
2586 }
2587
2588 /**
2589 * e1000_get_speed_and_duplex
2590 * @hw: Struct containing variables accessed by shared code
2591 * @speed: Speed of the connection
2592 * @duplex: Duplex setting of the connection
2593
2594 * Detects the current speed and duplex settings of the hardware.
2595 */
2596 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
2597 {
2598 u32 status;
2599 s32 ret_val;
2600 u16 phy_data;
2601
2602 e_dbg("e1000_get_speed_and_duplex");
2603
2604 if (hw->mac_type >= e1000_82543) {
2605 status = er32(STATUS);
2606 if (status & E1000_STATUS_SPEED_1000) {
2607 *speed = SPEED_1000;
2608 e_dbg("1000 Mbs, ");
2609 } else if (status & E1000_STATUS_SPEED_100) {
2610 *speed = SPEED_100;
2611 e_dbg("100 Mbs, ");
2612 } else {
2613 *speed = SPEED_10;
2614 e_dbg("10 Mbs, ");
2615 }
2616
2617 if (status & E1000_STATUS_FD) {
2618 *duplex = FULL_DUPLEX;
2619 e_dbg("Full Duplex\n");
2620 } else {
2621 *duplex = HALF_DUPLEX;
2622 e_dbg(" Half Duplex\n");
2623 }
2624 } else {
2625 e_dbg("1000 Mbs, Full Duplex\n");
2626 *speed = SPEED_1000;
2627 *duplex = FULL_DUPLEX;
2628 }
2629
2630 /* IGP01 PHY may advertise full duplex operation after speed downgrade even
2631 * if it is operating at half duplex. Here we set the duplex settings to
2632 * match the duplex in the link partner's capabilities.
2633 */
2634 if (hw->phy_type == e1000_phy_igp && hw->speed_downgraded) {
2635 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_data);
2636 if (ret_val)
2637 return ret_val;
2638
2639 if (!(phy_data & NWAY_ER_LP_NWAY_CAPS))
2640 *duplex = HALF_DUPLEX;
2641 else {
2642 ret_val =
2643 e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
2644 if (ret_val)
2645 return ret_val;
2646 if ((*speed == SPEED_100
2647 && !(phy_data & NWAY_LPAR_100TX_FD_CAPS))
2648 || (*speed == SPEED_10
2649 && !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
2650 *duplex = HALF_DUPLEX;
2651 }
2652 }
2653
2654 return E1000_SUCCESS;
2655 }
2656
2657 /**
2658 * e1000_wait_autoneg
2659 * @hw: Struct containing variables accessed by shared code
2660 *
2661 * Blocks until autoneg completes or times out (~4.5 seconds)
2662 */
2663 static s32 e1000_wait_autoneg(struct e1000_hw *hw)
2664 {
2665 s32 ret_val;
2666 u16 i;
2667 u16 phy_data;
2668
2669 e_dbg("e1000_wait_autoneg");
2670 e_dbg("Waiting for Auto-Neg to complete.\n");
2671
2672 /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2673 for (i = PHY_AUTO_NEG_TIME; i > 0; i--) {
2674 /* Read the MII Status Register and wait for Auto-Neg
2675 * Complete bit to be set.
2676 */
2677 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2678 if (ret_val)
2679 return ret_val;
2680 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2681 if (ret_val)
2682 return ret_val;
2683 if (phy_data & MII_SR_AUTONEG_COMPLETE) {
2684 return E1000_SUCCESS;
2685 }
2686 msleep(100);
2687 }
2688 return E1000_SUCCESS;
2689 }
2690
2691 /**
2692 * e1000_raise_mdi_clk - Raises the Management Data Clock
2693 * @hw: Struct containing variables accessed by shared code
2694 * @ctrl: Device control register's current value
2695 */
2696 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
2697 {
2698 /* Raise the clock input to the Management Data Clock (by setting the MDC
2699 * bit), and then delay 10 microseconds.
2700 */
2701 ew32(CTRL, (*ctrl | E1000_CTRL_MDC));
2702 E1000_WRITE_FLUSH();
2703 udelay(10);
2704 }
2705
2706 /**
2707 * e1000_lower_mdi_clk - Lowers the Management Data Clock
2708 * @hw: Struct containing variables accessed by shared code
2709 * @ctrl: Device control register's current value
2710 */
2711 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
2712 {
2713 /* Lower the clock input to the Management Data Clock (by clearing the MDC
2714 * bit), and then delay 10 microseconds.
2715 */
2716 ew32(CTRL, (*ctrl & ~E1000_CTRL_MDC));
2717 E1000_WRITE_FLUSH();
2718 udelay(10);
2719 }
2720
2721 /**
2722 * e1000_shift_out_mdi_bits - Shifts data bits out to the PHY
2723 * @hw: Struct containing variables accessed by shared code
2724 * @data: Data to send out to the PHY
2725 * @count: Number of bits to shift out
2726 *
2727 * Bits are shifted out in MSB to LSB order.
2728 */
2729 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data, u16 count)
2730 {
2731 u32 ctrl;
2732 u32 mask;
2733
2734 /* We need to shift "count" number of bits out to the PHY. So, the value
2735 * in the "data" parameter will be shifted out to the PHY one bit at a
2736 * time. In order to do this, "data" must be broken down into bits.
2737 */
2738 mask = 0x01;
2739 mask <<= (count - 1);
2740
2741 ctrl = er32(CTRL);
2742
2743 /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
2744 ctrl |= (E1000_CTRL_MDIO_DIR | E1000_CTRL_MDC_DIR);
2745
2746 while (mask) {
2747 /* A "1" is shifted out to the PHY by setting the MDIO bit to "1" and
2748 * then raising and lowering the Management Data Clock. A "0" is
2749 * shifted out to the PHY by setting the MDIO bit to "0" and then
2750 * raising and lowering the clock.
2751 */
2752 if (data & mask)
2753 ctrl |= E1000_CTRL_MDIO;
2754 else
2755 ctrl &= ~E1000_CTRL_MDIO;
2756
2757 ew32(CTRL, ctrl);
2758 E1000_WRITE_FLUSH();
2759
2760 udelay(10);
2761
2762 e1000_raise_mdi_clk(hw, &ctrl);
2763 e1000_lower_mdi_clk(hw, &ctrl);
2764
2765 mask = mask >> 1;
2766 }
2767 }
2768
2769 /**
2770 * e1000_shift_in_mdi_bits - Shifts data bits in from the PHY
2771 * @hw: Struct containing variables accessed by shared code
2772 *
2773 * Bits are shifted in in MSB to LSB order.
2774 */
2775 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
2776 {
2777 u32 ctrl;
2778 u16 data = 0;
2779 u8 i;
2780
2781 /* In order to read a register from the PHY, we need to shift in a total
2782 * of 18 bits from the PHY. The first two bit (turnaround) times are used
2783 * to avoid contention on the MDIO pin when a read operation is performed.
2784 * These two bits are ignored by us and thrown away. Bits are "shifted in"
2785 * by raising the input to the Management Data Clock (setting the MDC bit),
2786 * and then reading the value of the MDIO bit.
2787 */
2788 ctrl = er32(CTRL);
2789
2790 /* Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as input. */
2791 ctrl &= ~E1000_CTRL_MDIO_DIR;
2792 ctrl &= ~E1000_CTRL_MDIO;
2793
2794 ew32(CTRL, ctrl);
2795 E1000_WRITE_FLUSH();
2796
2797 /* Raise and Lower the clock before reading in the data. This accounts for
2798 * the turnaround bits. The first clock occurred when we clocked out the
2799 * last bit of the Register Address.
2800 */
2801 e1000_raise_mdi_clk(hw, &ctrl);
2802 e1000_lower_mdi_clk(hw, &ctrl);
2803
2804 for (data = 0, i = 0; i < 16; i++) {
2805 data = data << 1;
2806 e1000_raise_mdi_clk(hw, &ctrl);
2807 ctrl = er32(CTRL);
2808 /* Check to see if we shifted in a "1". */
2809 if (ctrl & E1000_CTRL_MDIO)
2810 data |= 1;
2811 e1000_lower_mdi_clk(hw, &ctrl);
2812 }
2813
2814 e1000_raise_mdi_clk(hw, &ctrl);
2815 e1000_lower_mdi_clk(hw, &ctrl);
2816
2817 return data;
2818 }
2819
2820
2821 /**
2822 * e1000_read_phy_reg - read a phy register
2823 * @hw: Struct containing variables accessed by shared code
2824 * @reg_addr: address of the PHY register to read
2825 *
2826 * Reads the value from a PHY register, if the value is on a specific non zero
2827 * page, sets the page first.
2828 */
2829 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
2830 {
2831 u32 ret_val;
2832
2833 e_dbg("e1000_read_phy_reg");
2834
2835 if ((hw->phy_type == e1000_phy_igp) &&
2836 (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
2837 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
2838 (u16) reg_addr);
2839 if (ret_val)
2840 return ret_val;
2841 }
2842
2843 ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
2844 phy_data);
2845
2846 return ret_val;
2847 }
2848
2849 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
2850 u16 *phy_data)
2851 {
2852 u32 i;
2853 u32 mdic = 0;
2854 const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1;
2855
2856 e_dbg("e1000_read_phy_reg_ex");
2857
2858 if (reg_addr > MAX_PHY_REG_ADDRESS) {
2859 e_dbg("PHY Address %d is out of range\n", reg_addr);
2860 return -E1000_ERR_PARAM;
2861 }
2862
2863 if (hw->mac_type > e1000_82543) {
2864 /* Set up Op-code, Phy Address, and register address in the MDI
2865 * Control register. The MAC will take care of interfacing with the
2866 * PHY to retrieve the desired data.
2867 */
2868 if (hw->mac_type == e1000_ce4100) {
2869 mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
2870 (phy_addr << E1000_MDIC_PHY_SHIFT) |
2871 (INTEL_CE_GBE_MDIC_OP_READ) |
2872 (INTEL_CE_GBE_MDIC_GO));
2873
2874 writel(mdic, E1000_MDIO_CMD);
2875
2876 /* Poll the ready bit to see if the MDI read
2877 * completed
2878 */
2879 for (i = 0; i < 64; i++) {
2880 udelay(50);
2881 mdic = readl(E1000_MDIO_CMD);
2882 if (!(mdic & INTEL_CE_GBE_MDIC_GO))
2883 break;
2884 }
2885
2886 if (mdic & INTEL_CE_GBE_MDIC_GO) {
2887 e_dbg("MDI Read did not complete\n");
2888 return -E1000_ERR_PHY;
2889 }
2890
2891 mdic = readl(E1000_MDIO_STS);
2892 if (mdic & INTEL_CE_GBE_MDIC_READ_ERROR) {
2893 e_dbg("MDI Read Error\n");
2894 return -E1000_ERR_PHY;
2895 }
2896 *phy_data = (u16) mdic;
2897 } else {
2898 mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
2899 (phy_addr << E1000_MDIC_PHY_SHIFT) |
2900 (E1000_MDIC_OP_READ));
2901
2902 ew32(MDIC, mdic);
2903
2904 /* Poll the ready bit to see if the MDI read
2905 * completed
2906 */
2907 for (i = 0; i < 64; i++) {
2908 udelay(50);
2909 mdic = er32(MDIC);
2910 if (mdic & E1000_MDIC_READY)
2911 break;
2912 }
2913 if (!(mdic & E1000_MDIC_READY)) {
2914 e_dbg("MDI Read did not complete\n");
2915 return -E1000_ERR_PHY;
2916 }
2917 if (mdic & E1000_MDIC_ERROR) {
2918 e_dbg("MDI Error\n");
2919 return -E1000_ERR_PHY;
2920 }
2921 *phy_data = (u16) mdic;
2922 }
2923 } else {
2924 /* We must first send a preamble through the MDIO pin to signal the
2925 * beginning of an MII instruction. This is done by sending 32
2926 * consecutive "1" bits.
2927 */
2928 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
2929
2930 /* Now combine the next few fields that are required for a read
2931 * operation. We use this method instead of calling the
2932 * e1000_shift_out_mdi_bits routine five different times. The format of
2933 * a MII read instruction consists of a shift out of 14 bits and is
2934 * defined as follows:
2935 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr>
2936 * followed by a shift in of 18 bits. This first two bits shifted in
2937 * are TurnAround bits used to avoid contention on the MDIO pin when a
2938 * READ operation is performed. These two bits are thrown away
2939 * followed by a shift in of 16 bits which contains the desired data.
2940 */
2941 mdic = ((reg_addr) | (phy_addr << 5) |
2942 (PHY_OP_READ << 10) | (PHY_SOF << 12));
2943
2944 e1000_shift_out_mdi_bits(hw, mdic, 14);
2945
2946 /* Now that we've shifted out the read command to the MII, we need to
2947 * "shift in" the 16-bit value (18 total bits) of the requested PHY
2948 * register address.
2949 */
2950 *phy_data = e1000_shift_in_mdi_bits(hw);
2951 }
2952 return E1000_SUCCESS;
2953 }
2954
2955 /**
2956 * e1000_write_phy_reg - write a phy register
2957 *
2958 * @hw: Struct containing variables accessed by shared code
2959 * @reg_addr: address of the PHY register to write
2960 * @data: data to write to the PHY
2961
2962 * Writes a value to a PHY register
2963 */
2964 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
2965 {
2966 u32 ret_val;
2967
2968 e_dbg("e1000_write_phy_reg");
2969
2970 if ((hw->phy_type == e1000_phy_igp) &&
2971 (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
2972 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
2973 (u16) reg_addr);
2974 if (ret_val)
2975 return ret_val;
2976 }
2977
2978 ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
2979 phy_data);
2980
2981 return ret_val;
2982 }
2983
2984 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
2985 u16 phy_data)
2986 {
2987 u32 i;
2988 u32 mdic = 0;
2989 const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1;
2990
2991 e_dbg("e1000_write_phy_reg_ex");
2992
2993 if (reg_addr > MAX_PHY_REG_ADDRESS) {
2994 e_dbg("PHY Address %d is out of range\n", reg_addr);
2995 return -E1000_ERR_PARAM;
2996 }
2997
2998 if (hw->mac_type > e1000_82543) {
2999 /* Set up Op-code, Phy Address, register address, and data
3000 * intended for the PHY register in the MDI Control register.
3001 * The MAC will take care of interfacing with the PHY to send
3002 * the desired data.
3003 */
3004 if (hw->mac_type == e1000_ce4100) {
3005 mdic = (((u32) phy_data) |
3006 (reg_addr << E1000_MDIC_REG_SHIFT) |
3007 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3008 (INTEL_CE_GBE_MDIC_OP_WRITE) |
3009 (INTEL_CE_GBE_MDIC_GO));
3010
3011 writel(mdic, E1000_MDIO_CMD);
3012
3013 /* Poll the ready bit to see if the MDI read
3014 * completed
3015 */
3016 for (i = 0; i < 640; i++) {
3017 udelay(5);
3018 mdic = readl(E1000_MDIO_CMD);
3019 if (!(mdic & INTEL_CE_GBE_MDIC_GO))
3020 break;
3021 }
3022 if (mdic & INTEL_CE_GBE_MDIC_GO) {
3023 e_dbg("MDI Write did not complete\n");
3024 return -E1000_ERR_PHY;
3025 }
3026 } else {
3027 mdic = (((u32) phy_data) |
3028 (reg_addr << E1000_MDIC_REG_SHIFT) |
3029 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3030 (E1000_MDIC_OP_WRITE));
3031
3032 ew32(MDIC, mdic);
3033
3034 /* Poll the ready bit to see if the MDI read
3035 * completed
3036 */
3037 for (i = 0; i < 641; i++) {
3038 udelay(5);
3039 mdic = er32(MDIC);
3040 if (mdic & E1000_MDIC_READY)
3041 break;
3042 }
3043 if (!(mdic & E1000_MDIC_READY)) {
3044 e_dbg("MDI Write did not complete\n");
3045 return -E1000_ERR_PHY;
3046 }
3047 }
3048 } else {
3049 /* We'll need to use the SW defined pins to shift the write command
3050 * out to the PHY. We first send a preamble to the PHY to signal the
3051 * beginning of the MII instruction. This is done by sending 32
3052 * consecutive "1" bits.
3053 */
3054 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3055
3056 /* Now combine the remaining required fields that will indicate a
3057 * write operation. We use this method instead of calling the
3058 * e1000_shift_out_mdi_bits routine for each field in the command. The
3059 * format of a MII write instruction is as follows:
3060 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr><Turnaround><Data>.
3061 */
3062 mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) |
3063 (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
3064 mdic <<= 16;
3065 mdic |= (u32) phy_data;
3066
3067 e1000_shift_out_mdi_bits(hw, mdic, 32);
3068 }
3069
3070 return E1000_SUCCESS;
3071 }
3072
3073 /**
3074 * e1000_phy_hw_reset - reset the phy, hardware style
3075 * @hw: Struct containing variables accessed by shared code
3076 *
3077 * Returns the PHY to the power-on reset state
3078 */
3079 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
3080 {
3081 u32 ctrl, ctrl_ext;
3082 u32 led_ctrl;
3083 s32 ret_val;
3084
3085 e_dbg("e1000_phy_hw_reset");
3086
3087 e_dbg("Resetting Phy...\n");
3088
3089 if (hw->mac_type > e1000_82543) {
3090 /* Read the device control register and assert the E1000_CTRL_PHY_RST
3091 * bit. Then, take it out of reset.
3092 * For e1000 hardware, we delay for 10ms between the assert
3093 * and deassert.
3094 */
3095 ctrl = er32(CTRL);
3096 ew32(CTRL, ctrl | E1000_CTRL_PHY_RST);
3097 E1000_WRITE_FLUSH();
3098
3099 msleep(10);
3100
3101 ew32(CTRL, ctrl);
3102 E1000_WRITE_FLUSH();
3103
3104 } else {
3105 /* Read the Extended Device Control Register, assert the PHY_RESET_DIR
3106 * bit to put the PHY into reset. Then, take it out of reset.
3107 */
3108 ctrl_ext = er32(CTRL_EXT);
3109 ctrl_ext |= E1000_CTRL_EXT_SDP4_DIR;
3110 ctrl_ext &= ~E1000_CTRL_EXT_SDP4_DATA;
3111 ew32(CTRL_EXT, ctrl_ext);
3112 E1000_WRITE_FLUSH();
3113 msleep(10);
3114 ctrl_ext |= E1000_CTRL_EXT_SDP4_DATA;
3115 ew32(CTRL_EXT, ctrl_ext);
3116 E1000_WRITE_FLUSH();
3117 }
3118 udelay(150);
3119
3120 if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
3121 /* Configure activity LED after PHY reset */
3122 led_ctrl = er32(LEDCTL);
3123 led_ctrl &= IGP_ACTIVITY_LED_MASK;
3124 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
3125 ew32(LEDCTL, led_ctrl);
3126 }
3127
3128 /* Wait for FW to finish PHY configuration. */
3129 ret_val = e1000_get_phy_cfg_done(hw);
3130 if (ret_val != E1000_SUCCESS)
3131 return ret_val;
3132
3133 return ret_val;
3134 }
3135
3136 /**
3137 * e1000_phy_reset - reset the phy to commit settings
3138 * @hw: Struct containing variables accessed by shared code
3139 *
3140 * Resets the PHY
3141 * Sets bit 15 of the MII Control register
3142 */
3143 s32 e1000_phy_reset(struct e1000_hw *hw)
3144 {
3145 s32 ret_val;
3146 u16 phy_data;
3147
3148 e_dbg("e1000_phy_reset");
3149
3150 switch (hw->phy_type) {
3151 case e1000_phy_igp:
3152 ret_val = e1000_phy_hw_reset(hw);
3153 if (ret_val)
3154 return ret_val;
3155 break;
3156 default:
3157 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
3158 if (ret_val)
3159 return ret_val;
3160
3161 phy_data |= MII_CR_RESET;
3162 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
3163 if (ret_val)
3164 return ret_val;
3165
3166 udelay(1);
3167 break;
3168 }
3169
3170 if (hw->phy_type == e1000_phy_igp)
3171 e1000_phy_init_script(hw);
3172
3173 return E1000_SUCCESS;
3174 }
3175
3176 /**
3177 * e1000_detect_gig_phy - check the phy type
3178 * @hw: Struct containing variables accessed by shared code
3179 *
3180 * Probes the expected PHY address for known PHY IDs
3181 */
3182 static s32 e1000_detect_gig_phy(struct e1000_hw *hw)
3183 {
3184 s32 phy_init_status, ret_val;
3185 u16 phy_id_high, phy_id_low;
3186 bool match = false;
3187
3188 e_dbg("e1000_detect_gig_phy");
3189
3190 if (hw->phy_id != 0)
3191 return E1000_SUCCESS;
3192
3193 /* Read the PHY ID Registers to identify which PHY is onboard. */
3194 ret_val = e1000_read_phy_reg(hw, PHY_ID1, &phy_id_high);
3195 if (ret_val)
3196 return ret_val;
3197
3198 hw->phy_id = (u32) (phy_id_high << 16);
3199 udelay(20);
3200 ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low);
3201 if (ret_val)
3202 return ret_val;
3203
3204 hw->phy_id |= (u32) (phy_id_low & PHY_REVISION_MASK);
3205 hw->phy_revision = (u32) phy_id_low & ~PHY_REVISION_MASK;
3206
3207 switch (hw->mac_type) {
3208 case e1000_82543:
3209 if (hw->phy_id == M88E1000_E_PHY_ID)
3210 match = true;
3211 break;
3212 case e1000_82544:
3213 if (hw->phy_id == M88E1000_I_PHY_ID)
3214 match = true;
3215 break;
3216 case e1000_82540:
3217 case e1000_82545:
3218 case e1000_82545_rev_3:
3219 case e1000_82546:
3220 case e1000_82546_rev_3:
3221 if (hw->phy_id == M88E1011_I_PHY_ID)
3222 match = true;
3223 break;
3224 case e1000_ce4100:
3225 if ((hw->phy_id == RTL8211B_PHY_ID) ||
3226 (hw->phy_id == RTL8201N_PHY_ID) ||
3227 (hw->phy_id == M88E1118_E_PHY_ID))
3228 match = true;
3229 break;
3230 case e1000_82541:
3231 case e1000_82541_rev_2:
3232 case e1000_82547:
3233 case e1000_82547_rev_2:
3234 if (hw->phy_id == IGP01E1000_I_PHY_ID)
3235 match = true;
3236 break;
3237 default:
3238 e_dbg("Invalid MAC type %d\n", hw->mac_type);
3239 return -E1000_ERR_CONFIG;
3240 }
3241 phy_init_status = e1000_set_phy_type(hw);
3242
3243 if ((match) && (phy_init_status == E1000_SUCCESS)) {
3244 e_dbg("PHY ID 0x%X detected\n", hw->phy_id);
3245 return E1000_SUCCESS;
3246 }
3247 e_dbg("Invalid PHY ID 0x%X\n", hw->phy_id);
3248 return -E1000_ERR_PHY;
3249 }
3250
3251 /**
3252 * e1000_phy_reset_dsp - reset DSP
3253 * @hw: Struct containing variables accessed by shared code
3254 *
3255 * Resets the PHY's DSP
3256 */
3257 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw)
3258 {
3259 s32 ret_val;
3260 e_dbg("e1000_phy_reset_dsp");
3261
3262 do {
3263 ret_val = e1000_write_phy_reg(hw, 29, 0x001d);
3264 if (ret_val)
3265 break;
3266 ret_val = e1000_write_phy_reg(hw, 30, 0x00c1);
3267 if (ret_val)
3268 break;
3269 ret_val = e1000_write_phy_reg(hw, 30, 0x0000);
3270 if (ret_val)
3271 break;
3272 ret_val = E1000_SUCCESS;
3273 } while (0);
3274
3275 return ret_val;
3276 }
3277
3278 /**
3279 * e1000_phy_igp_get_info - get igp specific registers
3280 * @hw: Struct containing variables accessed by shared code
3281 * @phy_info: PHY information structure
3282 *
3283 * Get PHY information from various PHY registers for igp PHY only.
3284 */
3285 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
3286 struct e1000_phy_info *phy_info)
3287 {
3288 s32 ret_val;
3289 u16 phy_data, min_length, max_length, average;
3290 e1000_rev_polarity polarity;
3291
3292 e_dbg("e1000_phy_igp_get_info");
3293
3294 /* The downshift status is checked only once, after link is established,
3295 * and it stored in the hw->speed_downgraded parameter. */
3296 phy_info->downshift = (e1000_downshift) hw->speed_downgraded;
3297
3298 /* IGP01E1000 does not need to support it. */
3299 phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
3300
3301 /* IGP01E1000 always correct polarity reversal */
3302 phy_info->polarity_correction = e1000_polarity_reversal_enabled;
3303
3304 /* Check polarity status */
3305 ret_val = e1000_check_polarity(hw, &polarity);
3306 if (ret_val)
3307 return ret_val;
3308
3309 phy_info->cable_polarity = polarity;
3310
3311 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS, &phy_data);
3312 if (ret_val)
3313 return ret_val;
3314
3315 phy_info->mdix_mode =
3316 (e1000_auto_x_mode) ((phy_data & IGP01E1000_PSSR_MDIX) >>
3317 IGP01E1000_PSSR_MDIX_SHIFT);
3318
3319 if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
3320 IGP01E1000_PSSR_SPEED_1000MBPS) {
3321 /* Local/Remote Receiver Information are only valid at 1000 Mbps */
3322 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
3323 if (ret_val)
3324 return ret_val;
3325
3326 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
3327 SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
3328 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3329 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
3330 SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
3331 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3332
3333 /* Get cable length */
3334 ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
3335 if (ret_val)
3336 return ret_val;
3337
3338 /* Translate to old method */
3339 average = (max_length + min_length) / 2;
3340
3341 if (average <= e1000_igp_cable_length_50)
3342 phy_info->cable_length = e1000_cable_length_50;
3343 else if (average <= e1000_igp_cable_length_80)
3344 phy_info->cable_length = e1000_cable_length_50_80;
3345 else if (average <= e1000_igp_cable_length_110)
3346 phy_info->cable_length = e1000_cable_length_80_110;
3347 else if (average <= e1000_igp_cable_length_140)
3348 phy_info->cable_length = e1000_cable_length_110_140;
3349 else
3350 phy_info->cable_length = e1000_cable_length_140;
3351 }
3352
3353 return E1000_SUCCESS;
3354 }
3355
3356 /**
3357 * e1000_phy_m88_get_info - get m88 specific registers
3358 * @hw: Struct containing variables accessed by shared code
3359 * @phy_info: PHY information structure
3360 *
3361 * Get PHY information from various PHY registers for m88 PHY only.
3362 */
3363 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
3364 struct e1000_phy_info *phy_info)
3365 {
3366 s32 ret_val;
3367 u16 phy_data;
3368 e1000_rev_polarity polarity;
3369
3370 e_dbg("e1000_phy_m88_get_info");
3371
3372 /* The downshift status is checked only once, after link is established,
3373 * and it stored in the hw->speed_downgraded parameter. */
3374 phy_info->downshift = (e1000_downshift) hw->speed_downgraded;
3375
3376 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
3377 if (ret_val)
3378 return ret_val;
3379
3380 phy_info->extended_10bt_distance =
3381 ((phy_data & M88E1000_PSCR_10BT_EXT_DIST_ENABLE) >>
3382 M88E1000_PSCR_10BT_EXT_DIST_ENABLE_SHIFT) ?
3383 e1000_10bt_ext_dist_enable_lower :
3384 e1000_10bt_ext_dist_enable_normal;
3385
3386 phy_info->polarity_correction =
3387 ((phy_data & M88E1000_PSCR_POLARITY_REVERSAL) >>
3388 M88E1000_PSCR_POLARITY_REVERSAL_SHIFT) ?
3389 e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
3390
3391 /* Check polarity status */
3392 ret_val = e1000_check_polarity(hw, &polarity);
3393 if (ret_val)
3394 return ret_val;
3395 phy_info->cable_polarity = polarity;
3396
3397 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
3398 if (ret_val)
3399 return ret_val;
3400
3401 phy_info->mdix_mode =
3402 (e1000_auto_x_mode) ((phy_data & M88E1000_PSSR_MDIX) >>
3403 M88E1000_PSSR_MDIX_SHIFT);
3404
3405 if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
3406 /* Cable Length Estimation and Local/Remote Receiver Information
3407 * are only valid at 1000 Mbps.
3408 */
3409 phy_info->cable_length =
3410 (e1000_cable_length) ((phy_data &
3411 M88E1000_PSSR_CABLE_LENGTH) >>
3412 M88E1000_PSSR_CABLE_LENGTH_SHIFT);
3413
3414 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
3415 if (ret_val)
3416 return ret_val;
3417
3418 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
3419 SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
3420 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3421 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
3422 SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
3423 e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3424
3425 }
3426
3427 return E1000_SUCCESS;
3428 }
3429
3430 /**
3431 * e1000_phy_get_info - request phy info
3432 * @hw: Struct containing variables accessed by shared code
3433 * @phy_info: PHY information structure
3434 *
3435 * Get PHY information from various PHY registers
3436 */
3437 s32 e1000_phy_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info)
3438 {
3439 s32 ret_val;
3440 u16 phy_data;
3441
3442 e_dbg("e1000_phy_get_info");
3443
3444 phy_info->cable_length = e1000_cable_length_undefined;
3445 phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_undefined;
3446 phy_info->cable_polarity = e1000_rev_polarity_undefined;
3447 phy_info->downshift = e1000_downshift_undefined;
3448 phy_info->polarity_correction = e1000_polarity_reversal_undefined;
3449 phy_info->mdix_mode = e1000_auto_x_mode_undefined;
3450 phy_info->local_rx = e1000_1000t_rx_status_undefined;
3451 phy_info->remote_rx = e1000_1000t_rx_status_undefined;
3452
3453 if (hw->media_type != e1000_media_type_copper) {
3454 e_dbg("PHY info is only valid for copper media\n");
3455 return -E1000_ERR_CONFIG;
3456 }
3457
3458 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3459 if (ret_val)
3460 return ret_val;
3461
3462 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3463 if (ret_val)
3464 return ret_val;
3465
3466 if ((phy_data & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) {
3467 e_dbg("PHY info is only valid if link is up\n");
3468 return -E1000_ERR_CONFIG;
3469 }
3470
3471 if (hw->phy_type == e1000_phy_igp)
3472 return e1000_phy_igp_get_info(hw, phy_info);
3473 else if ((hw->phy_type == e1000_phy_8211) ||
3474 (hw->phy_type == e1000_phy_8201))
3475 return E1000_SUCCESS;
3476 else
3477 return e1000_phy_m88_get_info(hw, phy_info);
3478 }
3479
3480 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
3481 {
3482 e_dbg("e1000_validate_mdi_settings");
3483
3484 if (!hw->autoneg && (hw->mdix == 0 || hw->mdix == 3)) {
3485 e_dbg("Invalid MDI setting detected\n");
3486 hw->mdix = 1;
3487 return -E1000_ERR_CONFIG;
3488 }
3489 return E1000_SUCCESS;
3490 }
3491
3492 /**
3493 * e1000_init_eeprom_params - initialize sw eeprom vars
3494 * @hw: Struct containing variables accessed by shared code
3495 *
3496 * Sets up eeprom variables in the hw struct. Must be called after mac_type
3497 * is configured.
3498 */
3499 s32 e1000_init_eeprom_params(struct e1000_hw *hw)
3500 {
3501 struct e1000_eeprom_info *eeprom = &hw->eeprom;
3502 u32 eecd = er32(EECD);
3503 s32 ret_val = E1000_SUCCESS;
3504 u16 eeprom_size;
3505
3506 e_dbg("e1000_init_eeprom_params");
3507
3508 switch (hw->mac_type) {
3509 case e1000_82542_rev2_0:
3510 case e1000_82542_rev2_1:
3511 case e1000_82543:
3512 case e1000_82544:
3513 eeprom->type = e1000_eeprom_microwire;
3514 eeprom->word_size = 64;
3515 eeprom->opcode_bits = 3;
3516 eeprom->address_bits = 6;
3517 eeprom->delay_usec = 50;
3518 break;
3519 case e1000_82540:
3520 case e1000_82545:
3521 case e1000_82545_rev_3:
3522 case e1000_82546:
3523 case e1000_82546_rev_3:
3524 eeprom->type = e1000_eeprom_microwire;
3525 eeprom->opcode_bits = 3;
3526 eeprom->delay_usec = 50;
3527 if (eecd & E1000_EECD_SIZE) {
3528 eeprom->word_size = 256;
3529 eeprom->address_bits = 8;
3530 } else {
3531 eeprom->word_size = 64;
3532 eeprom->address_bits = 6;
3533 }
3534 break;
3535 case e1000_82541:
3536 case e1000_82541_rev_2:
3537 case e1000_82547:
3538 case e1000_82547_rev_2:
3539 if (eecd & E1000_EECD_TYPE) {
3540 eeprom->type = e1000_eeprom_spi;
3541 eeprom->opcode_bits = 8;
3542 eeprom->delay_usec = 1;
3543 if (eecd & E1000_EECD_ADDR_BITS) {
3544 eeprom->page_size = 32;
3545 eeprom->address_bits = 16;
3546 } else {
3547 eeprom->page_size = 8;
3548 eeprom->address_bits = 8;
3549 }
3550 } else {
3551 eeprom->type = e1000_eeprom_microwire;
3552 eeprom->opcode_bits = 3;
3553 eeprom->delay_usec = 50;
3554 if (eecd & E1000_EECD_ADDR_BITS) {
3555 eeprom->word_size = 256;
3556 eeprom->address_bits = 8;
3557 } else {
3558 eeprom->word_size = 64;
3559 eeprom->address_bits = 6;
3560 }
3561 }
3562 break;
3563 default:
3564 break;
3565 }
3566
3567 if (eeprom->type == e1000_eeprom_spi) {
3568 /* eeprom_size will be an enum [0..8] that maps to eeprom sizes 128B to
3569 * 32KB (incremented by powers of 2).
3570 */
3571 /* Set to default value for initial eeprom read. */
3572 eeprom->word_size = 64;
3573 ret_val = e1000_read_eeprom(hw, EEPROM_CFG, 1, &eeprom_size);
3574 if (ret_val)
3575 return ret_val;
3576 eeprom_size =
3577 (eeprom_size & EEPROM_SIZE_MASK) >> EEPROM_SIZE_SHIFT;
3578 /* 256B eeprom size was not supported in earlier hardware, so we
3579 * bump eeprom_size up one to ensure that "1" (which maps to 256B)
3580 * is never the result used in the shifting logic below. */
3581 if (eeprom_size)
3582 eeprom_size++;
3583
3584 eeprom->word_size = 1 << (eeprom_size + EEPROM_WORD_SIZE_SHIFT);
3585 }
3586 return ret_val;
3587 }
3588
3589 /**
3590 * e1000_raise_ee_clk - Raises the EEPROM's clock input.
3591 * @hw: Struct containing variables accessed by shared code
3592 * @eecd: EECD's current value
3593 */
3594 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd)
3595 {
3596 /* Raise the clock input to the EEPROM (by setting the SK bit), and then
3597 * wait <delay> microseconds.
3598 */
3599 *eecd = *eecd | E1000_EECD_SK;
3600 ew32(EECD, *eecd);
3601 E1000_WRITE_FLUSH();
3602 udelay(hw->eeprom.delay_usec);
3603 }
3604
3605 /**
3606 * e1000_lower_ee_clk - Lowers the EEPROM's clock input.
3607 * @hw: Struct containing variables accessed by shared code
3608 * @eecd: EECD's current value
3609 */
3610 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd)
3611 {
3612 /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
3613 * wait 50 microseconds.
3614 */
3615 *eecd = *eecd & ~E1000_EECD_SK;
3616 ew32(EECD, *eecd);
3617 E1000_WRITE_FLUSH();
3618 udelay(hw->eeprom.delay_usec);
3619 }
3620
3621 /**
3622 * e1000_shift_out_ee_bits - Shift data bits out to the EEPROM.
3623 * @hw: Struct containing variables accessed by shared code
3624 * @data: data to send to the EEPROM
3625 * @count: number of bits to shift out
3626 */
3627 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count)
3628 {
3629 struct e1000_eeprom_info *eeprom = &hw->eeprom;
3630 u32 eecd;
3631 u32 mask;
3632
3633 /* We need to shift "count" bits out to the EEPROM. So, value in the
3634 * "data" parameter will be shifted out to the EEPROM one bit at a time.
3635 * In order to do this, "data" must be broken down into bits.
3636 */
3637 mask = 0x01 << (count - 1);
3638 eecd = er32(EECD);
3639 if (eeprom->type == e1000_eeprom_microwire) {
3640 eecd &= ~E1000_EECD_DO;
3641 } else if (eeprom->type == e1000_eeprom_spi) {
3642 eecd |= E1000_EECD_DO;
3643 }
3644 do {
3645 /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
3646 * and then raising and then lowering the clock (the SK bit controls
3647 * the clock input to the EEPROM). A "0" is shifted out to the EEPROM
3648 * by setting "DI" to "0" and then raising and then lowering the clock.
3649 */
3650 eecd &= ~E1000_EECD_DI;
3651
3652 if (data & mask)
3653 eecd |= E1000_EECD_DI;
3654
3655 ew32(EECD, eecd);
3656 E1000_WRITE_FLUSH();
3657
3658 udelay(eeprom->delay_usec);
3659
3660 e1000_raise_ee_clk(hw, &eecd);
3661 e1000_lower_ee_clk(hw, &eecd);
3662
3663 mask = mask >> 1;
3664
3665 } while (mask);
3666
3667 /* We leave the "DI" bit set to "0" when we leave this routine. */
3668 eecd &= ~E1000_EECD_DI;
3669 ew32(EECD, eecd);
3670 }
3671
3672 /**
3673 * e1000_shift_in_ee_bits - Shift data bits in from the EEPROM
3674 * @hw: Struct containing variables accessed by shared code
3675 * @count: number of bits to shift in
3676 */
3677 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count)
3678 {
3679 u32 eecd;
3680 u32 i;
3681 u16 data;
3682
3683 /* In order to read a register from the EEPROM, we need to shift 'count'
3684 * bits in from the EEPROM. Bits are "shifted in" by raising the clock
3685 * input to the EEPROM (setting the SK bit), and then reading the value of
3686 * the "DO" bit. During this "shifting in" process the "DI" bit should
3687 * always be clear.
3688 */
3689
3690 eecd = er32(EECD);
3691
3692 eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
3693 data = 0;
3694
3695 for (i = 0; i < count; i++) {
3696 data = data << 1;
3697 e1000_raise_ee_clk(hw, &eecd);
3698
3699 eecd = er32(EECD);
3700
3701 eecd &= ~(E1000_EECD_DI);
3702 if (eecd & E1000_EECD_DO)
3703 data |= 1;
3704
3705 e1000_lower_ee_clk(hw, &eecd);
3706 }
3707
3708 return data;
3709 }
3710
3711 /**
3712 * e1000_acquire_eeprom - Prepares EEPROM for access
3713 * @hw: Struct containing variables accessed by shared code
3714 *
3715 * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
3716 * function should be called before issuing a command to the EEPROM.
3717 */
3718 static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
3719 {
3720 struct e1000_eeprom_info *eeprom = &hw->eeprom;
3721 u32 eecd, i = 0;
3722
3723 e_dbg("e1000_acquire_eeprom");
3724
3725 eecd = er32(EECD);
3726
3727 /* Request EEPROM Access */
3728 if (hw->mac_type > e1000_82544) {
3729 eecd |= E1000_EECD_REQ;
3730 ew32(EECD, eecd);
3731 eecd = er32(EECD);
3732 while ((!(eecd & E1000_EECD_GNT)) &&
3733 (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
3734 i++;
3735 udelay(5);
3736 eecd = er32(EECD);
3737 }
3738 if (!(eecd & E1000_EECD_GNT)) {
3739 eecd &= ~E1000_EECD_REQ;
3740 ew32(EECD, eecd);
3741 e_dbg("Could not acquire EEPROM grant\n");
3742 return -E1000_ERR_EEPROM;
3743 }
3744 }
3745
3746 /* Setup EEPROM for Read/Write */
3747
3748 if (eeprom->type == e1000_eeprom_microwire) {
3749 /* Clear SK and DI */
3750 eecd &= ~(E1000_EECD_DI | E1000_EECD_SK);
3751 ew32(EECD, eecd);
3752
3753 /* Set CS */
3754 eecd |= E1000_EECD_CS;
3755 ew32(EECD, eecd);
3756 } else if (eeprom->type == e1000_eeprom_spi) {
3757 /* Clear SK and CS */
3758 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
3759 ew32(EECD, eecd);
3760 udelay(1);
3761 }
3762
3763 return E1000_SUCCESS;
3764 }
3765
3766 /**
3767 * e1000_standby_eeprom - Returns EEPROM to a "standby" state
3768 * @hw: Struct containing variables accessed by shared code
3769 */
3770 static void e1000_standby_eeprom(struct e1000_hw *hw)
3771 {
3772 struct e1000_eeprom_info *eeprom = &hw->eeprom;
3773 u32 eecd;
3774
3775 eecd = er32(EECD);
3776
3777 if (eeprom->type == e1000_eeprom_microwire) {
3778 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
3779 ew32(EECD, eecd);
3780 E1000_WRITE_FLUSH();
3781 udelay(eeprom->delay_usec);
3782
3783 /* Clock high */
3784 eecd |= E1000_EECD_SK;
3785 ew32(EECD, eecd);
3786 E1000_WRITE_FLUSH();
3787 udelay(eeprom->delay_usec);
3788
3789 /* Select EEPROM */
3790 eecd |= E1000_EECD_CS;
3791 ew32(EECD, eecd);
3792 E1000_WRITE_FLUSH();
3793 udelay(eeprom->delay_usec);
3794
3795 /* Clock low */
3796 eecd &= ~E1000_EECD_SK;
3797 ew32(EECD, eecd);
3798 E1000_WRITE_FLUSH();
3799 udelay(eeprom->delay_usec);
3800 } else if (eeprom->type == e1000_eeprom_spi) {
3801 /* Toggle CS to flush commands */
3802 eecd |= E1000_EECD_CS;
3803 ew32(EECD, eecd);
3804 E1000_WRITE_FLUSH();
3805 udelay(eeprom->delay_usec);
3806 eecd &= ~E1000_EECD_CS;
3807 ew32(EECD, eecd);
3808 E1000_WRITE_FLUSH();
3809 udelay(eeprom->delay_usec);
3810 }
3811 }
3812
3813 /**
3814 * e1000_release_eeprom - drop chip select
3815 * @hw: Struct containing variables accessed by shared code
3816 *
3817 * Terminates a command by inverting the EEPROM's chip select pin
3818 */
3819 static void e1000_release_eeprom(struct e1000_hw *hw)
3820 {
3821 u32 eecd;
3822
3823 e_dbg("e1000_release_eeprom");
3824
3825 eecd = er32(EECD);
3826
3827 if (hw->eeprom.type == e1000_eeprom_spi) {
3828 eecd |= E1000_EECD_CS; /* Pull CS high */
3829 eecd &= ~E1000_EECD_SK; /* Lower SCK */
3830
3831 ew32(EECD, eecd);
3832
3833 udelay(hw->eeprom.delay_usec);
3834 } else if (hw->eeprom.type == e1000_eeprom_microwire) {
3835 /* cleanup eeprom */
3836
3837 /* CS on Microwire is active-high */
3838 eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
3839
3840 ew32(EECD, eecd);
3841
3842 /* Rising edge of clock */
3843 eecd |= E1000_EECD_SK;
3844 ew32(EECD, eecd);
3845 E1000_WRITE_FLUSH();
3846 udelay(hw->eeprom.delay_usec);
3847
3848 /* Falling edge of clock */
3849 eecd &= ~E1000_EECD_SK;
3850 ew32(EECD, eecd);
3851 E1000_WRITE_FLUSH();
3852 udelay(hw->eeprom.delay_usec);
3853 }
3854
3855 /* Stop requesting EEPROM access */
3856 if (hw->mac_type > e1000_82544) {
3857 eecd &= ~E1000_EECD_REQ;
3858 ew32(EECD, eecd);
3859 }
3860 }
3861
3862 /**
3863 * e1000_spi_eeprom_ready - Reads a 16 bit word from the EEPROM.
3864 * @hw: Struct containing variables accessed by shared code
3865 */
3866 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw)
3867 {
3868 u16 retry_count = 0;
3869 u8 spi_stat_reg;
3870
3871 e_dbg("e1000_spi_eeprom_ready");
3872
3873 /* Read "Status Register" repeatedly until the LSB is cleared. The
3874 * EEPROM will signal that the command has been completed by clearing
3875 * bit 0 of the internal status register. If it's not cleared within
3876 * 5 milliseconds, then error out.
3877 */
3878 retry_count = 0;
3879 do {
3880 e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI,
3881 hw->eeprom.opcode_bits);
3882 spi_stat_reg = (u8) e1000_shift_in_ee_bits(hw, 8);
3883 if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI))
3884 break;
3885
3886 udelay(5);
3887 retry_count += 5;
3888
3889 e1000_standby_eeprom(hw);
3890 } while (retry_count < EEPROM_MAX_RETRY_SPI);
3891
3892 /* ATMEL SPI write time could vary from 0-20mSec on 3.3V devices (and
3893 * only 0-5mSec on 5V devices)
3894 */
3895 if (retry_count >= EEPROM_MAX_RETRY_SPI) {
3896 e_dbg("SPI EEPROM Status error\n");
3897 return -E1000_ERR_EEPROM;
3898 }
3899
3900 return E1000_SUCCESS;
3901 }
3902
3903 /**
3904 * e1000_read_eeprom - Reads a 16 bit word from the EEPROM.
3905 * @hw: Struct containing variables accessed by shared code
3906 * @offset: offset of word in the EEPROM to read
3907 * @data: word read from the EEPROM
3908 * @words: number of words to read
3909 */
3910 s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
3911 {
3912 s32 ret;
3913 spin_lock(&e1000_eeprom_lock);
3914 ret = e1000_do_read_eeprom(hw, offset, words, data);
3915 spin_unlock(&e1000_eeprom_lock);
3916 return ret;
3917 }
3918
3919 static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
3920 u16 *data)
3921 {
3922 struct e1000_eeprom_info *eeprom = &hw->eeprom;
3923 u32 i = 0;
3924
3925 e_dbg("e1000_read_eeprom");
3926
3927 if (hw->mac_type == e1000_ce4100) {
3928 GBE_CONFIG_FLASH_READ(GBE_CONFIG_BASE_VIRT, offset, words,
3929 data);
3930 return E1000_SUCCESS;
3931 }
3932
3933 /* If eeprom is not yet detected, do so now */
3934 if (eeprom->word_size == 0)
3935 e1000_init_eeprom_params(hw);
3936
3937 /* A check for invalid values: offset too large, too many words, and not
3938 * enough words.
3939 */
3940 if ((offset >= eeprom->word_size)
3941 || (words > eeprom->word_size - offset) || (words == 0)) {
3942 e_dbg("\"words\" parameter out of bounds. Words = %d,"
3943 "size = %d\n", offset, eeprom->word_size);
3944 return -E1000_ERR_EEPROM;
3945 }
3946
3947 /* EEPROM's that don't use EERD to read require us to bit-bang the SPI
3948 * directly. In this case, we need to acquire the EEPROM so that
3949 * FW or other port software does not interrupt.
3950 */
3951 /* Prepare the EEPROM for bit-bang reading */
3952 if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
3953 return -E1000_ERR_EEPROM;
3954
3955 /* Set up the SPI or Microwire EEPROM for bit-bang reading. We have
3956 * acquired the EEPROM at this point, so any returns should release it */
3957 if (eeprom->type == e1000_eeprom_spi) {
3958 u16 word_in;
3959 u8 read_opcode = EEPROM_READ_OPCODE_SPI;
3960
3961 if (e1000_spi_eeprom_ready(hw)) {
3962 e1000_release_eeprom(hw);
3963 return -E1000_ERR_EEPROM;
3964 }
3965
3966 e1000_standby_eeprom(hw);
3967
3968 /* Some SPI eeproms use the 8th address bit embedded in the opcode */
3969 if ((eeprom->address_bits == 8) && (offset >= 128))
3970 read_opcode |= EEPROM_A8_OPCODE_SPI;
3971
3972 /* Send the READ command (opcode + addr) */
3973 e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits);
3974 e1000_shift_out_ee_bits(hw, (u16) (offset * 2),
3975 eeprom->address_bits);
3976
3977 /* Read the data. The address of the eeprom internally increments with
3978 * each byte (spi) being read, saving on the overhead of eeprom setup
3979 * and tear-down. The address counter will roll over if reading beyond
3980 * the size of the eeprom, thus allowing the entire memory to be read
3981 * starting from any offset. */
3982 for (i = 0; i < words; i++) {
3983 word_in = e1000_shift_in_ee_bits(hw, 16);
3984 data[i] = (word_in >> 8) | (word_in << 8);
3985 }
3986 } else if (eeprom->type == e1000_eeprom_microwire) {
3987 for (i = 0; i < words; i++) {
3988 /* Send the READ command (opcode + addr) */
3989 e1000_shift_out_ee_bits(hw,
3990 EEPROM_READ_OPCODE_MICROWIRE,
3991 eeprom->opcode_bits);
3992 e1000_shift_out_ee_bits(hw, (u16) (offset + i),
3993 eeprom->address_bits);
3994
3995 /* Read the data. For microwire, each word requires the overhead
3996 * of eeprom setup and tear-down. */
3997 data[i] = e1000_shift_in_ee_bits(hw, 16);
3998 e1000_standby_eeprom(hw);
3999 }
4000 }
4001
4002 /* End this read operation */
4003 e1000_release_eeprom(hw);
4004
4005 return E1000_SUCCESS;
4006 }
4007
4008 /**
4009 * e1000_validate_eeprom_checksum - Verifies that the EEPROM has a valid checksum
4010 * @hw: Struct containing variables accessed by shared code
4011 *
4012 * Reads the first 64 16 bit words of the EEPROM and sums the values read.
4013 * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
4014 * valid.
4015 */
4016 s32 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
4017 {
4018 u16 checksum = 0;
4019 u16 i, eeprom_data;
4020
4021 e_dbg("e1000_validate_eeprom_checksum");
4022
4023 for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
4024 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
4025 e_dbg("EEPROM Read Error\n");
4026 return -E1000_ERR_EEPROM;
4027 }
4028 checksum += eeprom_data;
4029 }
4030
4031 if (checksum == (u16) EEPROM_SUM)
4032 return E1000_SUCCESS;
4033 else {
4034 e_dbg("EEPROM Checksum Invalid\n");
4035 return -E1000_ERR_EEPROM;
4036 }
4037 }
4038
4039 /**
4040 * e1000_update_eeprom_checksum - Calculates/writes the EEPROM checksum
4041 * @hw: Struct containing variables accessed by shared code
4042 *
4043 * Sums the first 63 16 bit words of the EEPROM. Subtracts the sum from 0xBABA.
4044 * Writes the difference to word offset 63 of the EEPROM.
4045 */
4046 s32 e1000_update_eeprom_checksum(struct e1000_hw *hw)
4047 {
4048 u16 checksum = 0;
4049 u16 i, eeprom_data;
4050
4051 e_dbg("e1000_update_eeprom_checksum");
4052
4053 for (i = 0; i < EEPROM_CHECKSUM_REG; i++) {
4054 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
4055 e_dbg("EEPROM Read Error\n");
4056 return -E1000_ERR_EEPROM;
4057 }
4058 checksum += eeprom_data;
4059 }
4060 checksum = (u16) EEPROM_SUM - checksum;
4061 if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) {
4062 e_dbg("EEPROM Write Error\n");
4063 return -E1000_ERR_EEPROM;
4064 }
4065 return E1000_SUCCESS;
4066 }
4067
4068 /**
4069 * e1000_write_eeprom - write words to the different EEPROM types.
4070 * @hw: Struct containing variables accessed by shared code
4071 * @offset: offset within the EEPROM to be written to
4072 * @words: number of words to write
4073 * @data: 16 bit word to be written to the EEPROM
4074 *
4075 * If e1000_update_eeprom_checksum is not called after this function, the
4076 * EEPROM will most likely contain an invalid checksum.
4077 */
4078 s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
4079 {
4080 s32 ret;
4081 spin_lock(&e1000_eeprom_lock);
4082 ret = e1000_do_write_eeprom(hw, offset, words, data);
4083 spin_unlock(&e1000_eeprom_lock);
4084 return ret;
4085 }
4086
4087 static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
4088 u16 *data)
4089 {
4090 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4091 s32 status = 0;
4092
4093 e_dbg("e1000_write_eeprom");
4094
4095 if (hw->mac_type == e1000_ce4100) {
4096 GBE_CONFIG_FLASH_WRITE(GBE_CONFIG_BASE_VIRT, offset, words,
4097 data);
4098 return E1000_SUCCESS;
4099 }
4100
4101 /* If eeprom is not yet detected, do so now */
4102 if (eeprom->word_size == 0)
4103 e1000_init_eeprom_params(hw);
4104
4105 /* A check for invalid values: offset too large, too many words, and not
4106 * enough words.
4107 */
4108 if ((offset >= eeprom->word_size)
4109 || (words > eeprom->word_size - offset) || (words == 0)) {
4110 e_dbg("\"words\" parameter out of bounds\n");
4111 return -E1000_ERR_EEPROM;
4112 }
4113
4114 /* Prepare the EEPROM for writing */
4115 if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
4116 return -E1000_ERR_EEPROM;
4117
4118 if (eeprom->type == e1000_eeprom_microwire) {
4119 status = e1000_write_eeprom_microwire(hw, offset, words, data);
4120 } else {
4121 status = e1000_write_eeprom_spi(hw, offset, words, data);
4122 msleep(10);
4123 }
4124
4125 /* Done with writing */
4126 e1000_release_eeprom(hw);
4127
4128 return status;
4129 }
4130
4131 /**
4132 * e1000_write_eeprom_spi - Writes a 16 bit word to a given offset in an SPI EEPROM.
4133 * @hw: Struct containing variables accessed by shared code
4134 * @offset: offset within the EEPROM to be written to
4135 * @words: number of words to write
4136 * @data: pointer to array of 8 bit words to be written to the EEPROM
4137 */
4138 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
4139 u16 *data)
4140 {
4141 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4142 u16 widx = 0;
4143
4144 e_dbg("e1000_write_eeprom_spi");
4145
4146 while (widx < words) {
4147 u8 write_opcode = EEPROM_WRITE_OPCODE_SPI;
4148
4149 if (e1000_spi_eeprom_ready(hw))
4150 return -E1000_ERR_EEPROM;
4151
4152 e1000_standby_eeprom(hw);
4153
4154 /* Send the WRITE ENABLE command (8 bit opcode ) */
4155 e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI,
4156 eeprom->opcode_bits);
4157
4158 e1000_standby_eeprom(hw);
4159
4160 /* Some SPI eeproms use the 8th address bit embedded in the opcode */
4161 if ((eeprom->address_bits == 8) && (offset >= 128))
4162 write_opcode |= EEPROM_A8_OPCODE_SPI;
4163
4164 /* Send the Write command (8-bit opcode + addr) */
4165 e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits);
4166
4167 e1000_shift_out_ee_bits(hw, (u16) ((offset + widx) * 2),
4168 eeprom->address_bits);
4169
4170 /* Send the data */
4171
4172 /* Loop to allow for up to whole page write (32 bytes) of eeprom */
4173 while (widx < words) {
4174 u16 word_out = data[widx];
4175 word_out = (word_out >> 8) | (word_out << 8);
4176 e1000_shift_out_ee_bits(hw, word_out, 16);
4177 widx++;
4178
4179 /* Some larger eeprom sizes are capable of a 32-byte PAGE WRITE
4180 * operation, while the smaller eeproms are capable of an 8-byte
4181 * PAGE WRITE operation. Break the inner loop to pass new address
4182 */
4183 if ((((offset + widx) * 2) % eeprom->page_size) == 0) {
4184 e1000_standby_eeprom(hw);
4185 break;
4186 }
4187 }
4188 }
4189
4190 return E1000_SUCCESS;
4191 }
4192
4193 /**
4194 * e1000_write_eeprom_microwire - Writes a 16 bit word to a given offset in a Microwire EEPROM.
4195 * @hw: Struct containing variables accessed by shared code
4196 * @offset: offset within the EEPROM to be written to
4197 * @words: number of words to write
4198 * @data: pointer to array of 8 bit words to be written to the EEPROM
4199 */
4200 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
4201 u16 words, u16 *data)
4202 {
4203 struct e1000_eeprom_info *eeprom = &hw->eeprom;
4204 u32 eecd;
4205 u16 words_written = 0;
4206 u16 i = 0;
4207
4208 e_dbg("e1000_write_eeprom_microwire");
4209
4210 /* Send the write enable command to the EEPROM (3-bit opcode plus
4211 * 6/8-bit dummy address beginning with 11). It's less work to include
4212 * the 11 of the dummy address as part of the opcode than it is to shift
4213 * it over the correct number of bits for the address. This puts the
4214 * EEPROM into write/erase mode.
4215 */
4216 e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE,
4217 (u16) (eeprom->opcode_bits + 2));
4218
4219 e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2));
4220
4221 /* Prepare the EEPROM */
4222 e1000_standby_eeprom(hw);
4223
4224 while (words_written < words) {
4225 /* Send the Write command (3-bit opcode + addr) */
4226 e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE,
4227 eeprom->opcode_bits);
4228
4229 e1000_shift_out_ee_bits(hw, (u16) (offset + words_written),
4230 eeprom->address_bits);
4231
4232 /* Send the data */
4233 e1000_shift_out_ee_bits(hw, data[words_written], 16);
4234
4235 /* Toggle the CS line. This in effect tells the EEPROM to execute
4236 * the previous command.
4237 */
4238 e1000_standby_eeprom(hw);
4239
4240 /* Read DO repeatedly until it is high (equal to '1'). The EEPROM will
4241 * signal that the command has been completed by raising the DO signal.
4242 * If DO does not go high in 10 milliseconds, then error out.
4243 */
4244 for (i = 0; i < 200; i++) {
4245 eecd = er32(EECD);
4246 if (eecd & E1000_EECD_DO)
4247 break;
4248 udelay(50);
4249 }
4250 if (i == 200) {
4251 e_dbg("EEPROM Write did not complete\n");
4252 return -E1000_ERR_EEPROM;
4253 }
4254
4255 /* Recover from write */
4256 e1000_standby_eeprom(hw);
4257
4258 words_written++;
4259 }
4260
4261 /* Send the write disable command to the EEPROM (3-bit opcode plus
4262 * 6/8-bit dummy address beginning with 10). It's less work to include
4263 * the 10 of the dummy address as part of the opcode than it is to shift
4264 * it over the correct number of bits for the address. This takes the
4265 * EEPROM out of write/erase mode.
4266 */
4267 e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE,
4268 (u16) (eeprom->opcode_bits + 2));
4269
4270 e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2));
4271
4272 return E1000_SUCCESS;
4273 }
4274
4275 /**
4276 * e1000_read_mac_addr - read the adapters MAC from eeprom
4277 * @hw: Struct containing variables accessed by shared code
4278 *
4279 * Reads the adapter's MAC address from the EEPROM and inverts the LSB for the
4280 * second function of dual function devices
4281 */
4282 s32 e1000_read_mac_addr(struct e1000_hw *hw)
4283 {
4284 u16 offset;
4285 u16 eeprom_data, i;
4286
4287 e_dbg("e1000_read_mac_addr");
4288
4289 for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
4290 offset = i >> 1;
4291 if (e1000_read_eeprom(hw, offset, 1, &eeprom_data) < 0) {
4292 e_dbg("EEPROM Read Error\n");
4293 return -E1000_ERR_EEPROM;
4294 }
4295 hw->perm_mac_addr[i] = (u8) (eeprom_data & 0x00FF);
4296 hw->perm_mac_addr[i + 1] = (u8) (eeprom_data >> 8);
4297 }
4298
4299 switch (hw->mac_type) {
4300 default:
4301 break;
4302 case e1000_82546:
4303 case e1000_82546_rev_3:
4304 if (er32(STATUS) & E1000_STATUS_FUNC_1)
4305 hw->perm_mac_addr[5] ^= 0x01;
4306 break;
4307 }
4308
4309 for (i = 0; i < NODE_ADDRESS_SIZE; i++)
4310 hw->mac_addr[i] = hw->perm_mac_addr[i];
4311 return E1000_SUCCESS;
4312 }
4313
4314 /**
4315 * e1000_init_rx_addrs - Initializes receive address filters.
4316 * @hw: Struct containing variables accessed by shared code
4317 *
4318 * Places the MAC address in receive address register 0 and clears the rest
4319 * of the receive address registers. Clears the multicast table. Assumes
4320 * the receiver is in reset when the routine is called.
4321 */
4322 static void e1000_init_rx_addrs(struct e1000_hw *hw)
4323 {
4324 u32 i;
4325 u32 rar_num;
4326
4327 e_dbg("e1000_init_rx_addrs");
4328
4329 /* Setup the receive address. */
4330 e_dbg("Programming MAC Address into RAR[0]\n");
4331
4332 e1000_rar_set(hw, hw->mac_addr, 0);
4333
4334 rar_num = E1000_RAR_ENTRIES;
4335
4336 /* Zero out the other 15 receive addresses. */
4337 e_dbg("Clearing RAR[1-15]\n");
4338 for (i = 1; i < rar_num; i++) {
4339 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
4340 E1000_WRITE_FLUSH();
4341 E1000_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
4342 E1000_WRITE_FLUSH();
4343 }
4344 }
4345
4346 /**
4347 * e1000_hash_mc_addr - Hashes an address to determine its location in the multicast table
4348 * @hw: Struct containing variables accessed by shared code
4349 * @mc_addr: the multicast address to hash
4350 */
4351 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
4352 {
4353 u32 hash_value = 0;
4354
4355 /* The portion of the address that is used for the hash table is
4356 * determined by the mc_filter_type setting.
4357 */
4358 switch (hw->mc_filter_type) {
4359 /* [0] [1] [2] [3] [4] [5]
4360 * 01 AA 00 12 34 56
4361 * LSB MSB
4362 */
4363 case 0:
4364 /* [47:36] i.e. 0x563 for above example address */
4365 hash_value = ((mc_addr[4] >> 4) | (((u16) mc_addr[5]) << 4));
4366 break;
4367 case 1:
4368 /* [46:35] i.e. 0xAC6 for above example address */
4369 hash_value = ((mc_addr[4] >> 3) | (((u16) mc_addr[5]) << 5));
4370 break;
4371 case 2:
4372 /* [45:34] i.e. 0x5D8 for above example address */
4373 hash_value = ((mc_addr[4] >> 2) | (((u16) mc_addr[5]) << 6));
4374 break;
4375 case 3:
4376 /* [43:32] i.e. 0x634 for above example address */
4377 hash_value = ((mc_addr[4]) | (((u16) mc_addr[5]) << 8));
4378 break;
4379 }
4380
4381 hash_value &= 0xFFF;
4382 return hash_value;
4383 }
4384
4385 /**
4386 * e1000_rar_set - Puts an ethernet address into a receive address register.
4387 * @hw: Struct containing variables accessed by shared code
4388 * @addr: Address to put into receive address register
4389 * @index: Receive address register to write
4390 */
4391 void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
4392 {
4393 u32 rar_low, rar_high;
4394
4395 /* HW expects these in little endian so we reverse the byte order
4396 * from network order (big endian) to little endian
4397 */
4398 rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) |
4399 ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
4400 rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
4401
4402 /* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx
4403 * unit hang.
4404 *
4405 * Description:
4406 * If there are any Rx frames queued up or otherwise present in the HW
4407 * before RSS is enabled, and then we enable RSS, the HW Rx unit will
4408 * hang. To work around this issue, we have to disable receives and
4409 * flush out all Rx frames before we enable RSS. To do so, we modify we
4410 * redirect all Rx traffic to manageability and then reset the HW.
4411 * This flushes away Rx frames, and (since the redirections to
4412 * manageability persists across resets) keeps new ones from coming in
4413 * while we work. Then, we clear the Address Valid AV bit for all MAC
4414 * addresses and undo the re-direction to manageability.
4415 * Now, frames are coming in again, but the MAC won't accept them, so
4416 * far so good. We now proceed to initialize RSS (if necessary) and
4417 * configure the Rx unit. Last, we re-enable the AV bits and continue
4418 * on our merry way.
4419 */
4420 switch (hw->mac_type) {
4421 default:
4422 /* Indicate to hardware the Address is Valid. */
4423 rar_high |= E1000_RAH_AV;
4424 break;
4425 }
4426
4427 E1000_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
4428 E1000_WRITE_FLUSH();
4429 E1000_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
4430 E1000_WRITE_FLUSH();
4431 }
4432
4433 /**
4434 * e1000_write_vfta - Writes a value to the specified offset in the VLAN filter table.
4435 * @hw: Struct containing variables accessed by shared code
4436 * @offset: Offset in VLAN filer table to write
4437 * @value: Value to write into VLAN filter table
4438 */
4439 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
4440 {
4441 u32 temp;
4442
4443 if ((hw->mac_type == e1000_82544) && ((offset & 0x1) == 1)) {
4444 temp = E1000_READ_REG_ARRAY(hw, VFTA, (offset - 1));
4445 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
4446 E1000_WRITE_FLUSH();
4447 E1000_WRITE_REG_ARRAY(hw, VFTA, (offset - 1), temp);
4448 E1000_WRITE_FLUSH();
4449 } else {
4450 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
4451 E1000_WRITE_FLUSH();
4452 }
4453 }
4454
4455 /**
4456 * e1000_clear_vfta - Clears the VLAN filer table
4457 * @hw: Struct containing variables accessed by shared code
4458 */
4459 static void e1000_clear_vfta(struct e1000_hw *hw)
4460 {
4461 u32 offset;
4462 u32 vfta_value = 0;
4463 u32 vfta_offset = 0;
4464 u32 vfta_bit_in_reg = 0;
4465
4466 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
4467 /* If the offset we want to clear is the same offset of the
4468 * manageability VLAN ID, then clear all bits except that of the
4469 * manageability unit */
4470 vfta_value = (offset == vfta_offset) ? vfta_bit_in_reg : 0;
4471 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, vfta_value);
4472 E1000_WRITE_FLUSH();
4473 }
4474 }
4475
4476 static s32 e1000_id_led_init(struct e1000_hw *hw)
4477 {
4478 u32 ledctl;
4479 const u32 ledctl_mask = 0x000000FF;
4480 const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
4481 const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
4482 u16 eeprom_data, i, temp;
4483 const u16 led_mask = 0x0F;
4484
4485 e_dbg("e1000_id_led_init");
4486
4487 if (hw->mac_type < e1000_82540) {
4488 /* Nothing to do */
4489 return E1000_SUCCESS;
4490 }
4491
4492 ledctl = er32(LEDCTL);
4493 hw->ledctl_default = ledctl;
4494 hw->ledctl_mode1 = hw->ledctl_default;
4495 hw->ledctl_mode2 = hw->ledctl_default;
4496
4497 if (e1000_read_eeprom(hw, EEPROM_ID_LED_SETTINGS, 1, &eeprom_data) < 0) {
4498 e_dbg("EEPROM Read Error\n");
4499 return -E1000_ERR_EEPROM;
4500 }
4501
4502 if ((eeprom_data == ID_LED_RESERVED_0000) ||
4503 (eeprom_data == ID_LED_RESERVED_FFFF)) {
4504 eeprom_data = ID_LED_DEFAULT;
4505 }
4506
4507 for (i = 0; i < 4; i++) {
4508 temp = (eeprom_data >> (i << 2)) & led_mask;
4509 switch (temp) {
4510 case ID_LED_ON1_DEF2:
4511 case ID_LED_ON1_ON2:
4512 case ID_LED_ON1_OFF2:
4513 hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
4514 hw->ledctl_mode1 |= ledctl_on << (i << 3);
4515 break;
4516 case ID_LED_OFF1_DEF2:
4517 case ID_LED_OFF1_ON2:
4518 case ID_LED_OFF1_OFF2:
4519 hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
4520 hw->ledctl_mode1 |= ledctl_off << (i << 3);
4521 break;
4522 default:
4523 /* Do nothing */
4524 break;
4525 }
4526 switch (temp) {
4527 case ID_LED_DEF1_ON2:
4528 case ID_LED_ON1_ON2:
4529 case ID_LED_OFF1_ON2:
4530 hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
4531 hw->ledctl_mode2 |= ledctl_on << (i << 3);
4532 break;
4533 case ID_LED_DEF1_OFF2:
4534 case ID_LED_ON1_OFF2:
4535 case ID_LED_OFF1_OFF2:
4536 hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
4537 hw->ledctl_mode2 |= ledctl_off << (i << 3);
4538 break;
4539 default:
4540 /* Do nothing */
4541 break;
4542 }
4543 }
4544 return E1000_SUCCESS;
4545 }
4546
4547 /**
4548 * e1000_setup_led
4549 * @hw: Struct containing variables accessed by shared code
4550 *
4551 * Prepares SW controlable LED for use and saves the current state of the LED.
4552 */
4553 s32 e1000_setup_led(struct e1000_hw *hw)
4554 {
4555 u32 ledctl;
4556 s32 ret_val = E1000_SUCCESS;
4557
4558 e_dbg("e1000_setup_led");
4559
4560 switch (hw->mac_type) {
4561 case e1000_82542_rev2_0:
4562 case e1000_82542_rev2_1:
4563 case e1000_82543:
4564 case e1000_82544:
4565 /* No setup necessary */
4566 break;
4567 case e1000_82541:
4568 case e1000_82547:
4569 case e1000_82541_rev_2:
4570 case e1000_82547_rev_2:
4571 /* Turn off PHY Smart Power Down (if enabled) */
4572 ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO,
4573 &hw->phy_spd_default);
4574 if (ret_val)
4575 return ret_val;
4576 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
4577 (u16) (hw->phy_spd_default &
4578 ~IGP01E1000_GMII_SPD));
4579 if (ret_val)
4580 return ret_val;
4581 /* Fall Through */
4582 default:
4583 if (hw->media_type == e1000_media_type_fiber) {
4584 ledctl = er32(LEDCTL);
4585 /* Save current LEDCTL settings */
4586 hw->ledctl_default = ledctl;
4587 /* Turn off LED0 */
4588 ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
4589 E1000_LEDCTL_LED0_BLINK |
4590 E1000_LEDCTL_LED0_MODE_MASK);
4591 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
4592 E1000_LEDCTL_LED0_MODE_SHIFT);
4593 ew32(LEDCTL, ledctl);
4594 } else if (hw->media_type == e1000_media_type_copper)
4595 ew32(LEDCTL, hw->ledctl_mode1);
4596 break;
4597 }
4598
4599 return E1000_SUCCESS;
4600 }
4601
4602 /**
4603 * e1000_cleanup_led - Restores the saved state of the SW controlable LED.
4604 * @hw: Struct containing variables accessed by shared code
4605 */
4606 s32 e1000_cleanup_led(struct e1000_hw *hw)
4607 {
4608 s32 ret_val = E1000_SUCCESS;
4609
4610 e_dbg("e1000_cleanup_led");
4611
4612 switch (hw->mac_type) {
4613 case e1000_82542_rev2_0:
4614 case e1000_82542_rev2_1:
4615 case e1000_82543:
4616 case e1000_82544:
4617 /* No cleanup necessary */
4618 break;
4619 case e1000_82541:
4620 case e1000_82547:
4621 case e1000_82541_rev_2:
4622 case e1000_82547_rev_2:
4623 /* Turn on PHY Smart Power Down (if previously enabled) */
4624 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
4625 hw->phy_spd_default);
4626 if (ret_val)
4627 return ret_val;
4628 /* Fall Through */
4629 default:
4630 /* Restore LEDCTL settings */
4631 ew32(LEDCTL, hw->ledctl_default);
4632 break;
4633 }
4634
4635 return E1000_SUCCESS;
4636 }
4637
4638 /**
4639 * e1000_led_on - Turns on the software controllable LED
4640 * @hw: Struct containing variables accessed by shared code
4641 */
4642 s32 e1000_led_on(struct e1000_hw *hw)
4643 {
4644 u32 ctrl = er32(CTRL);
4645
4646 e_dbg("e1000_led_on");
4647
4648 switch (hw->mac_type) {
4649 case e1000_82542_rev2_0:
4650 case e1000_82542_rev2_1:
4651 case e1000_82543:
4652 /* Set SW Defineable Pin 0 to turn on the LED */
4653 ctrl |= E1000_CTRL_SWDPIN0;
4654 ctrl |= E1000_CTRL_SWDPIO0;
4655 break;
4656 case e1000_82544:
4657 if (hw->media_type == e1000_media_type_fiber) {
4658 /* Set SW Defineable Pin 0 to turn on the LED */
4659 ctrl |= E1000_CTRL_SWDPIN0;
4660 ctrl |= E1000_CTRL_SWDPIO0;
4661 } else {
4662 /* Clear SW Defineable Pin 0 to turn on the LED */
4663 ctrl &= ~E1000_CTRL_SWDPIN0;
4664 ctrl |= E1000_CTRL_SWDPIO0;
4665 }
4666 break;
4667 default:
4668 if (hw->media_type == e1000_media_type_fiber) {
4669 /* Clear SW Defineable Pin 0 to turn on the LED */
4670 ctrl &= ~E1000_CTRL_SWDPIN0;
4671 ctrl |= E1000_CTRL_SWDPIO0;
4672 } else if (hw->media_type == e1000_media_type_copper) {
4673 ew32(LEDCTL, hw->ledctl_mode2);
4674 return E1000_SUCCESS;
4675 }
4676 break;
4677 }
4678
4679 ew32(CTRL, ctrl);
4680
4681 return E1000_SUCCESS;
4682 }
4683
4684 /**
4685 * e1000_led_off - Turns off the software controllable LED
4686 * @hw: Struct containing variables accessed by shared code
4687 */
4688 s32 e1000_led_off(struct e1000_hw *hw)
4689 {
4690 u32 ctrl = er32(CTRL);
4691
4692 e_dbg("e1000_led_off");
4693
4694 switch (hw->mac_type) {
4695 case e1000_82542_rev2_0:
4696 case e1000_82542_rev2_1:
4697 case e1000_82543:
4698 /* Clear SW Defineable Pin 0 to turn off the LED */
4699 ctrl &= ~E1000_CTRL_SWDPIN0;
4700 ctrl |= E1000_CTRL_SWDPIO0;
4701 break;
4702 case e1000_82544:
4703 if (hw->media_type == e1000_media_type_fiber) {
4704 /* Clear SW Defineable Pin 0 to turn off the LED */
4705 ctrl &= ~E1000_CTRL_SWDPIN0;
4706 ctrl |= E1000_CTRL_SWDPIO0;
4707 } else {
4708 /* Set SW Defineable Pin 0 to turn off the LED */
4709 ctrl |= E1000_CTRL_SWDPIN0;
4710 ctrl |= E1000_CTRL_SWDPIO0;
4711 }
4712 break;
4713 default:
4714 if (hw->media_type == e1000_media_type_fiber) {
4715 /* Set SW Defineable Pin 0 to turn off the LED */
4716 ctrl |= E1000_CTRL_SWDPIN0;
4717 ctrl |= E1000_CTRL_SWDPIO0;
4718 } else if (hw->media_type == e1000_media_type_copper) {
4719 ew32(LEDCTL, hw->ledctl_mode1);
4720 return E1000_SUCCESS;
4721 }
4722 break;
4723 }
4724
4725 ew32(CTRL, ctrl);
4726
4727 return E1000_SUCCESS;
4728 }
4729
4730 /**
4731 * e1000_clear_hw_cntrs - Clears all hardware statistics counters.
4732 * @hw: Struct containing variables accessed by shared code
4733 */
4734 static void e1000_clear_hw_cntrs(struct e1000_hw *hw)
4735 {
4736 volatile u32 temp;
4737
4738 temp = er32(CRCERRS);
4739 temp = er32(SYMERRS);
4740 temp = er32(MPC);
4741 temp = er32(SCC);
4742 temp = er32(ECOL);
4743 temp = er32(MCC);
4744 temp = er32(LATECOL);
4745 temp = er32(COLC);
4746 temp = er32(DC);
4747 temp = er32(SEC);
4748 temp = er32(RLEC);
4749 temp = er32(XONRXC);
4750 temp = er32(XONTXC);
4751 temp = er32(XOFFRXC);
4752 temp = er32(XOFFTXC);
4753 temp = er32(FCRUC);
4754
4755 temp = er32(PRC64);
4756 temp = er32(PRC127);
4757 temp = er32(PRC255);
4758 temp = er32(PRC511);
4759 temp = er32(PRC1023);
4760 temp = er32(PRC1522);
4761
4762 temp = er32(GPRC);
4763 temp = er32(BPRC);
4764 temp = er32(MPRC);
4765 temp = er32(GPTC);
4766 temp = er32(GORCL);
4767 temp = er32(GORCH);
4768 temp = er32(GOTCL);
4769 temp = er32(GOTCH);
4770 temp = er32(RNBC);
4771 temp = er32(RUC);
4772 temp = er32(RFC);
4773 temp = er32(ROC);
4774 temp = er32(RJC);
4775 temp = er32(TORL);
4776 temp = er32(TORH);
4777 temp = er32(TOTL);
4778 temp = er32(TOTH);
4779 temp = er32(TPR);
4780 temp = er32(TPT);
4781
4782 temp = er32(PTC64);
4783 temp = er32(PTC127);
4784 temp = er32(PTC255);
4785 temp = er32(PTC511);
4786 temp = er32(PTC1023);
4787 temp = er32(PTC1522);
4788
4789 temp = er32(MPTC);
4790 temp = er32(BPTC);
4791
4792 if (hw->mac_type < e1000_82543)
4793 return;
4794
4795 temp = er32(ALGNERRC);
4796 temp = er32(RXERRC);
4797 temp = er32(TNCRS);
4798 temp = er32(CEXTERR);
4799 temp = er32(TSCTC);
4800 temp = er32(TSCTFC);
4801
4802 if (hw->mac_type <= e1000_82544)
4803 return;
4804
4805 temp = er32(MGTPRC);
4806 temp = er32(MGTPDC);
4807 temp = er32(MGTPTC);
4808 }
4809
4810 /**
4811 * e1000_reset_adaptive - Resets Adaptive IFS to its default state.
4812 * @hw: Struct containing variables accessed by shared code
4813 *
4814 * Call this after e1000_init_hw. You may override the IFS defaults by setting
4815 * hw->ifs_params_forced to true. However, you must initialize hw->
4816 * current_ifs_val, ifs_min_val, ifs_max_val, ifs_step_size, and ifs_ratio
4817 * before calling this function.
4818 */
4819 void e1000_reset_adaptive(struct e1000_hw *hw)
4820 {
4821 e_dbg("e1000_reset_adaptive");
4822
4823 if (hw->adaptive_ifs) {
4824 if (!hw->ifs_params_forced) {
4825 hw->current_ifs_val = 0;
4826 hw->ifs_min_val = IFS_MIN;
4827 hw->ifs_max_val = IFS_MAX;
4828 hw->ifs_step_size = IFS_STEP;
4829 hw->ifs_ratio = IFS_RATIO;
4830 }
4831 hw->in_ifs_mode = false;
4832 ew32(AIT, 0);
4833 } else {
4834 e_dbg("Not in Adaptive IFS mode!\n");
4835 }
4836 }
4837
4838 /**
4839 * e1000_update_adaptive - update adaptive IFS
4840 * @hw: Struct containing variables accessed by shared code
4841 * @tx_packets: Number of transmits since last callback
4842 * @total_collisions: Number of collisions since last callback
4843 *
4844 * Called during the callback/watchdog routine to update IFS value based on
4845 * the ratio of transmits to collisions.
4846 */
4847 void e1000_update_adaptive(struct e1000_hw *hw)
4848 {
4849 e_dbg("e1000_update_adaptive");
4850
4851 if (hw->adaptive_ifs) {
4852 if ((hw->collision_delta *hw->ifs_ratio) > hw->tx_packet_delta) {
4853 if (hw->tx_packet_delta > MIN_NUM_XMITS) {
4854 hw->in_ifs_mode = true;
4855 if (hw->current_ifs_val < hw->ifs_max_val) {
4856 if (hw->current_ifs_val == 0)
4857 hw->current_ifs_val =
4858 hw->ifs_min_val;
4859 else
4860 hw->current_ifs_val +=
4861 hw->ifs_step_size;
4862 ew32(AIT, hw->current_ifs_val);
4863 }
4864 }
4865 } else {
4866 if (hw->in_ifs_mode
4867 && (hw->tx_packet_delta <= MIN_NUM_XMITS)) {
4868 hw->current_ifs_val = 0;
4869 hw->in_ifs_mode = false;
4870 ew32(AIT, 0);
4871 }
4872 }
4873 } else {
4874 e_dbg("Not in Adaptive IFS mode!\n");
4875 }
4876 }
4877
4878 /**
4879 * e1000_tbi_adjust_stats
4880 * @hw: Struct containing variables accessed by shared code
4881 * @frame_len: The length of the frame in question
4882 * @mac_addr: The Ethernet destination address of the frame in question
4883 *
4884 * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
4885 */
4886 void e1000_tbi_adjust_stats(struct e1000_hw *hw, struct e1000_hw_stats *stats,
4887 u32 frame_len, u8 *mac_addr)
4888 {
4889 u64 carry_bit;
4890
4891 /* First adjust the frame length. */
4892 frame_len--;
4893 /* We need to adjust the statistics counters, since the hardware
4894 * counters overcount this packet as a CRC error and undercount
4895 * the packet as a good packet
4896 */
4897 /* This packet should not be counted as a CRC error. */
4898 stats->crcerrs--;
4899 /* This packet does count as a Good Packet Received. */
4900 stats->gprc++;
4901
4902 /* Adjust the Good Octets received counters */
4903 carry_bit = 0x80000000 & stats->gorcl;
4904 stats->gorcl += frame_len;
4905 /* If the high bit of Gorcl (the low 32 bits of the Good Octets
4906 * Received Count) was one before the addition,
4907 * AND it is zero after, then we lost the carry out,
4908 * need to add one to Gorch (Good Octets Received Count High).
4909 * This could be simplified if all environments supported
4910 * 64-bit integers.
4911 */
4912 if (carry_bit && ((stats->gorcl & 0x80000000) == 0))
4913 stats->gorch++;
4914 /* Is this a broadcast or multicast? Check broadcast first,
4915 * since the test for a multicast frame will test positive on
4916 * a broadcast frame.
4917 */
4918 if ((mac_addr[0] == (u8) 0xff) && (mac_addr[1] == (u8) 0xff))
4919 /* Broadcast packet */
4920 stats->bprc++;
4921 else if (*mac_addr & 0x01)
4922 /* Multicast packet */
4923 stats->mprc++;
4924
4925 if (frame_len == hw->max_frame_size) {
4926 /* In this case, the hardware has overcounted the number of
4927 * oversize frames.
4928 */
4929 if (stats->roc > 0)
4930 stats->roc--;
4931 }
4932
4933 /* Adjust the bin counters when the extra byte put the frame in the
4934 * wrong bin. Remember that the frame_len was adjusted above.
4935 */
4936 if (frame_len == 64) {
4937 stats->prc64++;
4938 stats->prc127--;
4939 } else if (frame_len == 127) {
4940 stats->prc127++;
4941 stats->prc255--;
4942 } else if (frame_len == 255) {
4943 stats->prc255++;
4944 stats->prc511--;
4945 } else if (frame_len == 511) {
4946 stats->prc511++;
4947 stats->prc1023--;
4948 } else if (frame_len == 1023) {
4949 stats->prc1023++;
4950 stats->prc1522--;
4951 } else if (frame_len == 1522) {
4952 stats->prc1522++;
4953 }
4954 }
4955
4956 /**
4957 * e1000_get_bus_info
4958 * @hw: Struct containing variables accessed by shared code
4959 *
4960 * Gets the current PCI bus type, speed, and width of the hardware
4961 */
4962 void e1000_get_bus_info(struct e1000_hw *hw)
4963 {
4964 u32 status;
4965
4966 switch (hw->mac_type) {
4967 case e1000_82542_rev2_0:
4968 case e1000_82542_rev2_1:
4969 hw->bus_type = e1000_bus_type_pci;
4970 hw->bus_speed = e1000_bus_speed_unknown;
4971 hw->bus_width = e1000_bus_width_unknown;
4972 break;
4973 default:
4974 status = er32(STATUS);
4975 hw->bus_type = (status & E1000_STATUS_PCIX_MODE) ?
4976 e1000_bus_type_pcix : e1000_bus_type_pci;
4977
4978 if (hw->device_id == E1000_DEV_ID_82546EB_QUAD_COPPER) {
4979 hw->bus_speed = (hw->bus_type == e1000_bus_type_pci) ?
4980 e1000_bus_speed_66 : e1000_bus_speed_120;
4981 } else if (hw->bus_type == e1000_bus_type_pci) {
4982 hw->bus_speed = (status & E1000_STATUS_PCI66) ?
4983 e1000_bus_speed_66 : e1000_bus_speed_33;
4984 } else {
4985 switch (status & E1000_STATUS_PCIX_SPEED) {
4986 case E1000_STATUS_PCIX_SPEED_66:
4987 hw->bus_speed = e1000_bus_speed_66;
4988 break;
4989 case E1000_STATUS_PCIX_SPEED_100:
4990 hw->bus_speed = e1000_bus_speed_100;
4991 break;
4992 case E1000_STATUS_PCIX_SPEED_133:
4993 hw->bus_speed = e1000_bus_speed_133;
4994 break;
4995 default:
4996 hw->bus_speed = e1000_bus_speed_reserved;
4997 break;
4998 }
4999 }
5000 hw->bus_width = (status & E1000_STATUS_BUS64) ?
5001 e1000_bus_width_64 : e1000_bus_width_32;
5002 break;
5003 }
5004 }
5005
5006 /**
5007 * e1000_write_reg_io
5008 * @hw: Struct containing variables accessed by shared code
5009 * @offset: offset to write to
5010 * @value: value to write
5011 *
5012 * Writes a value to one of the devices registers using port I/O (as opposed to
5013 * memory mapped I/O). Only 82544 and newer devices support port I/O.
5014 */
5015 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value)
5016 {
5017 unsigned long io_addr = hw->io_base;
5018 unsigned long io_data = hw->io_base + 4;
5019
5020 e1000_io_write(hw, io_addr, offset);
5021 e1000_io_write(hw, io_data, value);
5022 }
5023
5024 /**
5025 * e1000_get_cable_length - Estimates the cable length.
5026 * @hw: Struct containing variables accessed by shared code
5027 * @min_length: The estimated minimum length
5028 * @max_length: The estimated maximum length
5029 *
5030 * returns: - E1000_ERR_XXX
5031 * E1000_SUCCESS
5032 *
5033 * This function always returns a ranged length (minimum & maximum).
5034 * So for M88 phy's, this function interprets the one value returned from the
5035 * register to the minimum and maximum range.
5036 * For IGP phy's, the function calculates the range by the AGC registers.
5037 */
5038 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
5039 u16 *max_length)
5040 {
5041 s32 ret_val;
5042 u16 agc_value = 0;
5043 u16 i, phy_data;
5044 u16 cable_length;
5045
5046 e_dbg("e1000_get_cable_length");
5047
5048 *min_length = *max_length = 0;
5049
5050 /* Use old method for Phy older than IGP */
5051 if (hw->phy_type == e1000_phy_m88) {
5052
5053 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5054 &phy_data);
5055 if (ret_val)
5056 return ret_val;
5057 cable_length = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
5058 M88E1000_PSSR_CABLE_LENGTH_SHIFT;
5059
5060 /* Convert the enum value to ranged values */
5061 switch (cable_length) {
5062 case e1000_cable_length_50:
5063 *min_length = 0;
5064 *max_length = e1000_igp_cable_length_50;
5065 break;
5066 case e1000_cable_length_50_80:
5067 *min_length = e1000_igp_cable_length_50;
5068 *max_length = e1000_igp_cable_length_80;
5069 break;
5070 case e1000_cable_length_80_110:
5071 *min_length = e1000_igp_cable_length_80;
5072 *max_length = e1000_igp_cable_length_110;
5073 break;
5074 case e1000_cable_length_110_140:
5075 *min_length = e1000_igp_cable_length_110;
5076 *max_length = e1000_igp_cable_length_140;
5077 break;
5078 case e1000_cable_length_140:
5079 *min_length = e1000_igp_cable_length_140;
5080 *max_length = e1000_igp_cable_length_170;
5081 break;
5082 default:
5083 return -E1000_ERR_PHY;
5084 break;
5085 }
5086 } else if (hw->phy_type == e1000_phy_igp) { /* For IGP PHY */
5087 u16 cur_agc_value;
5088 u16 min_agc_value = IGP01E1000_AGC_LENGTH_TABLE_SIZE;
5089 static const u16 agc_reg_array[IGP01E1000_PHY_CHANNEL_NUM] = {
5090 IGP01E1000_PHY_AGC_A,
5091 IGP01E1000_PHY_AGC_B,
5092 IGP01E1000_PHY_AGC_C,
5093 IGP01E1000_PHY_AGC_D
5094 };
5095 /* Read the AGC registers for all channels */
5096 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5097
5098 ret_val =
5099 e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
5100 if (ret_val)
5101 return ret_val;
5102
5103 cur_agc_value = phy_data >> IGP01E1000_AGC_LENGTH_SHIFT;
5104
5105 /* Value bound check. */
5106 if ((cur_agc_value >=
5107 IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1)
5108 || (cur_agc_value == 0))
5109 return -E1000_ERR_PHY;
5110
5111 agc_value += cur_agc_value;
5112
5113 /* Update minimal AGC value. */
5114 if (min_agc_value > cur_agc_value)
5115 min_agc_value = cur_agc_value;
5116 }
5117
5118 /* Remove the minimal AGC result for length < 50m */
5119 if (agc_value <
5120 IGP01E1000_PHY_CHANNEL_NUM * e1000_igp_cable_length_50) {
5121 agc_value -= min_agc_value;
5122
5123 /* Get the average length of the remaining 3 channels */
5124 agc_value /= (IGP01E1000_PHY_CHANNEL_NUM - 1);
5125 } else {
5126 /* Get the average length of all the 4 channels. */
5127 agc_value /= IGP01E1000_PHY_CHANNEL_NUM;
5128 }
5129
5130 /* Set the range of the calculated length. */
5131 *min_length = ((e1000_igp_cable_length_table[agc_value] -
5132 IGP01E1000_AGC_RANGE) > 0) ?
5133 (e1000_igp_cable_length_table[agc_value] -
5134 IGP01E1000_AGC_RANGE) : 0;
5135 *max_length = e1000_igp_cable_length_table[agc_value] +
5136 IGP01E1000_AGC_RANGE;
5137 }
5138
5139 return E1000_SUCCESS;
5140 }
5141
5142 /**
5143 * e1000_check_polarity - Check the cable polarity
5144 * @hw: Struct containing variables accessed by shared code
5145 * @polarity: output parameter : 0 - Polarity is not reversed
5146 * 1 - Polarity is reversed.
5147 *
5148 * returns: - E1000_ERR_XXX
5149 * E1000_SUCCESS
5150 *
5151 * For phy's older than IGP, this function simply reads the polarity bit in the
5152 * Phy Status register. For IGP phy's, this bit is valid only if link speed is
5153 * 10 Mbps. If the link speed is 100 Mbps there is no polarity so this bit will
5154 * return 0. If the link speed is 1000 Mbps the polarity status is in the
5155 * IGP01E1000_PHY_PCS_INIT_REG.
5156 */
5157 static s32 e1000_check_polarity(struct e1000_hw *hw,
5158 e1000_rev_polarity *polarity)
5159 {
5160 s32 ret_val;
5161 u16 phy_data;
5162
5163 e_dbg("e1000_check_polarity");
5164
5165 if (hw->phy_type == e1000_phy_m88) {
5166 /* return the Polarity bit in the Status register. */
5167 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5168 &phy_data);
5169 if (ret_val)
5170 return ret_val;
5171 *polarity = ((phy_data & M88E1000_PSSR_REV_POLARITY) >>
5172 M88E1000_PSSR_REV_POLARITY_SHIFT) ?
5173 e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
5174
5175 } else if (hw->phy_type == e1000_phy_igp) {
5176 /* Read the Status register to check the speed */
5177 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS,
5178 &phy_data);
5179 if (ret_val)
5180 return ret_val;
5181
5182 /* If speed is 1000 Mbps, must read the IGP01E1000_PHY_PCS_INIT_REG to
5183 * find the polarity status */
5184 if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
5185 IGP01E1000_PSSR_SPEED_1000MBPS) {
5186
5187 /* Read the GIG initialization PCS register (0x00B4) */
5188 ret_val =
5189 e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG,
5190 &phy_data);
5191 if (ret_val)
5192 return ret_val;
5193
5194 /* Check the polarity bits */
5195 *polarity = (phy_data & IGP01E1000_PHY_POLARITY_MASK) ?
5196 e1000_rev_polarity_reversed :
5197 e1000_rev_polarity_normal;
5198 } else {
5199 /* For 10 Mbps, read the polarity bit in the status register. (for
5200 * 100 Mbps this bit is always 0) */
5201 *polarity =
5202 (phy_data & IGP01E1000_PSSR_POLARITY_REVERSED) ?
5203 e1000_rev_polarity_reversed :
5204 e1000_rev_polarity_normal;
5205 }
5206 }
5207 return E1000_SUCCESS;
5208 }
5209
5210 /**
5211 * e1000_check_downshift - Check if Downshift occurred
5212 * @hw: Struct containing variables accessed by shared code
5213 * @downshift: output parameter : 0 - No Downshift occurred.
5214 * 1 - Downshift occurred.
5215 *
5216 * returns: - E1000_ERR_XXX
5217 * E1000_SUCCESS
5218 *
5219 * For phy's older than IGP, this function reads the Downshift bit in the Phy
5220 * Specific Status register. For IGP phy's, it reads the Downgrade bit in the
5221 * Link Health register. In IGP this bit is latched high, so the driver must
5222 * read it immediately after link is established.
5223 */
5224 static s32 e1000_check_downshift(struct e1000_hw *hw)
5225 {
5226 s32 ret_val;
5227 u16 phy_data;
5228
5229 e_dbg("e1000_check_downshift");
5230
5231 if (hw->phy_type == e1000_phy_igp) {
5232 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_LINK_HEALTH,
5233 &phy_data);
5234 if (ret_val)
5235 return ret_val;
5236
5237 hw->speed_downgraded =
5238 (phy_data & IGP01E1000_PLHR_SS_DOWNGRADE) ? 1 : 0;
5239 } else if (hw->phy_type == e1000_phy_m88) {
5240 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5241 &phy_data);
5242 if (ret_val)
5243 return ret_val;
5244
5245 hw->speed_downgraded = (phy_data & M88E1000_PSSR_DOWNSHIFT) >>
5246 M88E1000_PSSR_DOWNSHIFT_SHIFT;
5247 }
5248
5249 return E1000_SUCCESS;
5250 }
5251
5252 /**
5253 * e1000_config_dsp_after_link_change
5254 * @hw: Struct containing variables accessed by shared code
5255 * @link_up: was link up at the time this was called
5256 *
5257 * returns: - E1000_ERR_PHY if fail to read/write the PHY
5258 * E1000_SUCCESS at any other case.
5259 *
5260 * 82541_rev_2 & 82547_rev_2 have the capability to configure the DSP when a
5261 * gigabit link is achieved to improve link quality.
5262 */
5263
5264 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
5265 {
5266 s32 ret_val;
5267 u16 phy_data, phy_saved_data, speed, duplex, i;
5268 static const u16 dsp_reg_array[IGP01E1000_PHY_CHANNEL_NUM] = {
5269 IGP01E1000_PHY_AGC_PARAM_A,
5270 IGP01E1000_PHY_AGC_PARAM_B,
5271 IGP01E1000_PHY_AGC_PARAM_C,
5272 IGP01E1000_PHY_AGC_PARAM_D
5273 };
5274 u16 min_length, max_length;
5275
5276 e_dbg("e1000_config_dsp_after_link_change");
5277
5278 if (hw->phy_type != e1000_phy_igp)
5279 return E1000_SUCCESS;
5280
5281 if (link_up) {
5282 ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
5283 if (ret_val) {
5284 e_dbg("Error getting link speed and duplex\n");
5285 return ret_val;
5286 }
5287
5288 if (speed == SPEED_1000) {
5289
5290 ret_val =
5291 e1000_get_cable_length(hw, &min_length,
5292 &max_length);
5293 if (ret_val)
5294 return ret_val;
5295
5296 if ((hw->dsp_config_state == e1000_dsp_config_enabled)
5297 && min_length >= e1000_igp_cable_length_50) {
5298
5299 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5300 ret_val =
5301 e1000_read_phy_reg(hw,
5302 dsp_reg_array[i],
5303 &phy_data);
5304 if (ret_val)
5305 return ret_val;
5306
5307 phy_data &=
5308 ~IGP01E1000_PHY_EDAC_MU_INDEX;
5309
5310 ret_val =
5311 e1000_write_phy_reg(hw,
5312 dsp_reg_array
5313 [i], phy_data);
5314 if (ret_val)
5315 return ret_val;
5316 }
5317 hw->dsp_config_state =
5318 e1000_dsp_config_activated;
5319 }
5320
5321 if ((hw->ffe_config_state == e1000_ffe_config_enabled)
5322 && (min_length < e1000_igp_cable_length_50)) {
5323
5324 u16 ffe_idle_err_timeout =
5325 FFE_IDLE_ERR_COUNT_TIMEOUT_20;
5326 u32 idle_errs = 0;
5327
5328 /* clear previous idle error counts */
5329 ret_val =
5330 e1000_read_phy_reg(hw, PHY_1000T_STATUS,
5331 &phy_data);
5332 if (ret_val)
5333 return ret_val;
5334
5335 for (i = 0; i < ffe_idle_err_timeout; i++) {
5336 udelay(1000);
5337 ret_val =
5338 e1000_read_phy_reg(hw,
5339 PHY_1000T_STATUS,
5340 &phy_data);
5341 if (ret_val)
5342 return ret_val;
5343
5344 idle_errs +=
5345 (phy_data &
5346 SR_1000T_IDLE_ERROR_CNT);
5347 if (idle_errs >
5348 SR_1000T_PHY_EXCESSIVE_IDLE_ERR_COUNT)
5349 {
5350 hw->ffe_config_state =
5351 e1000_ffe_config_active;
5352
5353 ret_val =
5354 e1000_write_phy_reg(hw,
5355 IGP01E1000_PHY_DSP_FFE,
5356 IGP01E1000_PHY_DSP_FFE_CM_CP);
5357 if (ret_val)
5358 return ret_val;
5359 break;
5360 }
5361
5362 if (idle_errs)
5363 ffe_idle_err_timeout =
5364 FFE_IDLE_ERR_COUNT_TIMEOUT_100;
5365 }
5366 }
5367 }
5368 } else {
5369 if (hw->dsp_config_state == e1000_dsp_config_activated) {
5370 /* Save off the current value of register 0x2F5B to be restored at
5371 * the end of the routines. */
5372 ret_val =
5373 e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
5374
5375 if (ret_val)
5376 return ret_val;
5377
5378 /* Disable the PHY transmitter */
5379 ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
5380
5381 if (ret_val)
5382 return ret_val;
5383
5384 mdelay(20);
5385
5386 ret_val = e1000_write_phy_reg(hw, 0x0000,
5387 IGP01E1000_IEEE_FORCE_GIGA);
5388 if (ret_val)
5389 return ret_val;
5390 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5391 ret_val =
5392 e1000_read_phy_reg(hw, dsp_reg_array[i],
5393 &phy_data);
5394 if (ret_val)
5395 return ret_val;
5396
5397 phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
5398 phy_data |= IGP01E1000_PHY_EDAC_SIGN_EXT_9_BITS;
5399
5400 ret_val =
5401 e1000_write_phy_reg(hw, dsp_reg_array[i],
5402 phy_data);
5403 if (ret_val)
5404 return ret_val;
5405 }
5406
5407 ret_val = e1000_write_phy_reg(hw, 0x0000,
5408 IGP01E1000_IEEE_RESTART_AUTONEG);
5409 if (ret_val)
5410 return ret_val;
5411
5412 mdelay(20);
5413
5414 /* Now enable the transmitter */
5415 ret_val =
5416 e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
5417
5418 if (ret_val)
5419 return ret_val;
5420
5421 hw->dsp_config_state = e1000_dsp_config_enabled;
5422 }
5423
5424 if (hw->ffe_config_state == e1000_ffe_config_active) {
5425 /* Save off the current value of register 0x2F5B to be restored at
5426 * the end of the routines. */
5427 ret_val =
5428 e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
5429
5430 if (ret_val)
5431 return ret_val;
5432
5433 /* Disable the PHY transmitter */
5434 ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
5435
5436 if (ret_val)
5437 return ret_val;
5438
5439 mdelay(20);
5440
5441 ret_val = e1000_write_phy_reg(hw, 0x0000,
5442 IGP01E1000_IEEE_FORCE_GIGA);
5443 if (ret_val)
5444 return ret_val;
5445 ret_val =
5446 e1000_write_phy_reg(hw, IGP01E1000_PHY_DSP_FFE,
5447 IGP01E1000_PHY_DSP_FFE_DEFAULT);
5448 if (ret_val)
5449 return ret_val;
5450
5451 ret_val = e1000_write_phy_reg(hw, 0x0000,
5452 IGP01E1000_IEEE_RESTART_AUTONEG);
5453 if (ret_val)
5454 return ret_val;
5455
5456 mdelay(20);
5457
5458 /* Now enable the transmitter */
5459 ret_val =
5460 e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
5461
5462 if (ret_val)
5463 return ret_val;
5464
5465 hw->ffe_config_state = e1000_ffe_config_enabled;
5466 }
5467 }
5468 return E1000_SUCCESS;
5469 }
5470
5471 /**
5472 * e1000_set_phy_mode - Set PHY to class A mode
5473 * @hw: Struct containing variables accessed by shared code
5474 *
5475 * Assumes the following operations will follow to enable the new class mode.
5476 * 1. Do a PHY soft reset
5477 * 2. Restart auto-negotiation or force link.
5478 */
5479 static s32 e1000_set_phy_mode(struct e1000_hw *hw)
5480 {
5481 s32 ret_val;
5482 u16 eeprom_data;
5483
5484 e_dbg("e1000_set_phy_mode");
5485
5486 if ((hw->mac_type == e1000_82545_rev_3) &&
5487 (hw->media_type == e1000_media_type_copper)) {
5488 ret_val =
5489 e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1,
5490 &eeprom_data);
5491 if (ret_val) {
5492 return ret_val;
5493 }
5494
5495 if ((eeprom_data != EEPROM_RESERVED_WORD) &&
5496 (eeprom_data & EEPROM_PHY_CLASS_A)) {
5497 ret_val =
5498 e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT,
5499 0x000B);
5500 if (ret_val)
5501 return ret_val;
5502 ret_val =
5503 e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL,
5504 0x8104);
5505 if (ret_val)
5506 return ret_val;
5507
5508 hw->phy_reset_disable = false;
5509 }
5510 }
5511
5512 return E1000_SUCCESS;
5513 }
5514
5515 /**
5516 * e1000_set_d3_lplu_state - set d3 link power state
5517 * @hw: Struct containing variables accessed by shared code
5518 * @active: true to enable lplu false to disable lplu.
5519 *
5520 * This function sets the lplu state according to the active flag. When
5521 * activating lplu this function also disables smart speed and vise versa.
5522 * lplu will not be activated unless the device autonegotiation advertisement
5523 * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
5524 *
5525 * returns: - E1000_ERR_PHY if fail to read/write the PHY
5526 * E1000_SUCCESS at any other case.
5527 */
5528 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
5529 {
5530 s32 ret_val;
5531 u16 phy_data;
5532 e_dbg("e1000_set_d3_lplu_state");
5533
5534 if (hw->phy_type != e1000_phy_igp)
5535 return E1000_SUCCESS;
5536
5537 /* During driver activity LPLU should not be used or it will attain link
5538 * from the lowest speeds starting from 10Mbps. The capability is used for
5539 * Dx transitions and states */
5540 if (hw->mac_type == e1000_82541_rev_2
5541 || hw->mac_type == e1000_82547_rev_2) {
5542 ret_val =
5543 e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data);
5544 if (ret_val)
5545 return ret_val;
5546 }
5547
5548 if (!active) {
5549 if (hw->mac_type == e1000_82541_rev_2 ||
5550 hw->mac_type == e1000_82547_rev_2) {
5551 phy_data &= ~IGP01E1000_GMII_FLEX_SPD;
5552 ret_val =
5553 e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
5554 phy_data);
5555 if (ret_val)
5556 return ret_val;
5557 }
5558
5559 /* LPLU and SmartSpeed are mutually exclusive. LPLU is used during
5560 * Dx states where the power conservation is most important. During
5561 * driver activity we should enable SmartSpeed, so performance is
5562 * maintained. */
5563 if (hw->smart_speed == e1000_smart_speed_on) {
5564 ret_val =
5565 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5566 &phy_data);
5567 if (ret_val)
5568 return ret_val;
5569
5570 phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
5571 ret_val =
5572 e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5573 phy_data);
5574 if (ret_val)
5575 return ret_val;
5576 } else if (hw->smart_speed == e1000_smart_speed_off) {
5577 ret_val =
5578 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5579 &phy_data);
5580 if (ret_val)
5581 return ret_val;
5582
5583 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
5584 ret_val =
5585 e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5586 phy_data);
5587 if (ret_val)
5588 return ret_val;
5589 }
5590 } else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT)
5591 || (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL)
5592 || (hw->autoneg_advertised ==
5593 AUTONEG_ADVERTISE_10_100_ALL)) {
5594
5595 if (hw->mac_type == e1000_82541_rev_2 ||
5596 hw->mac_type == e1000_82547_rev_2) {
5597 phy_data |= IGP01E1000_GMII_FLEX_SPD;
5598 ret_val =
5599 e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
5600 phy_data);
5601 if (ret_val)
5602 return ret_val;
5603 }
5604
5605 /* When LPLU is enabled we should disable SmartSpeed */
5606 ret_val =
5607 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5608 &phy_data);
5609 if (ret_val)
5610 return ret_val;
5611
5612 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
5613 ret_val =
5614 e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5615 phy_data);
5616 if (ret_val)
5617 return ret_val;
5618
5619 }
5620 return E1000_SUCCESS;
5621 }
5622
5623 /**
5624 * e1000_set_vco_speed
5625 * @hw: Struct containing variables accessed by shared code
5626 *
5627 * Change VCO speed register to improve Bit Error Rate performance of SERDES.
5628 */
5629 static s32 e1000_set_vco_speed(struct e1000_hw *hw)
5630 {
5631 s32 ret_val;
5632 u16 default_page = 0;
5633 u16 phy_data;
5634
5635 e_dbg("e1000_set_vco_speed");
5636
5637 switch (hw->mac_type) {
5638 case e1000_82545_rev_3:
5639 case e1000_82546_rev_3:
5640 break;
5641 default:
5642 return E1000_SUCCESS;
5643 }
5644
5645 /* Set PHY register 30, page 5, bit 8 to 0 */
5646
5647 ret_val =
5648 e1000_read_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, &default_page);
5649 if (ret_val)
5650 return ret_val;
5651
5652 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0005);
5653 if (ret_val)
5654 return ret_val;
5655
5656 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
5657 if (ret_val)
5658 return ret_val;
5659
5660 phy_data &= ~M88E1000_PHY_VCO_REG_BIT8;
5661 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
5662 if (ret_val)
5663 return ret_val;
5664
5665 /* Set PHY register 30, page 4, bit 11 to 1 */
5666
5667 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0004);
5668 if (ret_val)
5669 return ret_val;
5670
5671 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
5672 if (ret_val)
5673 return ret_val;
5674
5675 phy_data |= M88E1000_PHY_VCO_REG_BIT11;
5676 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
5677 if (ret_val)
5678 return ret_val;
5679
5680 ret_val =
5681 e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, default_page);
5682 if (ret_val)
5683 return ret_val;
5684
5685 return E1000_SUCCESS;
5686 }
5687
5688
5689 /**
5690 * e1000_enable_mng_pass_thru - check for bmc pass through
5691 * @hw: Struct containing variables accessed by shared code
5692 *
5693 * Verifies the hardware needs to allow ARPs to be processed by the host
5694 * returns: - true/false
5695 */
5696 u32 e1000_enable_mng_pass_thru(struct e1000_hw *hw)
5697 {
5698 u32 manc;
5699
5700 if (hw->asf_firmware_present) {
5701 manc = er32(MANC);
5702
5703 if (!(manc & E1000_MANC_RCV_TCO_EN) ||
5704 !(manc & E1000_MANC_EN_MAC_ADDR_FILTER))
5705 return false;
5706 if ((manc & E1000_MANC_SMBUS_EN) && !(manc & E1000_MANC_ASF_EN))
5707 return true;
5708 }
5709 return false;
5710 }
5711
5712 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw)
5713 {
5714 s32 ret_val;
5715 u16 mii_status_reg;
5716 u16 i;
5717
5718 /* Polarity reversal workaround for forced 10F/10H links. */
5719
5720 /* Disable the transmitter on the PHY */
5721
5722 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
5723 if (ret_val)
5724 return ret_val;
5725 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFFF);
5726 if (ret_val)
5727 return ret_val;
5728
5729 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
5730 if (ret_val)
5731 return ret_val;
5732
5733 /* This loop will early-out if the NO link condition has been met. */
5734 for (i = PHY_FORCE_TIME; i > 0; i--) {
5735 /* Read the MII Status Register and wait for Link Status bit
5736 * to be clear.
5737 */
5738
5739 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5740 if (ret_val)
5741 return ret_val;
5742
5743 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5744 if (ret_val)
5745 return ret_val;
5746
5747 if ((mii_status_reg & ~MII_SR_LINK_STATUS) == 0)
5748 break;
5749 mdelay(100);
5750 }
5751
5752 /* Recommended delay time after link has been lost */
5753 mdelay(1000);
5754
5755 /* Now we will re-enable th transmitter on the PHY */
5756
5757 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
5758 if (ret_val)
5759 return ret_val;
5760 mdelay(50);
5761 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFF0);
5762 if (ret_val)
5763 return ret_val;
5764 mdelay(50);
5765 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFF00);
5766 if (ret_val)
5767 return ret_val;
5768 mdelay(50);
5769 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x0000);
5770 if (ret_val)
5771 return ret_val;
5772
5773 ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
5774 if (ret_val)
5775 return ret_val;
5776
5777 /* This loop will early-out if the link condition has been met. */
5778 for (i = PHY_FORCE_TIME; i > 0; i--) {
5779 /* Read the MII Status Register and wait for Link Status bit
5780 * to be set.
5781 */
5782
5783 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5784 if (ret_val)
5785 return ret_val;
5786
5787 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5788 if (ret_val)
5789 return ret_val;
5790
5791 if (mii_status_reg & MII_SR_LINK_STATUS)
5792 break;
5793 mdelay(100);
5794 }
5795 return E1000_SUCCESS;
5796 }
5797
5798 /**
5799 * e1000_get_auto_rd_done
5800 * @hw: Struct containing variables accessed by shared code
5801 *
5802 * Check for EEPROM Auto Read bit done.
5803 * returns: - E1000_ERR_RESET if fail to reset MAC
5804 * E1000_SUCCESS at any other case.
5805 */
5806 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw)
5807 {
5808 e_dbg("e1000_get_auto_rd_done");
5809 msleep(5);
5810 return E1000_SUCCESS;
5811 }
5812
5813 /**
5814 * e1000_get_phy_cfg_done
5815 * @hw: Struct containing variables accessed by shared code
5816 *
5817 * Checks if the PHY configuration is done
5818 * returns: - E1000_ERR_RESET if fail to reset MAC
5819 * E1000_SUCCESS at any other case.
5820 */
5821 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw)
5822 {
5823 e_dbg("e1000_get_phy_cfg_done");
5824 mdelay(10);
5825 return E1000_SUCCESS;
5826 }
Mirror of the linux-mips.org kernel tree