[e1000e] Add e1000e driver
[people/pcmattman/gpxe.git] / src / drivers / net / e1000e / e1000e_phy.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2009 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 FILE_LICENCE ( GPL2_OR_LATER );
30
31 #include "e1000e.h"
32
33 static s32 e1000e_copper_link_autoneg(struct e1000_hw *hw);
34 static s32 e1000e_phy_setup_autoneg(struct e1000_hw *hw);
35 static u32 e1000e_get_phy_addr_for_bm_page(u32 page, u32 reg);
36 static s32 e1000e_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
37                                           u16 *data, bool read);
38 static u32 e1000e_get_phy_addr_for_hv_page(u32 page);
39 static s32 e1000e_access_phy_debug_regs_hv(struct e1000_hw *hw, u32 offset,
40                                           u16 *data, bool read);
41 #if 0
42 /* Cable length tables */
43 static const u16 e1000_m88_cable_length_table[] =
44         { 0, 50, 80, 110, 140, 140, E1000_CABLE_LENGTH_UNDEFINED };
45 #define M88E1000_CABLE_LENGTH_TABLE_SIZE \
46                 (sizeof(e1000_m88_cable_length_table) / \
47                  sizeof(e1000_m88_cable_length_table[0]))
48
49 static const u16 e1000_igp_2_cable_length_table[] =
50     { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
51       0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
52       6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
53       21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
54       40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
55       60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
56       83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
57       104, 109, 114, 118, 121, 124};
58 #define IGP02E1000_CABLE_LENGTH_TABLE_SIZE \
59                 (sizeof(e1000_igp_2_cable_length_table) / \
60                  sizeof(e1000_igp_2_cable_length_table[0]))
61 #endif
62
63 /**
64  *  e1000e_check_reset_block_generic - Check if PHY reset is blocked
65  *  @hw: pointer to the HW structure
66  *
67  *  Read the PHY management control register and check whether a PHY reset
68  *  is blocked.  If a reset is not blocked return E1000_SUCCESS, otherwise
69  *  return E1000_BLK_PHY_RESET (12).
70  **/
71 s32 e1000e_check_reset_block_generic(struct e1000_hw *hw)
72 {
73         u32 manc;
74
75         manc = er32(MANC);
76
77         return (manc & E1000_MANC_BLK_PHY_RST_ON_IDE) ?
78                E1000_BLK_PHY_RESET : E1000_SUCCESS;
79 }
80
81 /**
82  *  e1000e_get_phy_id - Retrieve the PHY ID and revision
83  *  @hw: pointer to the HW structure
84  *
85  *  Reads the PHY registers and stores the PHY ID and possibly the PHY
86  *  revision in the hardware structure.
87  **/
88 s32 e1000e_get_phy_id(struct e1000_hw *hw)
89 {
90         struct e1000_phy_info *phy = &hw->phy;
91         s32 ret_val = E1000_SUCCESS;
92         u16 phy_id;
93         u16 retry_count = 0;
94
95         if (!(phy->ops.read_reg))
96                 goto out;
97
98         while (retry_count < 2) {
99                 ret_val = e1e_rphy(hw, PHY_ID1, &phy_id);
100                 if (ret_val)
101                         goto out;
102
103                 phy->id = (u32)(phy_id << 16);
104                 udelay(20);
105                 ret_val = e1e_rphy(hw, PHY_ID2, &phy_id);
106                 if (ret_val)
107                         goto out;
108
109                 phy->id |= (u32)(phy_id & PHY_REVISION_MASK);
110                 phy->revision = (u32)(phy_id & ~PHY_REVISION_MASK);
111
112                 if (phy->id != 0 && phy->id != PHY_REVISION_MASK)
113                         goto out;
114
115                 /*
116                  * If the PHY ID is still unknown, we may have an 82577
117                  * without link.  We will try again after setting Slow MDIC
118                  * mode. No harm in trying again in this case since the PHY
119                  * ID is unknown at this point anyway.
120                  */
121                 ret_val = phy->ops.acquire(hw);
122                 if (ret_val)
123                         goto out;
124                 ret_val = e1000e_set_mdio_slow_mode_hv(hw, true);
125                 if (ret_val)
126                         goto out;
127                 phy->ops.release(hw);
128
129                 retry_count++;
130         }
131 out:
132         /* Revert to MDIO fast mode, if applicable */
133         if (retry_count) {
134                 ret_val = phy->ops.acquire(hw);
135                 if (ret_val)
136                         return ret_val;
137                 ret_val = e1000e_set_mdio_slow_mode_hv(hw, false);
138                 phy->ops.release(hw);
139         }
140
141         return ret_val;
142 }
143
144 /**
145  *  e1000e_phy_reset_dsp - Reset PHY DSP
146  *  @hw: pointer to the HW structure
147  *
148  *  Reset the digital signal processor.
149  **/
150 s32 e1000e_phy_reset_dsp(struct e1000_hw *hw)
151 {
152         s32 ret_val = E1000_SUCCESS;
153
154         if (!(hw->phy.ops.write_reg))
155                 goto out;
156
157         ret_val = e1e_wphy(hw, M88E1000_PHY_GEN_CONTROL, 0xC1);
158         if (ret_val)
159                 goto out;
160
161         ret_val = e1e_wphy(hw, M88E1000_PHY_GEN_CONTROL, 0);
162
163 out:
164         return ret_val;
165 }
166
167 /**
168  *  e1000e_read_phy_reg_mdic - Read MDI control register
169  *  @hw: pointer to the HW structure
170  *  @offset: register offset to be read
171  *  @data: pointer to the read data
172  *
173  *  Reads the MDI control register in the PHY at offset and stores the
174  *  information read to data.
175  **/
176 s32 e1000e_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)
177 {
178         struct e1000_phy_info *phy = &hw->phy;
179         u32 i, mdic = 0;
180         s32 ret_val = E1000_SUCCESS;
181
182         /*
183          * Set up Op-code, Phy Address, and register offset in the MDI
184          * Control register.  The MAC will take care of interfacing with the
185          * PHY to retrieve the desired data.
186          */
187         mdic = ((offset << E1000_MDIC_REG_SHIFT) |
188                 (phy->addr << E1000_MDIC_PHY_SHIFT) |
189                 (E1000_MDIC_OP_READ));
190
191         ew32(MDIC, mdic);
192
193         /*
194          * Poll the ready bit to see if the MDI read completed
195          * Increasing the time out as testing showed failures with
196          * the lower time out
197          */
198         for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {
199                 udelay(50);
200                 mdic = er32(MDIC);
201                 if (mdic & E1000_MDIC_READY)
202                         break;
203         }
204         if (!(mdic & E1000_MDIC_READY)) {
205                 e_dbg("MDI Read did not complete\n");
206                 ret_val = -E1000_ERR_PHY;
207                 goto out;
208         }
209         if (mdic & E1000_MDIC_ERROR) {
210                 e_dbg("MDI Error\n");
211                 ret_val = -E1000_ERR_PHY;
212                 goto out;
213         }
214         *data = (u16) mdic;
215
216 out:
217         return ret_val;
218 }
219
220 /**
221  *  e1000e_write_phy_reg_mdic - Write MDI control register
222  *  @hw: pointer to the HW structure
223  *  @offset: register offset to write to
224  *  @data: data to write to register at offset
225  *
226  *  Writes data to MDI control register in the PHY at offset.
227  **/
228 s32 e1000e_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data)
229 {
230         struct e1000_phy_info *phy = &hw->phy;
231         u32 i, mdic = 0;
232         s32 ret_val = E1000_SUCCESS;
233
234         /*
235          * Set up Op-code, Phy Address, and register offset in the MDI
236          * Control register.  The MAC will take care of interfacing with the
237          * PHY to retrieve the desired data.
238          */
239         mdic = (((u32)data) |
240                 (offset << E1000_MDIC_REG_SHIFT) |
241                 (phy->addr << E1000_MDIC_PHY_SHIFT) |
242                 (E1000_MDIC_OP_WRITE));
243
244         ew32(MDIC, mdic);
245
246         /*
247          * Poll the ready bit to see if the MDI read completed
248          * Increasing the time out as testing showed failures with
249          * the lower time out
250          */
251         for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {
252                 udelay(50);
253                 mdic = er32(MDIC);
254                 if (mdic & E1000_MDIC_READY)
255                         break;
256         }
257         if (!(mdic & E1000_MDIC_READY)) {
258                 e_dbg("MDI Write did not complete\n");
259                 ret_val = -E1000_ERR_PHY;
260                 goto out;
261         }
262         if (mdic & E1000_MDIC_ERROR) {
263                 e_dbg("MDI Error\n");
264                 ret_val = -E1000_ERR_PHY;
265                 goto out;
266         }
267
268 out:
269         return ret_val;
270 }
271
272 /**
273  *  e1000e_read_phy_reg_m88 - Read m88 PHY register
274  *  @hw: pointer to the HW structure
275  *  @offset: register offset to be read
276  *  @data: pointer to the read data
277  *
278  *  Acquires semaphore, if necessary, then reads the PHY register at offset
279  *  and storing the retrieved information in data.  Release any acquired
280  *  semaphores before exiting.
281  **/
282 s32 e1000e_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data)
283 {
284         s32 ret_val = E1000_SUCCESS;
285
286         if (!(hw->phy.ops.acquire))
287                 goto out;
288
289         ret_val = hw->phy.ops.acquire(hw);
290         if (ret_val)
291                 goto out;
292
293         ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
294                                           data);
295
296         hw->phy.ops.release(hw);
297
298 out:
299         return ret_val;
300 }
301
302 /**
303  *  e1000e_write_phy_reg_m88 - Write m88 PHY register
304  *  @hw: pointer to the HW structure
305  *  @offset: register offset to write to
306  *  @data: data to write at register offset
307  *
308  *  Acquires semaphore, if necessary, then writes the data to PHY register
309  *  at the offset.  Release any acquired semaphores before exiting.
310  **/
311 s32 e1000e_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data)
312 {
313         s32 ret_val = E1000_SUCCESS;
314
315         if (!(hw->phy.ops.acquire))
316                 goto out;
317
318         ret_val = hw->phy.ops.acquire(hw);
319         if (ret_val)
320                 goto out;
321
322         ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
323                                            data);
324
325         hw->phy.ops.release(hw);
326
327 out:
328         return ret_val;
329 }
330
331 /**
332  *  __e1000e_read_phy_reg_igp - Read igp PHY register
333  *  @hw: pointer to the HW structure
334  *  @offset: register offset to be read
335  *  @data: pointer to the read data
336  *  @locked: semaphore has already been acquired or not
337  *
338  *  Acquires semaphore, if necessary, then reads the PHY register at offset
339  *  and stores the retrieved information in data.  Release any acquired
340  *  semaphores before exiting.
341  **/
342 static s32 __e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data,
343                                     bool locked)
344 {
345         s32 ret_val = E1000_SUCCESS;
346
347         if (!locked) {
348                 if (!(hw->phy.ops.acquire))
349                         goto out;
350
351                 ret_val = hw->phy.ops.acquire(hw);
352                 if (ret_val)
353                         goto out;
354         }
355
356         if (offset > MAX_PHY_MULTI_PAGE_REG) {
357                 ret_val = e1000e_write_phy_reg_mdic(hw,
358                                                    IGP01E1000_PHY_PAGE_SELECT,
359                                                    (u16)offset);
360                 if (ret_val)
361                         goto release;
362         }
363
364         ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
365                                           data);
366
367 release:
368         if (!locked)
369                 hw->phy.ops.release(hw);
370 out:
371         return ret_val;
372 }
373
374 /**
375  *  e1000e_read_phy_reg_igp - Read igp PHY register
376  *  @hw: pointer to the HW structure
377  *  @offset: register offset to be read
378  *  @data: pointer to the read data
379  *
380  *  Acquires semaphore then reads the PHY register at offset and stores the
381  *  retrieved information in data.
382  *  Release the acquired semaphore before exiting.
383  **/
384 s32 e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)
385 {
386         return __e1000e_read_phy_reg_igp(hw, offset, data, false);
387 }
388
389 /**
390  *  e1000e_read_phy_reg_igp_locked - Read igp PHY register
391  *  @hw: pointer to the HW structure
392  *  @offset: register offset to be read
393  *  @data: pointer to the read data
394  *
395  *  Reads the PHY register at offset and stores the retrieved information
396  *  in data.  Assumes semaphore already acquired.
397  **/
398 s32 e1000e_read_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 *data)
399 {
400         return __e1000e_read_phy_reg_igp(hw, offset, data, true);
401 }
402
403 /**
404  *  e1000e_write_phy_reg_igp - Write igp PHY register
405  *  @hw: pointer to the HW structure
406  *  @offset: register offset to write to
407  *  @data: data to write at register offset
408  *  @locked: semaphore has already been acquired or not
409  *
410  *  Acquires semaphore, if necessary, then writes the data to PHY register
411  *  at the offset.  Release any acquired semaphores before exiting.
412  **/
413 static s32 __e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data,
414                                      bool locked)
415 {
416         s32 ret_val = E1000_SUCCESS;
417
418         if (!locked) {
419                 if (!(hw->phy.ops.acquire))
420                         goto out;
421
422                 ret_val = hw->phy.ops.acquire(hw);
423                 if (ret_val)
424                         goto out;
425         }
426
427         if (offset > MAX_PHY_MULTI_PAGE_REG) {
428                 ret_val = e1000e_write_phy_reg_mdic(hw,
429                                                    IGP01E1000_PHY_PAGE_SELECT,
430                                                    (u16)offset);
431                 if (ret_val)
432                         goto release;
433         }
434
435         ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
436                                            data);
437
438 release:
439         if (!locked)
440                 hw->phy.ops.release(hw);
441
442 out:
443         return ret_val;
444 }
445
446 /**
447  *  e1000e_write_phy_reg_igp - Write igp PHY register
448  *  @hw: pointer to the HW structure
449  *  @offset: register offset to write to
450  *  @data: data to write at register offset
451  *
452  *  Acquires semaphore then writes the data to PHY register
453  *  at the offset.  Release any acquired semaphores before exiting.
454  **/
455 s32 e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)
456 {
457         return __e1000e_write_phy_reg_igp(hw, offset, data, false);
458 }
459
460 /**
461  *  e1000e_write_phy_reg_igp_locked - Write igp PHY register
462  *  @hw: pointer to the HW structure
463  *  @offset: register offset to write to
464  *  @data: data to write at register offset
465  *
466  *  Writes the data to PHY register at the offset.
467  *  Assumes semaphore already acquired.
468  **/
469 s32 e1000e_write_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 data)
470 {
471         return __e1000e_write_phy_reg_igp(hw, offset, data, true);
472 }
473
474 /**
475  *  __e1000e_read_kmrn_reg - Read kumeran register
476  *  @hw: pointer to the HW structure
477  *  @offset: register offset to be read
478  *  @data: pointer to the read data
479  *  @locked: semaphore has already been acquired or not
480  *
481  *  Acquires semaphore, if necessary.  Then reads the PHY register at offset
482  *  using the kumeran interface.  The information retrieved is stored in data.
483  *  Release any acquired semaphores before exiting.
484  **/
485 static s32 __e1000e_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data,
486                                  bool locked)
487 {
488         u32 kmrnctrlsta;
489         s32 ret_val = E1000_SUCCESS;
490
491         if (!locked) {
492                 if (!(hw->phy.ops.acquire))
493                         goto out;
494
495                 ret_val = hw->phy.ops.acquire(hw);
496                 if (ret_val)
497                         goto out;
498         }
499
500         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
501                        E1000_KMRNCTRLSTA_OFFSET) | E1000_KMRNCTRLSTA_REN;
502         ew32(KMRNCTRLSTA, kmrnctrlsta);
503
504         udelay(2);
505
506         kmrnctrlsta = er32(KMRNCTRLSTA);
507         *data = (u16)kmrnctrlsta;
508
509         if (!locked)
510                 hw->phy.ops.release(hw);
511
512 out:
513         return ret_val;
514 }
515
516 /**
517  *  e1000e_read_kmrn_reg -  Read kumeran register
518  *  @hw: pointer to the HW structure
519  *  @offset: register offset to be read
520  *  @data: pointer to the read data
521  *
522  *  Acquires semaphore then reads the PHY register at offset using the
523  *  kumeran interface.  The information retrieved is stored in data.
524  *  Release the acquired semaphore before exiting.
525  **/
526 s32 e1000e_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data)
527 {
528         return __e1000e_read_kmrn_reg(hw, offset, data, false);
529 }
530
531 /**
532  *  e1000e_read_kmrn_reg_locked -  Read kumeran register
533  *  @hw: pointer to the HW structure
534  *  @offset: register offset to be read
535  *  @data: pointer to the read data
536  *
537  *  Reads the PHY register at offset using the kumeran interface.  The
538  *  information retrieved is stored in data.
539  *  Assumes semaphore already acquired.
540  **/
541 s32 e1000e_read_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 *data)
542 {
543         return __e1000e_read_kmrn_reg(hw, offset, data, true);
544 }
545
546 /**
547  *  __e1000e_write_kmrn_reg - Write kumeran register
548  *  @hw: pointer to the HW structure
549  *  @offset: register offset to write to
550  *  @data: data to write at register offset
551  *  @locked: semaphore has already been acquired or not
552  *
553  *  Acquires semaphore, if necessary.  Then write the data to PHY register
554  *  at the offset using the kumeran interface.  Release any acquired semaphores
555  *  before exiting.
556  **/
557 static s32 __e1000e_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data,
558                                   bool locked)
559 {
560         u32 kmrnctrlsta;
561         s32 ret_val = E1000_SUCCESS;
562
563         if (!locked) {
564                 if (!(hw->phy.ops.acquire))
565                         goto out;
566
567                 ret_val = hw->phy.ops.acquire(hw);
568                 if (ret_val)
569                         goto out;
570         }
571
572         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
573                        E1000_KMRNCTRLSTA_OFFSET) | data;
574         ew32(KMRNCTRLSTA, kmrnctrlsta);
575
576         udelay(2);
577
578         if (!locked)
579                 hw->phy.ops.release(hw);
580
581 out:
582         return ret_val;
583 }
584
585 /**
586  *  e1000e_write_kmrn_reg -  Write kumeran register
587  *  @hw: pointer to the HW structure
588  *  @offset: register offset to write to
589  *  @data: data to write at register offset
590  *
591  *  Acquires semaphore then writes the data to the PHY register at the offset
592  *  using the kumeran interface.  Release the acquired semaphore before exiting.
593  **/
594 s32 e1000e_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data)
595 {
596         return __e1000e_write_kmrn_reg(hw, offset, data, false);
597 }
598
599 /**
600  *  e1000e_write_kmrn_reg_locked -  Write kumeran register
601  *  @hw: pointer to the HW structure
602  *  @offset: register offset to write to
603  *  @data: data to write at register offset
604  *
605  *  Write the data to PHY register at the offset using the kumeran interface.
606  *  Assumes semaphore already acquired.
607  **/
608 s32 e1000e_write_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 data)
609 {
610         return __e1000e_write_kmrn_reg(hw, offset, data, true);
611 }
612
613 /**
614  *  e1000e_copper_link_setup_82577 - Setup 82577 PHY for copper link
615  *  @hw: pointer to the HW structure
616  *
617  *  Sets up Carrier-sense on Transmit and downshift values.
618  **/
619 s32 e1000e_copper_link_setup_82577(struct e1000_hw *hw)
620 {
621         struct e1000_phy_info *phy = &hw->phy;
622         s32 ret_val;
623         u16 phy_data;
624
625         if (phy->reset_disable) {
626                 ret_val = E1000_SUCCESS;
627                 goto out;
628         }
629
630         /* Enable CRS on TX. This must be set for half-duplex operation. */
631         ret_val = e1e_rphy(hw, I82577_CFG_REG, &phy_data);
632         if (ret_val)
633                 goto out;
634
635         phy_data |= I82577_CFG_ASSERT_CRS_ON_TX;
636
637         /* Enable downshift */
638         phy_data |= I82577_CFG_ENABLE_DOWNSHIFT;
639
640         ret_val = e1e_wphy(hw, I82577_CFG_REG, phy_data);
641
642 out:
643         return ret_val;
644 }
645
646 /**
647  *  e1000e_copper_link_setup_m88 - Setup m88 PHY's for copper link
648  *  @hw: pointer to the HW structure
649  *
650  *  Sets up MDI/MDI-X and polarity for m88 PHY's.  If necessary, transmit clock
651  *  and downshift values are set also.
652  **/
653 s32 e1000e_copper_link_setup_m88(struct e1000_hw *hw)
654 {
655         struct e1000_phy_info *phy = &hw->phy;
656         s32 ret_val;
657         u16 phy_data;
658
659         if (phy->reset_disable) {
660                 ret_val = E1000_SUCCESS;
661                 goto out;
662         }
663
664         /* Enable CRS on TX. This must be set for half-duplex operation. */
665         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
666         if (ret_val)
667                 goto out;
668
669         /* For BM PHY this bit is downshift enable */
670         if (phy->type != e1000_phy_bm)
671                 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
672
673         /*
674          * Options:
675          *   MDI/MDI-X = 0 (default)
676          *   0 - Auto for all speeds
677          *   1 - MDI mode
678          *   2 - MDI-X mode
679          *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
680          */
681         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
682
683         switch (phy->mdix) {
684         case 1:
685                 phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
686                 break;
687         case 2:
688                 phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
689                 break;
690         case 3:
691                 phy_data |= M88E1000_PSCR_AUTO_X_1000T;
692                 break;
693         case 0:
694         default:
695                 phy_data |= M88E1000_PSCR_AUTO_X_MODE;
696                 break;
697         }
698
699         /*
700          * Options:
701          *   disable_polarity_correction = 0 (default)
702          *       Automatic Correction for Reversed Cable Polarity
703          *   0 - Disabled
704          *   1 - Enabled
705          */
706         phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
707         if (phy->disable_polarity_correction == 1)
708                 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
709
710         /* Enable downshift on BM (disabled by default) */
711         if (phy->type == e1000_phy_bm)
712                 phy_data |= BME1000_PSCR_ENABLE_DOWNSHIFT;
713
714         ret_val = e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
715         if (ret_val)
716                 goto out;
717
718         if ((phy->type == e1000_phy_m88) &&
719             (phy->revision < E1000_REVISION_4) &&
720             (phy->id != BME1000_E_PHY_ID_R2)) {
721                 /*
722                  * Force TX_CLK in the Extended PHY Specific Control Register
723                  * to 25MHz clock.
724                  */
725                 ret_val = e1e_rphy(hw, M88E1000_EXT_PHY_SPEC_CTRL,
726                                              &phy_data);
727                 if (ret_val)
728                         goto out;
729
730                 phy_data |= M88E1000_EPSCR_TX_CLK_25;
731
732                 if ((phy->revision == E1000_REVISION_2) &&
733                     (phy->id == M88E1111_I_PHY_ID)) {
734                         /* 82573L PHY - set the downshift counter to 5x. */
735                         phy_data &= ~M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK;
736                         phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
737                 } else {
738                         /* Configure Master and Slave downshift values */
739                         phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
740                                      M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
741                         phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
742                                      M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
743                 }
744                 ret_val = e1e_wphy(hw, M88E1000_EXT_PHY_SPEC_CTRL,
745                                              phy_data);
746                 if (ret_val)
747                         goto out;
748         }
749
750         if ((phy->type == e1000_phy_bm) && (phy->id == BME1000_E_PHY_ID_R2)) {
751                 /* Set PHY page 0, register 29 to 0x0003 */
752                 ret_val = e1e_wphy(hw, 29, 0x0003);
753                 if (ret_val)
754                         goto out;
755
756                 /* Set PHY page 0, register 30 to 0x0000 */
757                 ret_val = e1e_wphy(hw, 30, 0x0000);
758                 if (ret_val)
759                         goto out;
760         }
761
762         /* Commit the changes. */
763         ret_val = e1000e_commit_phy(hw);
764         if (ret_val) {
765                 e_dbg("Error committing the PHY changes\n");
766                 goto out;
767         }
768
769         if (phy->type == e1000_phy_82578) {
770                 ret_val = e1e_rphy(hw, M88E1000_EXT_PHY_SPEC_CTRL,
771                                             &phy_data);
772                 if (ret_val)
773                         goto out;
774
775                 /* 82578 PHY - set the downshift count to 1x. */
776                 phy_data |= I82578_EPSCR_DOWNSHIFT_ENABLE;
777                 phy_data &= ~I82578_EPSCR_DOWNSHIFT_COUNTER_MASK;
778                 ret_val = e1e_wphy(hw, M88E1000_EXT_PHY_SPEC_CTRL,
779                                              phy_data);
780                 if (ret_val)
781                         goto out;
782         }
783
784 out:
785         return ret_val;
786 }
787
788 /**
789  *  e1000e_copper_link_setup_igp - Setup igp PHY's for copper link
790  *  @hw: pointer to the HW structure
791  *
792  *  Sets up LPLU, MDI/MDI-X, polarity, Smartspeed and Master/Slave config for
793  *  igp PHY's.
794  **/
795 s32 e1000e_copper_link_setup_igp(struct e1000_hw *hw)
796 {
797         struct e1000_phy_info *phy = &hw->phy;
798         s32 ret_val;
799         u16 data;
800
801         if (phy->reset_disable) {
802                 ret_val = E1000_SUCCESS;
803                 goto out;
804         }
805
806         ret_val = e1000e_phy_hw_reset(hw);
807         if (ret_val) {
808                 e_dbg("Error resetting the PHY.\n");
809                 goto out;
810         }
811
812         /*
813          * Wait 100ms for MAC to configure PHY from NVM settings, to avoid
814          * timeout issues when LFS is enabled.
815          */
816         msleep(100);
817
818         /*
819          * The NVM settings will configure LPLU in D3 for
820          * non-IGP1 PHYs.
821          */
822         if (phy->type == e1000_phy_igp) {
823                 /* disable lplu d3 during driver init */
824                 ret_val = hw->phy.ops.set_d3_lplu_state(hw, false);
825                 if (ret_val) {
826                         e_dbg("Error Disabling LPLU D3\n");
827                         goto out;
828                 }
829         }
830
831         /* disable lplu d0 during driver init */
832         if (hw->phy.ops.set_d0_lplu_state) {
833                 ret_val = hw->phy.ops.set_d0_lplu_state(hw, false);
834                 if (ret_val) {
835                         e_dbg("Error Disabling LPLU D0\n");
836                         goto out;
837                 }
838         }
839         /* Configure mdi-mdix settings */
840         ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_CTRL, &data);
841         if (ret_val)
842                 goto out;
843
844         data &= ~IGP01E1000_PSCR_AUTO_MDIX;
845
846         switch (phy->mdix) {
847         case 1:
848                 data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
849                 break;
850         case 2:
851                 data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
852                 break;
853         case 0:
854         default:
855                 data |= IGP01E1000_PSCR_AUTO_MDIX;
856                 break;
857         }
858         ret_val = e1e_wphy(hw, IGP01E1000_PHY_PORT_CTRL, data);
859         if (ret_val)
860                 goto out;
861
862         /* set auto-master slave resolution settings */
863         if (hw->mac.autoneg) {
864                 /*
865                  * when autonegotiation advertisement is only 1000Mbps then we
866                  * should disable SmartSpeed and enable Auto MasterSlave
867                  * resolution as hardware default.
868                  */
869                 if (phy->autoneg_advertised == ADVERTISE_1000_FULL) {
870                         /* Disable SmartSpeed */
871                         ret_val = e1e_rphy(hw,
872                                                      IGP01E1000_PHY_PORT_CONFIG,
873                                                      &data);
874                         if (ret_val)
875                                 goto out;
876
877                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
878                         ret_val = e1e_wphy(hw,
879                                                      IGP01E1000_PHY_PORT_CONFIG,
880                                                      data);
881                         if (ret_val)
882                                 goto out;
883
884                         /* Set auto Master/Slave resolution process */
885                         ret_val = e1e_rphy(hw, PHY_1000T_CTRL, &data);
886                         if (ret_val)
887                                 goto out;
888
889                         data &= ~CR_1000T_MS_ENABLE;
890                         ret_val = e1e_wphy(hw, PHY_1000T_CTRL, data);
891                         if (ret_val)
892                                 goto out;
893                 }
894
895                 ret_val = e1e_rphy(hw, PHY_1000T_CTRL, &data);
896                 if (ret_val)
897                         goto out;
898
899                 /* load defaults for future use */
900                 phy->original_ms_type = (data & CR_1000T_MS_ENABLE) ?
901                         ((data & CR_1000T_MS_VALUE) ?
902                         e1000_ms_force_master :
903                         e1000_ms_force_slave) :
904                         e1000_ms_auto;
905
906                 switch (phy->ms_type) {
907                 case e1000_ms_force_master:
908                         data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
909                         break;
910                 case e1000_ms_force_slave:
911                         data |= CR_1000T_MS_ENABLE;
912                         data &= ~(CR_1000T_MS_VALUE);
913                         break;
914                 case e1000_ms_auto:
915                         data &= ~CR_1000T_MS_ENABLE;
916                 default:
917                         break;
918                 }
919                 ret_val = e1e_wphy(hw, PHY_1000T_CTRL, data);
920                 if (ret_val)
921                         goto out;
922         }
923
924 out:
925         return ret_val;
926 }
927
928 /**
929  *  e1000e_copper_link_autoneg - Setup/Enable autoneg for copper link
930  *  @hw: pointer to the HW structure
931  *
932  *  Performs initial bounds checking on autoneg advertisement parameter, then
933  *  configure to advertise the full capability.  Setup the PHY to autoneg
934  *  and restart the negotiation process between the link partner.  If
935  *  autoneg_wait_to_complete, then wait for autoneg to complete before exiting.
936  **/
937 static s32 e1000e_copper_link_autoneg(struct e1000_hw *hw)
938 {
939         struct e1000_phy_info *phy = &hw->phy;
940         s32 ret_val;
941         u16 phy_ctrl;
942
943         /*
944          * Perform some bounds checking on the autoneg advertisement
945          * parameter.
946          */
947         phy->autoneg_advertised &= phy->autoneg_mask;
948
949         /*
950          * If autoneg_advertised is zero, we assume it was not defaulted
951          * by the calling code so we set to advertise full capability.
952          */
953         if (phy->autoneg_advertised == 0)
954                 phy->autoneg_advertised = phy->autoneg_mask;
955
956         e_dbg("Reconfiguring auto-neg advertisement params\n");
957         ret_val = e1000e_phy_setup_autoneg(hw);
958         if (ret_val) {
959                 e_dbg("Error Setting up Auto-Negotiation\n");
960                 goto out;
961         }
962         e_dbg("Restarting Auto-Neg\n");
963
964         /*
965          * Restart auto-negotiation by setting the Auto Neg Enable bit and
966          * the Auto Neg Restart bit in the PHY control register.
967          */
968         ret_val = e1e_rphy(hw, PHY_CONTROL, &phy_ctrl);
969         if (ret_val)
970                 goto out;
971
972         phy_ctrl |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
973         ret_val = e1e_wphy(hw, PHY_CONTROL, phy_ctrl);
974         if (ret_val)
975                 goto out;
976
977         /*
978          * Does the user want to wait for Auto-Neg to complete here, or
979          * check at a later time (for example, callback routine).
980          */
981         if (phy->autoneg_wait_to_complete) {
982                 ret_val = hw->mac.ops.wait_autoneg(hw);
983                 if (ret_val) {
984                         e_dbg("Error while waiting for "
985                                  "autoneg to complete\n");
986                         goto out;
987                 }
988         }
989
990         hw->mac.get_link_status = true;
991
992 out:
993         return ret_val;
994 }
995
996 /**
997  *  e1000e_phy_setup_autoneg - Configure PHY for auto-negotiation
998  *  @hw: pointer to the HW structure
999  *
1000  *  Reads the MII auto-neg advertisement register and/or the 1000T control
1001  *  register and if the PHY is already setup for auto-negotiation, then
1002  *  return successful.  Otherwise, setup advertisement and flow control to
1003  *  the appropriate values for the wanted auto-negotiation.
1004  **/
1005 static s32 e1000e_phy_setup_autoneg(struct e1000_hw *hw)
1006 {
1007         struct e1000_phy_info *phy = &hw->phy;
1008         s32 ret_val;
1009         u16 mii_autoneg_adv_reg;
1010         u16 mii_1000t_ctrl_reg = 0;
1011
1012         phy->autoneg_advertised &= phy->autoneg_mask;
1013
1014         /* Read the MII Auto-Neg Advertisement Register (Address 4). */
1015         ret_val = e1e_rphy(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
1016         if (ret_val)
1017                 goto out;
1018
1019         if (phy->autoneg_mask & ADVERTISE_1000_FULL) {
1020                 /* Read the MII 1000Base-T Control Register (Address 9). */
1021                 ret_val = e1e_rphy(hw, PHY_1000T_CTRL,
1022                                             &mii_1000t_ctrl_reg);
1023                 if (ret_val)
1024                         goto out;
1025         }
1026
1027         /*
1028          * Need to parse both autoneg_advertised and fc and set up
1029          * the appropriate PHY registers.  First we will parse for
1030          * autoneg_advertised software override.  Since we can advertise
1031          * a plethora of combinations, we need to check each bit
1032          * individually.
1033          */
1034
1035         /*
1036          * First we clear all the 10/100 mb speed bits in the Auto-Neg
1037          * Advertisement Register (Address 4) and the 1000 mb speed bits in
1038          * the  1000Base-T Control Register (Address 9).
1039          */
1040         mii_autoneg_adv_reg &= ~(NWAY_AR_100TX_FD_CAPS |
1041                                  NWAY_AR_100TX_HD_CAPS |
1042                                  NWAY_AR_10T_FD_CAPS   |
1043                                  NWAY_AR_10T_HD_CAPS);
1044         mii_1000t_ctrl_reg &= ~(CR_1000T_HD_CAPS | CR_1000T_FD_CAPS);
1045
1046         e_dbg("autoneg_advertised %x\n", phy->autoneg_advertised);
1047
1048         /* Do we want to advertise 10 Mb Half Duplex? */
1049         if (phy->autoneg_advertised & ADVERTISE_10_HALF) {
1050                 e_dbg("Advertise 10mb Half duplex\n");
1051                 mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
1052         }
1053
1054         /* Do we want to advertise 10 Mb Full Duplex? */
1055         if (phy->autoneg_advertised & ADVERTISE_10_FULL) {
1056                 e_dbg("Advertise 10mb Full duplex\n");
1057                 mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
1058         }
1059
1060         /* Do we want to advertise 100 Mb Half Duplex? */
1061         if (phy->autoneg_advertised & ADVERTISE_100_HALF) {
1062                 e_dbg("Advertise 100mb Half duplex\n");
1063                 mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
1064         }
1065
1066         /* Do we want to advertise 100 Mb Full Duplex? */
1067         if (phy->autoneg_advertised & ADVERTISE_100_FULL) {
1068                 e_dbg("Advertise 100mb Full duplex\n");
1069                 mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
1070         }
1071
1072         /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
1073         if (phy->autoneg_advertised & ADVERTISE_1000_HALF)
1074                 e_dbg("Advertise 1000mb Half duplex request denied!\n");
1075
1076         /* Do we want to advertise 1000 Mb Full Duplex? */
1077         if (phy->autoneg_advertised & ADVERTISE_1000_FULL) {
1078                 e_dbg("Advertise 1000mb Full duplex\n");
1079                 mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
1080         }
1081
1082         /*
1083          * Check for a software override of the flow control settings, and
1084          * setup the PHY advertisement registers accordingly.  If
1085          * auto-negotiation is enabled, then software will have to set the
1086          * "PAUSE" bits to the correct value in the Auto-Negotiation
1087          * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-
1088          * negotiation.
1089          *
1090          * The possible values of the "fc" parameter are:
1091          *      0:  Flow control is completely disabled
1092          *      1:  Rx flow control is enabled (we can receive pause frames
1093          *          but not send pause frames).
1094          *      2:  Tx flow control is enabled (we can send pause frames
1095          *          but we do not support receiving pause frames).
1096          *      3:  Both Rx and Tx flow control (symmetric) are enabled.
1097          *  other:  No software override.  The flow control configuration
1098          *          in the EEPROM is used.
1099          */
1100         switch (hw->fc.current_mode) {
1101         case e1000_fc_none:
1102                 /*
1103                  * Flow control (Rx & Tx) is completely disabled by a
1104                  * software over-ride.
1105                  */
1106                 mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1107                 break;
1108         case e1000_fc_rx_pause:
1109                 /*
1110                  * Rx Flow control is enabled, and Tx Flow control is
1111                  * disabled, by a software over-ride.
1112                  *
1113                  * Since there really isn't a way to advertise that we are
1114                  * capable of Rx Pause ONLY, we will advertise that we
1115                  * support both symmetric and asymmetric Rx PAUSE.  Later
1116                  * (in e1000e_config_fc_after_link_up) we will disable the
1117                  * hw's ability to send PAUSE frames.
1118                  */
1119                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1120                 break;
1121         case e1000_fc_tx_pause:
1122                 /*
1123                  * Tx Flow control is enabled, and Rx Flow control is
1124                  * disabled, by a software over-ride.
1125                  */
1126                 mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
1127                 mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
1128                 break;
1129         case e1000_fc_full:
1130                 /*
1131                  * Flow control (both Rx and Tx) is enabled by a software
1132                  * over-ride.
1133                  */
1134                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1135                 break;
1136         default:
1137                 e_dbg("Flow control param set incorrectly\n");
1138                 ret_val = -E1000_ERR_CONFIG;
1139                 goto out;
1140         }
1141
1142         ret_val = e1e_wphy(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
1143         if (ret_val)
1144                 goto out;
1145
1146         e_dbg("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
1147
1148         if (phy->autoneg_mask & ADVERTISE_1000_FULL) {
1149                 ret_val = e1e_wphy(hw,
1150                                               PHY_1000T_CTRL,
1151                                               mii_1000t_ctrl_reg);
1152                 if (ret_val)
1153                         goto out;
1154         }
1155
1156 out:
1157         return ret_val;
1158 }
1159
1160 /**
1161  *  e1000e_setup_copper_link - Configure copper link settings
1162  *  @hw: pointer to the HW structure
1163  *
1164  *  Calls the appropriate function to configure the link for auto-neg or forced
1165  *  speed and duplex.  Then we check for link, once link is established calls
1166  *  to configure collision distance and flow control are called.  If link is
1167  *  not established, we return -E1000_ERR_PHY (-2).
1168  **/
1169 s32 e1000e_setup_copper_link(struct e1000_hw *hw)
1170 {
1171         s32 ret_val;
1172         bool link;
1173
1174         if (hw->mac.autoneg) {
1175                 /*
1176                  * Setup autoneg and flow control advertisement and perform
1177                  * autonegotiation.
1178                  */
1179                 ret_val = e1000e_copper_link_autoneg(hw);
1180                 if (ret_val)
1181                         goto out;
1182         } else {
1183 #if 0
1184                 /*
1185                  * PHY will be set to 10H, 10F, 100H or 100F
1186                  * depending on user settings.
1187                  */
1188                 e_dbg("Forcing Speed and Duplex\n");
1189                 ret_val = hw->phy.ops.force_speed_duplex(hw);
1190                 if (ret_val) {
1191                         e_dbg("Error Forcing Speed and Duplex\n");
1192                         goto out;
1193                 }
1194 #endif
1195         }
1196
1197         /*
1198          * Check link status. Wait up to 100 microseconds for link to become
1199          * valid.
1200          */
1201         ret_val = e1000e_phy_has_link_generic(hw,
1202                                              COPPER_LINK_UP_LIMIT,
1203                                              10,
1204                                              &link);
1205         if (ret_val)
1206                 goto out;
1207
1208         if (link) {
1209                 e_dbg("Valid link established!!!\n");
1210                 e1000e_config_collision_dist(hw);
1211                 ret_val = e1000e_config_fc_after_link_up(hw);
1212         } else {
1213                 e_dbg("Unable to establish link!!!\n");
1214         }
1215
1216 out:
1217         return ret_val;
1218 }
1219
1220 #if 0
1221 /**
1222  *  e1000e_phy_force_speed_duplex_igp - Force speed/duplex for igp PHY
1223  *  @hw: pointer to the HW structure
1224  *
1225  *  Calls the PHY setup function to force speed and duplex.  Clears the
1226  *  auto-crossover to force MDI manually.  Waits for link and returns
1227  *  successful if link up is successful, else -E1000_ERR_PHY (-2).
1228  **/
1229 s32 e1000e_phy_force_speed_duplex_igp(struct e1000_hw *hw)
1230 {
1231         struct e1000_phy_info *phy = &hw->phy;
1232         s32 ret_val;
1233         u16 phy_data;
1234         bool link;
1235
1236         ret_val = e1e_rphy(hw, PHY_CONTROL, &phy_data);
1237         if (ret_val)
1238                 goto out;
1239
1240         e1000e_phy_force_speed_duplex_setup(hw, &phy_data);
1241
1242         ret_val = e1e_wphy(hw, PHY_CONTROL, phy_data);
1243         if (ret_val)
1244                 goto out;
1245
1246         /*
1247          * Clear Auto-Crossover to force MDI manually.  IGP requires MDI
1248          * forced whenever speed and duplex are forced.
1249          */
1250         ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1251         if (ret_val)
1252                 goto out;
1253
1254         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1255         phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1256
1257         ret_val = e1e_wphy(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1258         if (ret_val)
1259                 goto out;
1260
1261         e_dbg("IGP PSCR: %X\n", phy_data);
1262
1263         udelay(1);
1264
1265         if (phy->autoneg_wait_to_complete) {
1266                 e_dbg("Waiting for forced speed/duplex link on IGP phy.\n");
1267
1268                 ret_val = e1000e_phy_has_link_generic(hw,
1269                                                      PHY_FORCE_LIMIT,
1270                                                      100000,
1271                                                      &link);
1272                 if (ret_val)
1273                         goto out;
1274
1275                 if (!link)
1276                         e_dbg("Link taking longer than expected.\n");
1277
1278                 /* Try once more */
1279                 ret_val = e1000e_phy_has_link_generic(hw,
1280                                                      PHY_FORCE_LIMIT,
1281                                                      100000,
1282                                                      &link);
1283                 if (ret_val)
1284                         goto out;
1285         }
1286
1287 out:
1288         return ret_val;
1289 }
1290 #endif
1291
1292 #if 0
1293 /**
1294  *  e1000e_phy_force_speed_duplex_m88 - Force speed/duplex for m88 PHY
1295  *  @hw: pointer to the HW structure
1296  *
1297  *  Calls the PHY setup function to force speed and duplex.  Clears the
1298  *  auto-crossover to force MDI manually.  Resets the PHY to commit the
1299  *  changes.  If time expires while waiting for link up, we reset the DSP.
1300  *  After reset, TX_CLK and CRS on Tx must be set.  Return successful upon
1301  *  successful completion, else return corresponding error code.
1302  **/
1303 s32 e1000e_phy_force_speed_duplex_m88(struct e1000_hw *hw)
1304 {
1305         struct e1000_phy_info *phy = &hw->phy;
1306         s32 ret_val;
1307         u16 phy_data;
1308         bool link;
1309
1310         /*
1311          * Clear Auto-Crossover to force MDI manually.  M88E1000 requires MDI
1312          * forced whenever speed and duplex are forced.
1313          */
1314         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1315         if (ret_val)
1316                 goto out;
1317
1318         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1319         ret_val = e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1320         if (ret_val)
1321                 goto out;
1322
1323         e_dbg("M88E1000 PSCR: %X\n", phy_data);
1324
1325         ret_val = e1e_rphy(hw, PHY_CONTROL, &phy_data);
1326         if (ret_val)
1327                 goto out;
1328
1329         e1000e_phy_force_speed_duplex_setup(hw, &phy_data);
1330
1331         ret_val = e1e_wphy(hw, PHY_CONTROL, phy_data);
1332         if (ret_val)
1333                 goto out;
1334
1335         /* Reset the phy to commit changes. */
1336         ret_val = e1000e_commit_phy(hw);
1337         if (ret_val)
1338                 goto out;
1339
1340         if (phy->autoneg_wait_to_complete) {
1341                 e_dbg("Waiting for forced speed/duplex link on M88 phy.\n");
1342
1343                 ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
1344                                                      100000, &link);
1345                 if (ret_val)
1346                         goto out;
1347
1348                 if (!link) {
1349                         /*
1350                          * We didn't get link.
1351                          * Reset the DSP and cross our fingers.
1352                          */
1353                         ret_val = e1e_wphy(hw,
1354                                                       M88E1000_PHY_PAGE_SELECT,
1355                                                       0x001d);
1356                         if (ret_val)
1357                                 goto out;
1358                         ret_val = e1000e_phy_reset_dsp(hw);
1359                         if (ret_val)
1360                                 goto out;
1361                 }
1362
1363                 /* Try once more */
1364                 ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
1365                                                      100000, &link);
1366                 if (ret_val)
1367                         goto out;
1368         }
1369
1370         ret_val = e1e_rphy(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
1371         if (ret_val)
1372                 goto out;
1373
1374         /*
1375          * Resetting the phy means we need to re-force TX_CLK in the
1376          * Extended PHY Specific Control Register to 25MHz clock from
1377          * the reset value of 2.5MHz.
1378          */
1379         phy_data |= M88E1000_EPSCR_TX_CLK_25;
1380         ret_val = e1e_wphy(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1381         if (ret_val)
1382                 goto out;
1383
1384         /*
1385          * In addition, we must re-enable CRS on Tx for both half and full
1386          * duplex.
1387          */
1388         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1389         if (ret_val)
1390                 goto out;
1391
1392         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1393         ret_val = e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1394
1395 out:
1396         return ret_val;
1397 }
1398 #endif
1399
1400 #if 0
1401 /**
1402  *  e1000e_phy_force_speed_duplex_ife - Force PHY speed & duplex
1403  *  @hw: pointer to the HW structure
1404  *
1405  *  Forces the speed and duplex settings of the PHY.
1406  *  This is a function pointer entry point only called by
1407  *  PHY setup routines.
1408  **/
1409 s32 e1000e_phy_force_speed_duplex_ife(struct e1000_hw *hw)
1410 {
1411         struct e1000_phy_info *phy = &hw->phy;
1412         s32 ret_val;
1413         u16 data;
1414         bool link;
1415
1416         if (phy->type != e1000_phy_ife) {
1417                 ret_val = e1000e_phy_force_speed_duplex_igp(hw);
1418                 goto out;
1419         }
1420
1421         ret_val = e1e_rphy(hw, PHY_CONTROL, &data);
1422         if (ret_val)
1423                 goto out;
1424
1425         e1000e_phy_force_speed_duplex_setup(hw, &data);
1426
1427         ret_val = e1e_wphy(hw, PHY_CONTROL, data);
1428         if (ret_val)
1429                 goto out;
1430
1431         /* Disable MDI-X support for 10/100 */
1432         ret_val = e1e_rphy(hw, IFE_PHY_MDIX_CONTROL, &data);
1433         if (ret_val)
1434                 goto out;
1435
1436         data &= ~IFE_PMC_AUTO_MDIX;
1437         data &= ~IFE_PMC_FORCE_MDIX;
1438
1439         ret_val = e1e_wphy(hw, IFE_PHY_MDIX_CONTROL, data);
1440         if (ret_val)
1441                 goto out;
1442
1443         e_dbg("IFE PMC: %X\n", data);
1444
1445         udelay(1);
1446
1447         if (phy->autoneg_wait_to_complete) {
1448                 e_dbg("Waiting for forced speed/duplex link on IFE phy.\n");
1449
1450                 ret_val = e1000e_phy_has_link_generic(hw,
1451                                                      PHY_FORCE_LIMIT,
1452                                                      100000,
1453                                                      &link);
1454                 if (ret_val)
1455                         goto out;
1456
1457                 if (!link)
1458                         e_dbg("Link taking longer than expected.\n");
1459
1460                 /* Try once more */
1461                 ret_val = e1000e_phy_has_link_generic(hw,
1462                                                      PHY_FORCE_LIMIT,
1463                                                      100000,
1464                                                      &link);
1465                 if (ret_val)
1466                         goto out;
1467         }
1468
1469 out:
1470         return ret_val;
1471 }
1472 #endif
1473
1474 #if 0
1475 /**
1476  *  e1000e_phy_force_speed_duplex_setup - Configure forced PHY speed/duplex
1477  *  @hw: pointer to the HW structure
1478  *  @phy_ctrl: pointer to current value of PHY_CONTROL
1479  *
1480  *  Forces speed and duplex on the PHY by doing the following: disable flow
1481  *  control, force speed/duplex on the MAC, disable auto speed detection,
1482  *  disable auto-negotiation, configure duplex, configure speed, configure
1483  *  the collision distance, write configuration to CTRL register.  The
1484  *  caller must write to the PHY_CONTROL register for these settings to
1485  *  take affect.
1486  **/
1487 void e1000e_phy_force_speed_duplex_setup(struct e1000_hw *hw, u16 *phy_ctrl)
1488 {
1489         struct e1000_mac_info *mac = &hw->mac;
1490         u32 ctrl;
1491
1492         /* Turn off flow control when forcing speed/duplex */
1493         hw->fc.current_mode = e1000_fc_none;
1494
1495         /* Force speed/duplex on the mac */
1496         ctrl = er32(CTRL);
1497         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1498         ctrl &= ~E1000_CTRL_SPD_SEL;
1499
1500         /* Disable Auto Speed Detection */
1501         ctrl &= ~E1000_CTRL_ASDE;
1502
1503         /* Disable autoneg on the phy */
1504         *phy_ctrl &= ~MII_CR_AUTO_NEG_EN;
1505
1506         /* Forcing Full or Half Duplex? */
1507         if (mac->forced_speed_duplex & E1000_ALL_HALF_DUPLEX) {
1508                 ctrl &= ~E1000_CTRL_FD;
1509                 *phy_ctrl &= ~MII_CR_FULL_DUPLEX;
1510                 e_dbg("Half Duplex\n");
1511         } else {
1512                 ctrl |= E1000_CTRL_FD;
1513                 *phy_ctrl |= MII_CR_FULL_DUPLEX;
1514                 e_dbg("Full Duplex\n");
1515         }
1516
1517         /* Forcing 10mb or 100mb? */
1518         if (mac->forced_speed_duplex & E1000_ALL_100_SPEED) {
1519                 ctrl |= E1000_CTRL_SPD_100;
1520                 *phy_ctrl |= MII_CR_SPEED_100;
1521                 *phy_ctrl &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
1522                 e_dbg("Forcing 100mb\n");
1523         } else {
1524                 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1525                 *phy_ctrl |= MII_CR_SPEED_10;
1526                 *phy_ctrl &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
1527                 e_dbg("Forcing 10mb\n");
1528         }
1529
1530         e1000e_config_collision_dist(hw);
1531
1532         ew32(CTRL, ctrl);
1533 }
1534 #endif
1535
1536 /**
1537  *  e1000e_set_d3_lplu_state - Sets low power link up state for D3
1538  *  @hw: pointer to the HW structure
1539  *  @active: boolean used to enable/disable lplu
1540  *
1541  *  Success returns 0, Failure returns 1
1542  *
1543  *  The low power link up (lplu) state is set to the power management level D3
1544  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
1545  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1546  *  is used during Dx states where the power conservation is most important.
1547  *  During driver activity, SmartSpeed should be enabled so performance is
1548  *  maintained.
1549  **/
1550 s32 e1000e_set_d3_lplu_state(struct e1000_hw *hw, bool active)
1551 {
1552         struct e1000_phy_info *phy = &hw->phy;
1553         s32 ret_val = E1000_SUCCESS;
1554         u16 data;
1555
1556         if (!(hw->phy.ops.read_reg))
1557                 goto out;
1558
1559         ret_val = e1e_rphy(hw, IGP02E1000_PHY_POWER_MGMT, &data);
1560         if (ret_val)
1561                 goto out;
1562
1563         if (!active) {
1564                 data &= ~IGP02E1000_PM_D3_LPLU;
1565                 ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT,
1566                                              data);
1567                 if (ret_val)
1568                         goto out;
1569                 /*
1570                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
1571                  * during Dx states where the power conservation is most
1572                  * important.  During driver activity we should enable
1573                  * SmartSpeed, so performance is maintained.
1574                  */
1575                 if (phy->smart_speed == e1000_smart_speed_on) {
1576                         ret_val = e1e_rphy(hw,
1577                                                     IGP01E1000_PHY_PORT_CONFIG,
1578                                                     &data);
1579                         if (ret_val)
1580                                 goto out;
1581
1582                         data |= IGP01E1000_PSCFR_SMART_SPEED;
1583                         ret_val = e1e_wphy(hw,
1584                                                      IGP01E1000_PHY_PORT_CONFIG,
1585                                                      data);
1586                         if (ret_val)
1587                                 goto out;
1588                 } else if (phy->smart_speed == e1000_smart_speed_off) {
1589                         ret_val = e1e_rphy(hw,
1590                                                      IGP01E1000_PHY_PORT_CONFIG,
1591                                                      &data);
1592                         if (ret_val)
1593                                 goto out;
1594
1595                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1596                         ret_val = e1e_wphy(hw,
1597                                                      IGP01E1000_PHY_PORT_CONFIG,
1598                                                      data);
1599                         if (ret_val)
1600                                 goto out;
1601                 }
1602         } else if ((phy->autoneg_advertised == E1000_ALL_SPEED_DUPLEX) ||
1603                    (phy->autoneg_advertised == E1000_ALL_NOT_GIG) ||
1604                    (phy->autoneg_advertised == E1000_ALL_10_SPEED)) {
1605                 data |= IGP02E1000_PM_D3_LPLU;
1606                 ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT,
1607                                               data);
1608                 if (ret_val)
1609                         goto out;
1610
1611                 /* When LPLU is enabled, we should disable SmartSpeed */
1612                 ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_CONFIG,
1613                                              &data);
1614                 if (ret_val)
1615                         goto out;
1616
1617                 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1618                 ret_val = e1e_wphy(hw, IGP01E1000_PHY_PORT_CONFIG,
1619                                               data);
1620         }
1621
1622 out:
1623         return ret_val;
1624 }
1625
1626 /**
1627  *  e1000e_check_downshift - Checks whether a downshift in speed occurred
1628  *  @hw: pointer to the HW structure
1629  *
1630  *  Success returns 0, Failure returns 1
1631  *
1632  *  A downshift is detected by querying the PHY link health.
1633  **/
1634 s32 e1000e_check_downshift(struct e1000_hw *hw)
1635 {
1636         struct e1000_phy_info *phy = &hw->phy;
1637         s32 ret_val;
1638         u16 phy_data, offset, mask;
1639
1640         switch (phy->type) {
1641         case e1000_phy_m88:
1642         case e1000_phy_gg82563:
1643         case e1000_phy_bm:
1644         case e1000_phy_82578:
1645                 offset  = M88E1000_PHY_SPEC_STATUS;
1646                 mask    = M88E1000_PSSR_DOWNSHIFT;
1647                 break;
1648         case e1000_phy_igp_2:
1649         case e1000_phy_igp:
1650         case e1000_phy_igp_3:
1651                 offset  = IGP01E1000_PHY_LINK_HEALTH;
1652                 mask    = IGP01E1000_PLHR_SS_DOWNGRADE;
1653                 break;
1654         default:
1655                 /* speed downshift not supported */
1656                 phy->speed_downgraded = false;
1657                 ret_val = E1000_SUCCESS;
1658                 goto out;
1659         }
1660
1661         ret_val = e1e_rphy(hw, offset, &phy_data);
1662
1663         if (!ret_val)
1664                 phy->speed_downgraded = (phy_data & mask) ? true : false;
1665
1666 out:
1667         return ret_val;
1668 }
1669
1670 /**
1671  *  e1000e_check_polarity_m88 - Checks the polarity.
1672  *  @hw: pointer to the HW structure
1673  *
1674  *  Success returns 0, Failure returns -E1000_ERR_PHY (-2)
1675  *
1676  *  Polarity is determined based on the PHY specific status register.
1677  **/
1678 s32 e1000e_check_polarity_m88(struct e1000_hw *hw)
1679 {
1680         struct e1000_phy_info *phy = &hw->phy;
1681         s32 ret_val;
1682         u16 data;
1683
1684         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &data);
1685
1686         if (!ret_val)
1687                 phy->cable_polarity = (data & M88E1000_PSSR_REV_POLARITY)
1688                                       ? e1000_rev_polarity_reversed
1689                                       : e1000_rev_polarity_normal;
1690
1691         return ret_val;
1692 }
1693
1694 /**
1695  *  e1000e_check_polarity_igp - Checks the polarity.
1696  *  @hw: pointer to the HW structure
1697  *
1698  *  Success returns 0, Failure returns -E1000_ERR_PHY (-2)
1699  *
1700  *  Polarity is determined based on the PHY port status register, and the
1701  *  current speed (since there is no polarity at 100Mbps).
1702  **/
1703 s32 e1000e_check_polarity_igp(struct e1000_hw *hw)
1704 {
1705         struct e1000_phy_info *phy = &hw->phy;
1706         s32 ret_val;
1707         u16 data, offset, mask;
1708
1709         /*
1710          * Polarity is determined based on the speed of
1711          * our connection.
1712          */
1713         ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_STATUS, &data);
1714         if (ret_val)
1715                 goto out;
1716
1717         if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
1718             IGP01E1000_PSSR_SPEED_1000MBPS) {
1719                 offset  = IGP01E1000_PHY_PCS_INIT_REG;
1720                 mask    = IGP01E1000_PHY_POLARITY_MASK;
1721         } else {
1722                 /*
1723                  * This really only applies to 10Mbps since
1724                  * there is no polarity for 100Mbps (always 0).
1725                  */
1726                 offset  = IGP01E1000_PHY_PORT_STATUS;
1727                 mask    = IGP01E1000_PSSR_POLARITY_REVERSED;
1728         }
1729
1730         ret_val = e1e_rphy(hw, offset, &data);
1731
1732         if (!ret_val)
1733                 phy->cable_polarity = (data & mask)
1734                                       ? e1000_rev_polarity_reversed
1735                                       : e1000_rev_polarity_normal;
1736
1737 out:
1738         return ret_val;
1739 }
1740
1741 /**
1742  *  e1000e_check_polarity_ife - Check cable polarity for IFE PHY
1743  *  @hw: pointer to the HW structure
1744  *
1745  *  Polarity is determined on the polarity reversal feature being enabled.
1746  **/
1747 s32 e1000e_check_polarity_ife(struct e1000_hw *hw)
1748 {
1749         struct e1000_phy_info *phy = &hw->phy;
1750         s32 ret_val;
1751         u16 phy_data, offset, mask;
1752
1753         /*
1754          * Polarity is determined based on the reversal feature being enabled.
1755          */
1756         if (phy->polarity_correction) {
1757                 offset = IFE_PHY_EXTENDED_STATUS_CONTROL;
1758                 mask = IFE_PESC_POLARITY_REVERSED;
1759         } else {
1760                 offset = IFE_PHY_SPECIAL_CONTROL;
1761                 mask = IFE_PSC_FORCE_POLARITY;
1762         }
1763
1764         ret_val = e1e_rphy(hw, offset, &phy_data);
1765
1766         if (!ret_val)
1767                 phy->cable_polarity = (phy_data & mask)
1768                                        ? e1000_rev_polarity_reversed
1769                                        : e1000_rev_polarity_normal;
1770
1771         return ret_val;
1772 }
1773
1774 /**
1775  *  e1000e_wait_autoneg - Wait for auto-neg completion
1776  *  @hw: pointer to the HW structure
1777  *
1778  *  Waits for auto-negotiation to complete or for the auto-negotiation time
1779  *  limit to expire, which ever happens first.
1780  **/
1781 s32 e1000e_wait_autoneg(struct e1000_hw *hw)
1782 {
1783         s32 ret_val = E1000_SUCCESS;
1784         u16 i, phy_status;
1785
1786         if (!(hw->phy.ops.read_reg))
1787                 return E1000_SUCCESS;
1788
1789         /* Break after autoneg completes or PHY_AUTO_NEG_LIMIT expires. */
1790         for (i = PHY_AUTO_NEG_LIMIT; i > 0; i--) {
1791                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
1792                 if (ret_val)
1793                         break;
1794                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
1795                 if (ret_val)
1796                         break;
1797                 if (phy_status & MII_SR_AUTONEG_COMPLETE)
1798                         break;
1799                 msleep(100);
1800         }
1801
1802         /*
1803          * PHY_AUTO_NEG_TIME expiration doesn't guarantee auto-negotiation
1804          * has completed.
1805          */
1806         return ret_val;
1807 }
1808
1809 /**
1810  *  e1000e_phy_has_link_generic - Polls PHY for link
1811  *  @hw: pointer to the HW structure
1812  *  @iterations: number of times to poll for link
1813  *  @usec_interval: delay between polling attempts
1814  *  @success: pointer to whether polling was successful or not
1815  *
1816  *  Polls the PHY status register for link, 'iterations' number of times.
1817  **/
1818 s32 e1000e_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
1819                                u32 usec_interval, bool *success)
1820 {
1821         s32 ret_val = E1000_SUCCESS;
1822         u16 i, phy_status;
1823
1824         if (!(hw->phy.ops.read_reg))
1825                 return E1000_SUCCESS;
1826
1827         for (i = 0; i < iterations; i++) {
1828                 /*
1829                  * Some PHYs require the PHY_STATUS register to be read
1830                  * twice due to the link bit being sticky.  No harm doing
1831                  * it across the board.
1832                  */
1833                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
1834                 if (ret_val) {
1835                         /*
1836                          * If the first read fails, another entity may have
1837                          * ownership of the resources, wait and try again to
1838                          * see if they have relinquished the resources yet.
1839                          */
1840                         udelay(usec_interval);
1841                 }
1842                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
1843                 if (ret_val)
1844                         break;
1845                 if (phy_status & MII_SR_LINK_STATUS)
1846                         break;
1847                 if (usec_interval >= 1000)
1848                         mdelay(usec_interval/1000);
1849                 else
1850                         udelay(usec_interval);
1851         }
1852
1853         *success = (i < iterations) ? true : false;
1854
1855         return ret_val;
1856 }
1857
1858 #if 0
1859 /**
1860  *  e1000e_get_cable_length_m88 - Determine cable length for m88 PHY
1861  *  @hw: pointer to the HW structure
1862  *
1863  *  Reads the PHY specific status register to retrieve the cable length
1864  *  information.  The cable length is determined by averaging the minimum and
1865  *  maximum values to get the "average" cable length.  The m88 PHY has four
1866  *  possible cable length values, which are:
1867  *      Register Value          Cable Length
1868  *      0                       < 50 meters
1869  *      1                       50 - 80 meters
1870  *      2                       80 - 110 meters
1871  *      3                       110 - 140 meters
1872  *      4                       > 140 meters
1873  **/
1874 s32 e1000e_get_cable_length_m88(struct e1000_hw *hw)
1875 {
1876         struct e1000_phy_info *phy = &hw->phy;
1877         s32 ret_val;
1878         u16 phy_data, index;
1879
1880         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
1881         if (ret_val)
1882                 goto out;
1883
1884         index = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
1885                 M88E1000_PSSR_CABLE_LENGTH_SHIFT;
1886         if (index >= M88E1000_CABLE_LENGTH_TABLE_SIZE - 1) {
1887                 ret_val = -E1000_ERR_PHY;
1888                 goto out;
1889         }
1890
1891         phy->min_cable_length = e1000_m88_cable_length_table[index];
1892         phy->max_cable_length = e1000_m88_cable_length_table[index + 1];
1893
1894         phy->cable_length = (phy->min_cable_length + phy->max_cable_length) / 2;
1895
1896 out:
1897         return ret_val;
1898 }
1899
1900 /**
1901  *  e1000e_get_cable_length_igp_2 - Determine cable length for igp2 PHY
1902  *  @hw: pointer to the HW structure
1903  *
1904  *  The automatic gain control (agc) normalizes the amplitude of the
1905  *  received signal, adjusting for the attenuation produced by the
1906  *  cable.  By reading the AGC registers, which represent the
1907  *  combination of coarse and fine gain value, the value can be put
1908  *  into a lookup table to obtain the approximate cable length
1909  *  for each channel.
1910  **/
1911 s32 e1000e_get_cable_length_igp_2(struct e1000_hw *hw)
1912 {
1913         struct e1000_phy_info *phy = &hw->phy;
1914         s32 ret_val = E1000_SUCCESS;
1915         u16 phy_data, i, agc_value = 0;
1916         u16 cur_agc_index, max_agc_index = 0;
1917         u16 min_agc_index = IGP02E1000_CABLE_LENGTH_TABLE_SIZE - 1;
1918         u16 agc_reg_array[IGP02E1000_PHY_CHANNEL_NUM] =
1919                                                          {IGP02E1000_PHY_AGC_A,
1920                                                           IGP02E1000_PHY_AGC_B,
1921                                                           IGP02E1000_PHY_AGC_C,
1922                                                           IGP02E1000_PHY_AGC_D};
1923
1924         /* Read the AGC registers for all channels */
1925         for (i = 0; i < IGP02E1000_PHY_CHANNEL_NUM; i++) {
1926                 ret_val = e1e_rphy(hw, agc_reg_array[i], &phy_data);
1927                 if (ret_val)
1928                         goto out;
1929
1930                 /*
1931                  * Getting bits 15:9, which represent the combination of
1932                  * coarse and fine gain values.  The result is a number
1933                  * that can be put into the lookup table to obtain the
1934                  * approximate cable length.
1935                  */
1936                 cur_agc_index = (phy_data >> IGP02E1000_AGC_LENGTH_SHIFT) &
1937                                 IGP02E1000_AGC_LENGTH_MASK;
1938
1939                 /* Array index bound check. */
1940                 if ((cur_agc_index >= IGP02E1000_CABLE_LENGTH_TABLE_SIZE) ||
1941                     (cur_agc_index == 0)) {
1942                         ret_val = -E1000_ERR_PHY;
1943                         goto out;
1944                 }
1945
1946                 /* Remove min & max AGC values from calculation. */
1947                 if (e1000_igp_2_cable_length_table[min_agc_index] >
1948                     e1000_igp_2_cable_length_table[cur_agc_index])
1949                         min_agc_index = cur_agc_index;
1950                 if (e1000_igp_2_cable_length_table[max_agc_index] <
1951                     e1000_igp_2_cable_length_table[cur_agc_index])
1952                         max_agc_index = cur_agc_index;
1953
1954                 agc_value += e1000_igp_2_cable_length_table[cur_agc_index];
1955         }
1956
1957         agc_value -= (e1000_igp_2_cable_length_table[min_agc_index] +
1958                       e1000_igp_2_cable_length_table[max_agc_index]);
1959         agc_value /= (IGP02E1000_PHY_CHANNEL_NUM - 2);
1960
1961         /* Calculate cable length with the error range of +/- 10 meters. */
1962         phy->min_cable_length = ((agc_value - IGP02E1000_AGC_RANGE) > 0) ?
1963                                  (agc_value - IGP02E1000_AGC_RANGE) : 0;
1964         phy->max_cable_length = agc_value + IGP02E1000_AGC_RANGE;
1965
1966         phy->cable_length = (phy->min_cable_length + phy->max_cable_length) / 2;
1967
1968 out:
1969         return ret_val;
1970 }
1971 #endif
1972
1973 /**
1974  *  e1000e_get_phy_info_m88 - Retrieve PHY information
1975  *  @hw: pointer to the HW structure
1976  *
1977  *  Valid for only copper links.  Read the PHY status register (sticky read)
1978  *  to verify that link is up.  Read the PHY special control register to
1979  *  determine the polarity and 10base-T extended distance.  Read the PHY
1980  *  special status register to determine MDI/MDIx and current speed.  If
1981  *  speed is 1000, then determine cable length, local and remote receiver.
1982  **/
1983 s32 e1000e_get_phy_info_m88(struct e1000_hw *hw)
1984 {
1985         struct e1000_phy_info *phy = &hw->phy;
1986         s32  ret_val;
1987         u16 phy_data;
1988         bool link;
1989
1990         if (phy->media_type != e1000_media_type_copper) {
1991                 e_dbg("Phy info is only valid for copper media\n");
1992                 ret_val = -E1000_ERR_CONFIG;
1993                 goto out;
1994         }
1995
1996         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
1997         if (ret_val)
1998                 goto out;
1999
2000         if (!link) {
2001                 e_dbg("Phy info is only valid if link is up\n");
2002                 ret_val = -E1000_ERR_CONFIG;
2003                 goto out;
2004         }
2005
2006         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2007         if (ret_val)
2008                 goto out;
2009
2010         phy->polarity_correction = (phy_data & M88E1000_PSCR_POLARITY_REVERSAL)
2011                                    ? true : false;
2012
2013         ret_val = e1000e_check_polarity_m88(hw);
2014         if (ret_val)
2015                 goto out;
2016
2017         ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
2018         if (ret_val)
2019                 goto out;
2020
2021         phy->is_mdix = (phy_data & M88E1000_PSSR_MDIX) ? true : false;
2022
2023         if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
2024 #if 0
2025                 ret_val = e1000e_get_cable_length(hw);
2026 #endif
2027                 ret_val = -E1000_ERR_CONFIG;
2028                 if (ret_val)
2029                         goto out;
2030 #if 0
2031                 ret_val = e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);
2032                 if (ret_val)
2033                         goto out;
2034
2035                 phy->local_rx = (phy_data & SR_1000T_LOCAL_RX_STATUS)
2036                                 ? e1000_1000t_rx_status_ok
2037                                 : e1000_1000t_rx_status_not_ok;
2038
2039                 phy->remote_rx = (phy_data & SR_1000T_REMOTE_RX_STATUS)
2040                                  ? e1000_1000t_rx_status_ok
2041                                  : e1000_1000t_rx_status_not_ok;
2042 #endif
2043         } else {
2044                 /* Set values to "undefined" */
2045                 phy->cable_length = E1000_CABLE_LENGTH_UNDEFINED;
2046                 phy->local_rx = e1000_1000t_rx_status_undefined;
2047                 phy->remote_rx = e1000_1000t_rx_status_undefined;
2048         }
2049 out:
2050         return ret_val;
2051 }
2052
2053 /**
2054  *  e1000e_get_phy_info_igp - Retrieve igp PHY information
2055  *  @hw: pointer to the HW structure
2056  *
2057  *  Read PHY status to determine if link is up.  If link is up, then
2058  *  set/determine 10base-T extended distance and polarity correction.  Read
2059  *  PHY port status to determine MDI/MDIx and speed.  Based on the speed,
2060  *  determine on the cable length, local and remote receiver.
2061  **/
2062 s32 e1000e_get_phy_info_igp(struct e1000_hw *hw)
2063 {
2064         struct e1000_phy_info *phy = &hw->phy;
2065         s32 ret_val;
2066         u16 data;
2067         bool link;
2068
2069         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
2070         if (ret_val)
2071                 goto out;
2072
2073         if (!link) {
2074                 e_dbg("Phy info is only valid if link is up\n");
2075                 ret_val = -E1000_ERR_CONFIG;
2076                 goto out;
2077         }
2078
2079         phy->polarity_correction = true;
2080
2081         ret_val = e1000e_check_polarity_igp(hw);
2082         if (ret_val)
2083                 goto out;
2084
2085         ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_STATUS, &data);
2086         if (ret_val)
2087                 goto out;
2088
2089         phy->is_mdix = (data & IGP01E1000_PSSR_MDIX) ? true : false;
2090
2091         if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
2092             IGP01E1000_PSSR_SPEED_1000MBPS) {
2093 #if 0
2094                 ret_val = phy->ops.get_cable_length(hw);
2095 #endif
2096                 ret_val = -E1000_ERR_CONFIG;
2097                 if (ret_val)
2098                         goto out;
2099 #if 0
2100                 ret_val = e1e_rphy(hw, PHY_1000T_STATUS, &data);
2101                 if (ret_val)
2102                         goto out;
2103
2104                 phy->local_rx = (data & SR_1000T_LOCAL_RX_STATUS)
2105                                 ? e1000_1000t_rx_status_ok
2106                                 : e1000_1000t_rx_status_not_ok;
2107
2108                 phy->remote_rx = (data & SR_1000T_REMOTE_RX_STATUS)
2109                                  ? e1000_1000t_rx_status_ok
2110                                  : e1000_1000t_rx_status_not_ok;
2111 #endif
2112         } else {
2113                 phy->cable_length = E1000_CABLE_LENGTH_UNDEFINED;
2114                 phy->local_rx = e1000_1000t_rx_status_undefined;
2115                 phy->remote_rx = e1000_1000t_rx_status_undefined;
2116         }
2117 out:
2118         return ret_val;
2119 }
2120
2121 /**
2122  *  e1000e_phy_sw_reset - PHY software reset
2123  *  @hw: pointer to the HW structure
2124  *
2125  *  Does a software reset of the PHY by reading the PHY control register and
2126  *  setting/write the control register reset bit to the PHY.
2127  **/
2128 s32 e1000e_phy_sw_reset(struct e1000_hw *hw)
2129 {
2130         s32 ret_val = E1000_SUCCESS;
2131         u16 phy_ctrl;
2132
2133         if (!(hw->phy.ops.read_reg))
2134                 goto out;
2135
2136         ret_val = e1e_rphy(hw, PHY_CONTROL, &phy_ctrl);
2137         if (ret_val)
2138                 goto out;
2139
2140         phy_ctrl |= MII_CR_RESET;
2141         ret_val = e1e_wphy(hw, PHY_CONTROL, phy_ctrl);
2142         if (ret_val)
2143                 goto out;
2144
2145         udelay(1);
2146
2147 out:
2148         return ret_val;
2149 }
2150
2151 /**
2152  *  e1000e_phy_hw_reset_generic - PHY hardware reset
2153  *  @hw: pointer to the HW structure
2154  *
2155  *  Verify the reset block is not blocking us from resetting.  Acquire
2156  *  semaphore (if necessary) and read/set/write the device control reset
2157  *  bit in the PHY.  Wait the appropriate delay time for the device to
2158  *  reset and release the semaphore (if necessary).
2159  **/
2160 s32 e1000e_phy_hw_reset_generic(struct e1000_hw *hw)
2161 {
2162         struct e1000_phy_info *phy = &hw->phy;
2163         s32 ret_val = E1000_SUCCESS;
2164         u32 ctrl;
2165
2166         ret_val = e1000e_check_reset_block(hw);
2167         if (ret_val) {
2168                 ret_val = E1000_SUCCESS;
2169                 goto out;
2170         }
2171
2172         ret_val = phy->ops.acquire(hw);
2173         if (ret_val)
2174                 goto out;
2175
2176         ctrl = er32(CTRL);
2177         ew32(CTRL, ctrl | E1000_CTRL_PHY_RST);
2178         e1e_flush();
2179
2180         udelay(phy->reset_delay_us);
2181
2182         ew32(CTRL, ctrl);
2183         e1e_flush();
2184
2185         udelay(150);
2186
2187         phy->ops.release(hw);
2188
2189         ret_val = phy->ops.get_cfg_done(hw);
2190
2191 out:
2192         return ret_val;
2193 }
2194
2195 /**
2196  *  e1000e_get_cfg_done - Generic configuration done
2197  *  @hw: pointer to the HW structure
2198  *
2199  *  Generic function to wait 10 milli-seconds for configuration to complete
2200  *  and return success.
2201  **/
2202 s32 e1000e_get_cfg_done(struct e1000_hw *hw __unused)
2203 {
2204         mdelay(10);
2205
2206         return E1000_SUCCESS;
2207 }
2208
2209 /**
2210  *  e1000e_phy_init_script_igp3 - Inits the IGP3 PHY
2211  *  @hw: pointer to the HW structure
2212  *
2213  *  Initializes a Intel Gigabit PHY3 when an EEPROM is not present.
2214  **/
2215 s32 e1000e_phy_init_script_igp3(struct e1000_hw *hw)
2216 {
2217         e_dbg("Running IGP 3 PHY init script\n");
2218
2219         /* PHY init IGP 3 */
2220         /* Enable rise/fall, 10-mode work in class-A */
2221         e1e_wphy(hw, 0x2F5B, 0x9018);
2222         /* Remove all caps from Replica path filter */
2223         e1e_wphy(hw, 0x2F52, 0x0000);
2224         /* Bias trimming for ADC, AFE and Driver (Default) */
2225         e1e_wphy(hw, 0x2FB1, 0x8B24);
2226         /* Increase Hybrid poly bias */
2227         e1e_wphy(hw, 0x2FB2, 0xF8F0);
2228         /* Add 4% to Tx amplitude in Gig mode */
2229         e1e_wphy(hw, 0x2010, 0x10B0);
2230         /* Disable trimming (TTT) */
2231         e1e_wphy(hw, 0x2011, 0x0000);
2232         /* Poly DC correction to 94.6% + 2% for all channels */
2233         e1e_wphy(hw, 0x20DD, 0x249A);
2234         /* ABS DC correction to 95.9% */
2235         e1e_wphy(hw, 0x20DE, 0x00D3);
2236         /* BG temp curve trim */
2237         e1e_wphy(hw, 0x28B4, 0x04CE);
2238         /* Increasing ADC OPAMP stage 1 currents to max */
2239         e1e_wphy(hw, 0x2F70, 0x29E4);
2240         /* Force 1000 ( required for enabling PHY regs configuration) */
2241         e1e_wphy(hw, 0x0000, 0x0140);
2242         /* Set upd_freq to 6 */
2243         e1e_wphy(hw, 0x1F30, 0x1606);
2244         /* Disable NPDFE */
2245         e1e_wphy(hw, 0x1F31, 0xB814);
2246         /* Disable adaptive fixed FFE (Default) */
2247         e1e_wphy(hw, 0x1F35, 0x002A);
2248         /* Enable FFE hysteresis */
2249         e1e_wphy(hw, 0x1F3E, 0x0067);
2250         /* Fixed FFE for short cable lengths */
2251         e1e_wphy(hw, 0x1F54, 0x0065);
2252         /* Fixed FFE for medium cable lengths */
2253         e1e_wphy(hw, 0x1F55, 0x002A);
2254         /* Fixed FFE for long cable lengths */
2255         e1e_wphy(hw, 0x1F56, 0x002A);
2256         /* Enable Adaptive Clip Threshold */
2257         e1e_wphy(hw, 0x1F72, 0x3FB0);
2258         /* AHT reset limit to 1 */
2259         e1e_wphy(hw, 0x1F76, 0xC0FF);
2260         /* Set AHT master delay to 127 msec */
2261         e1e_wphy(hw, 0x1F77, 0x1DEC);
2262         /* Set scan bits for AHT */
2263         e1e_wphy(hw, 0x1F78, 0xF9EF);
2264         /* Set AHT Preset bits */
2265         e1e_wphy(hw, 0x1F79, 0x0210);
2266         /* Change integ_factor of channel A to 3 */
2267         e1e_wphy(hw, 0x1895, 0x0003);
2268         /* Change prop_factor of channels BCD to 8 */
2269         e1e_wphy(hw, 0x1796, 0x0008);
2270         /* Change cg_icount + enable integbp for channels BCD */
2271         e1e_wphy(hw, 0x1798, 0xD008);
2272         /*
2273          * Change cg_icount + enable integbp + change prop_factor_master
2274          * to 8 for channel A
2275          */
2276         e1e_wphy(hw, 0x1898, 0xD918);
2277         /* Disable AHT in Slave mode on channel A */
2278         e1e_wphy(hw, 0x187A, 0x0800);
2279         /*
2280          * Enable LPLU and disable AN to 1000 in non-D0a states,
2281          * Enable SPD+B2B
2282          */
2283         e1e_wphy(hw, 0x0019, 0x008D);
2284         /* Enable restart AN on an1000_dis change */
2285         e1e_wphy(hw, 0x001B, 0x2080);
2286         /* Enable wh_fifo read clock in 10/100 modes */
2287         e1e_wphy(hw, 0x0014, 0x0045);
2288         /* Restart AN, Speed selection is 1000 */
2289         e1e_wphy(hw, 0x0000, 0x1340);
2290
2291         return E1000_SUCCESS;
2292 }
2293
2294 /**
2295  *  e1000e_get_phy_type_from_id - Get PHY type from id
2296  *  @phy_id: phy_id read from the phy
2297  *
2298  *  Returns the phy type from the id.
2299  **/
2300 enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id)
2301 {
2302         enum e1000_phy_type phy_type = e1000_phy_unknown;
2303
2304         switch (phy_id) {
2305         case M88E1000_I_PHY_ID:
2306         case M88E1000_E_PHY_ID:
2307         case M88E1111_I_PHY_ID:
2308         case M88E1011_I_PHY_ID:
2309                 phy_type = e1000_phy_m88;
2310                 break;
2311         case IGP01E1000_I_PHY_ID: /* IGP 1 & 2 share this */
2312                 phy_type = e1000_phy_igp_2;
2313                 break;
2314         case GG82563_E_PHY_ID:
2315                 phy_type = e1000_phy_gg82563;
2316                 break;
2317         case IGP03E1000_E_PHY_ID:
2318                 phy_type = e1000_phy_igp_3;
2319                 break;
2320         case IFE_E_PHY_ID:
2321         case IFE_PLUS_E_PHY_ID:
2322         case IFE_C_E_PHY_ID:
2323                 phy_type = e1000_phy_ife;
2324                 break;
2325         case BME1000_E_PHY_ID:
2326         case BME1000_E_PHY_ID_R2:
2327                 phy_type = e1000_phy_bm;
2328                 break;
2329         case I82578_E_PHY_ID:
2330                 phy_type = e1000_phy_82578;
2331                 break;
2332         case I82577_E_PHY_ID:
2333                 phy_type = e1000_phy_82577;
2334                 break;
2335         default:
2336                 phy_type = e1000_phy_unknown;
2337                 break;
2338         }
2339         return phy_type;
2340 }
2341
2342 /**
2343  *  e1000e_determine_phy_address - Determines PHY address.
2344  *  @hw: pointer to the HW structure
2345  *
2346  *  This uses a trial and error method to loop through possible PHY
2347  *  addresses. It tests each by reading the PHY ID registers and
2348  *  checking for a match.
2349  **/
2350 s32 e1000e_determine_phy_address(struct e1000_hw *hw)
2351 {
2352         s32 ret_val = -E1000_ERR_PHY_TYPE;
2353         u32 phy_addr = 0;
2354         u32 i;
2355         enum e1000_phy_type phy_type = e1000_phy_unknown;
2356
2357         hw->phy.id = phy_type;
2358
2359         for (phy_addr = 0; phy_addr < E1000_MAX_PHY_ADDR; phy_addr++) {
2360                 hw->phy.addr = phy_addr;
2361                 i = 0;
2362
2363                 do {
2364                         e1000e_get_phy_id(hw);
2365                         phy_type = e1000e_get_phy_type_from_id(hw->phy.id);
2366
2367                         /*
2368                          * If phy_type is valid, break - we found our
2369                          * PHY address
2370                          */
2371                         if (phy_type  != e1000_phy_unknown) {
2372                                 ret_val = E1000_SUCCESS;
2373                                 goto out;
2374                         }
2375                         msleep(1);
2376                         i++;
2377                 } while (i < 10);
2378         }
2379
2380 out:
2381         return ret_val;
2382 }
2383
2384 /**
2385  *  e1000e_get_phy_addr_for_bm_page - Retrieve PHY page address
2386  *  @page: page to access
2387  *
2388  *  Returns the phy address for the page requested.
2389  **/
2390 static u32 e1000e_get_phy_addr_for_bm_page(u32 page, u32 reg)
2391 {
2392         u32 phy_addr = 2;
2393
2394         if ((page >= 768) || (page == 0 && reg == 25) || (reg == 31))
2395                 phy_addr = 1;
2396
2397         return phy_addr;
2398 }
2399
2400 /**
2401  *  e1000e_write_phy_reg_bm - Write BM PHY register
2402  *  @hw: pointer to the HW structure
2403  *  @offset: register offset to write to
2404  *  @data: data to write at register offset
2405  *
2406  *  Acquires semaphore, if necessary, then writes the data to PHY register
2407  *  at the offset.  Release any acquired semaphores before exiting.
2408  **/
2409 s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
2410 {
2411         s32 ret_val;
2412         u32 page_select = 0;
2413         u32 page = offset >> IGP_PAGE_SHIFT;
2414         u32 page_shift = 0;
2415
2416         ret_val = hw->phy.ops.acquire(hw);
2417         if (ret_val)
2418                 return ret_val;
2419
2420         /* Page 800 works differently than the rest so it has its own func */
2421         if (page == BM_WUC_PAGE) {
2422                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset, &data,
2423                                                          false);
2424                 goto out;
2425         }
2426
2427         hw->phy.addr = e1000e_get_phy_addr_for_bm_page(page, offset);
2428
2429         if (offset > MAX_PHY_MULTI_PAGE_REG) {
2430                 /*
2431                  * Page select is register 31 for phy address 1 and 22 for
2432                  * phy address 2 and 3. Page select is shifted only for
2433                  * phy address 1.
2434                  */
2435                 if (hw->phy.addr == 1) {
2436                         page_shift = IGP_PAGE_SHIFT;
2437                         page_select = IGP01E1000_PHY_PAGE_SELECT;
2438                 } else {
2439                         page_shift = 0;
2440                         page_select = BM_PHY_PAGE_SELECT;
2441                 }
2442
2443                 /* Page is shifted left, PHY expects (page x 32) */
2444                 ret_val = e1000e_write_phy_reg_mdic(hw, page_select,
2445                                                    (page << page_shift));
2446                 if (ret_val)
2447                         goto out;
2448         }
2449
2450         ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
2451                                            data);
2452
2453 out:
2454         hw->phy.ops.release(hw);
2455         return ret_val;
2456 }
2457
2458 /**
2459  *  e1000e_read_phy_reg_bm - Read BM PHY register
2460  *  @hw: pointer to the HW structure
2461  *  @offset: register offset to be read
2462  *  @data: pointer to the read data
2463  *
2464  *  Acquires semaphore, if necessary, then reads the PHY register at offset
2465  *  and storing the retrieved information in data.  Release any acquired
2466  *  semaphores before exiting.
2467  **/
2468 s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
2469 {
2470         s32 ret_val;
2471         u32 page_select = 0;
2472         u32 page = offset >> IGP_PAGE_SHIFT;
2473         u32 page_shift = 0;
2474
2475         ret_val = hw->phy.ops.acquire(hw);
2476         if (ret_val)
2477                 return ret_val;
2478
2479         /* Page 800 works differently than the rest so it has its own func */
2480         if (page == BM_WUC_PAGE) {
2481                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset, data,
2482                                                          true);
2483                 goto out;
2484         }
2485
2486         hw->phy.addr = e1000e_get_phy_addr_for_bm_page(page, offset);
2487
2488         if (offset > MAX_PHY_MULTI_PAGE_REG) {
2489                 /*
2490                  * Page select is register 31 for phy address 1 and 22 for
2491                  * phy address 2 and 3. Page select is shifted only for
2492                  * phy address 1.
2493                  */
2494                 if (hw->phy.addr == 1) {
2495                         page_shift = IGP_PAGE_SHIFT;
2496                         page_select = IGP01E1000_PHY_PAGE_SELECT;
2497                 } else {
2498                         page_shift = 0;
2499                         page_select = BM_PHY_PAGE_SELECT;
2500                 }
2501
2502                 /* Page is shifted left, PHY expects (page x 32) */
2503                 ret_val = e1000e_write_phy_reg_mdic(hw, page_select,
2504                                                    (page << page_shift));
2505                 if (ret_val)
2506                         goto out;
2507         }
2508
2509         ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
2510                                           data);
2511 out:
2512         hw->phy.ops.release(hw);
2513         return ret_val;
2514 }
2515
2516 /**
2517  *  e1000e_read_phy_reg_bm2 - Read BM PHY register
2518  *  @hw: pointer to the HW structure
2519  *  @offset: register offset to be read
2520  *  @data: pointer to the read data
2521  *
2522  *  Acquires semaphore, if necessary, then reads the PHY register at offset
2523  *  and storing the retrieved information in data.  Release any acquired
2524  *  semaphores before exiting.
2525  **/
2526 s32 e1000e_read_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 *data)
2527 {
2528         s32 ret_val;
2529         u16 page = (u16)(offset >> IGP_PAGE_SHIFT);
2530
2531         ret_val = hw->phy.ops.acquire(hw);
2532         if (ret_val)
2533                 return ret_val;
2534
2535         /* Page 800 works differently than the rest so it has its own func */
2536         if (page == BM_WUC_PAGE) {
2537                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset, data,
2538                                                          true);
2539                 goto out;
2540         }
2541
2542         hw->phy.addr = 1;
2543
2544         if (offset > MAX_PHY_MULTI_PAGE_REG) {
2545
2546                 /* Page is shifted left, PHY expects (page x 32) */
2547                 ret_val = e1000e_write_phy_reg_mdic(hw, BM_PHY_PAGE_SELECT,
2548                                                    page);
2549
2550                 if (ret_val)
2551                         goto out;
2552         }
2553
2554         ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
2555                                           data);
2556 out:
2557         hw->phy.ops.release(hw);
2558         return ret_val;
2559 }
2560
2561 /**
2562  *  e1000e_write_phy_reg_bm2 - Write BM PHY register
2563  *  @hw: pointer to the HW structure
2564  *  @offset: register offset to write to
2565  *  @data: data to write at register offset
2566  *
2567  *  Acquires semaphore, if necessary, then writes the data to PHY register
2568  *  at the offset.  Release any acquired semaphores before exiting.
2569  **/
2570 s32 e1000e_write_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 data)
2571 {
2572         s32 ret_val;
2573         u16 page = (u16)(offset >> IGP_PAGE_SHIFT);
2574
2575         ret_val = hw->phy.ops.acquire(hw);
2576         if (ret_val)
2577                 return ret_val;
2578
2579         /* Page 800 works differently than the rest so it has its own func */
2580         if (page == BM_WUC_PAGE) {
2581                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset, &data,
2582                                                          false);
2583                 goto out;
2584         }
2585
2586         hw->phy.addr = 1;
2587
2588         if (offset > MAX_PHY_MULTI_PAGE_REG) {
2589                 /* Page is shifted left, PHY expects (page x 32) */
2590                 ret_val = e1000e_write_phy_reg_mdic(hw, BM_PHY_PAGE_SELECT,
2591                                                    page);
2592
2593                 if (ret_val)
2594                         goto out;
2595         }
2596
2597         ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
2598                                            data);
2599
2600 out:
2601         hw->phy.ops.release(hw);
2602         return ret_val;
2603 }
2604
2605 /**
2606  *  e1000e_access_phy_wakeup_reg_bm - Read BM PHY wakeup register
2607  *  @hw: pointer to the HW structure
2608  *  @offset: register offset to be read or written
2609  *  @data: pointer to the data to read or write
2610  *  @read: determines if operation is read or write
2611  *
2612  *  Acquires semaphore, if necessary, then reads the PHY register at offset
2613  *  and storing the retrieved information in data.  Release any acquired
2614  *  semaphores before exiting. Note that procedure to read the wakeup
2615  *  registers are different. It works as such:
2616  *  1) Set page 769, register 17, bit 2 = 1
2617  *  2) Set page to 800 for host (801 if we were manageability)
2618  *  3) Write the address using the address opcode (0x11)
2619  *  4) Read or write the data using the data opcode (0x12)
2620  *  5) Restore 769_17.2 to its original value
2621  *
2622  *  Assumes semaphore already acquired.
2623  **/
2624 static s32 e1000e_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
2625                                           u16 *data, bool read)
2626 {
2627         s32 ret_val;
2628         u16 reg = BM_PHY_REG_NUM(offset);
2629         u16 phy_reg = 0;
2630
2631         /* Gig must be disabled for MDIO accesses to page 800 */
2632         if ((hw->mac.type == e1000_pchlan) &&
2633            (!(er32(PHY_CTRL) & E1000_PHY_CTRL_GBE_DISABLE)))
2634                 e_dbg("Attempting to access page 800 while gig enabled.\n");
2635
2636         /* All operations in this function are phy address 1 */
2637         hw->phy.addr = 1;
2638
2639         /* Set page 769 */
2640         e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
2641                                  (BM_WUC_ENABLE_PAGE << IGP_PAGE_SHIFT));
2642
2643         ret_val = e1000e_read_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, &phy_reg);
2644         if (ret_val) {
2645                 e_dbg("Could not read PHY page 769\n");
2646                 goto out;
2647         }
2648
2649         /* First clear bit 4 to avoid a power state change */
2650         phy_reg &= ~(BM_WUC_HOST_WU_BIT);
2651         ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, phy_reg);
2652         if (ret_val) {
2653                 e_dbg("Could not clear PHY page 769 bit 4\n");
2654                 goto out;
2655         }
2656
2657         /* Write bit 2 = 1, and clear bit 4 to 769_17 */
2658         ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG,
2659                                            phy_reg | BM_WUC_ENABLE_BIT);
2660         if (ret_val) {
2661                 e_dbg("Could not write PHY page 769 bit 2\n");
2662                 goto out;
2663         }
2664
2665         /* Select page 800 */
2666         ret_val = e1000e_write_phy_reg_mdic(hw,
2667                                            IGP01E1000_PHY_PAGE_SELECT,
2668                                            (BM_WUC_PAGE << IGP_PAGE_SHIFT));
2669
2670         /* Write the page 800 offset value using opcode 0x11 */
2671         ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ADDRESS_OPCODE, reg);
2672         if (ret_val) {
2673                 e_dbg("Could not write address opcode to page 800\n");
2674                 goto out;
2675         }
2676
2677         if (read) {
2678                 /* Read the page 800 value using opcode 0x12 */
2679                 ret_val = e1000e_read_phy_reg_mdic(hw, BM_WUC_DATA_OPCODE,
2680                                                   data);
2681         } else {
2682                 /* Write the page 800 value using opcode 0x12 */
2683                 ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_DATA_OPCODE,
2684                                                    *data);
2685         }
2686
2687         if (ret_val) {
2688                 e_dbg("Could not access data value from page 800\n");
2689                 goto out;
2690         }
2691
2692         /*
2693          * Restore 769_17.2 to its original value
2694          * Set page 769
2695          */
2696         e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
2697                                  (BM_WUC_ENABLE_PAGE << IGP_PAGE_SHIFT));
2698
2699         /* Clear 769_17.2 */
2700         ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, phy_reg);
2701         if (ret_val) {
2702                 e_dbg("Could not clear PHY page 769 bit 2\n");
2703                 goto out;
2704         }
2705
2706 out:
2707         return ret_val;
2708 }
2709
2710 /**
2711  * e1000e_power_up_phy_copper - Restore copper link in case of PHY power down
2712  * @hw: pointer to the HW structure
2713  *
2714  * In the case of a PHY power down to save power, or to turn off link during a
2715  * driver unload, or wake on lan is not enabled, restore the link to previous
2716  * settings.
2717  **/
2718 void e1000e_power_up_phy_copper(struct e1000_hw *hw)
2719 {
2720         u16 mii_reg = 0;
2721
2722         /* The PHY will retain its settings across a power down/up cycle */
2723         e1e_rphy(hw, PHY_CONTROL, &mii_reg);
2724         mii_reg &= ~MII_CR_POWER_DOWN;
2725         e1e_wphy(hw, PHY_CONTROL, mii_reg);
2726 }
2727
2728 /**
2729  * e1000e_power_down_phy_copper - Restore copper link in case of PHY power down
2730  * @hw: pointer to the HW structure
2731  *
2732  * In the case of a PHY power down to save power, or to turn off link during a
2733  * driver unload, or wake on lan is not enabled, restore the link to previous
2734  * settings.
2735  **/
2736 void e1000e_power_down_phy_copper(struct e1000_hw *hw)
2737 {
2738         u16 mii_reg = 0;
2739
2740         /* The PHY will retain its settings across a power down/up cycle */
2741         e1e_rphy(hw, PHY_CONTROL, &mii_reg);
2742         mii_reg |= MII_CR_POWER_DOWN;
2743         e1e_wphy(hw, PHY_CONTROL, mii_reg);
2744         msleep(1);
2745 }
2746
2747 /**
2748  *  e1000e_set_mdio_slow_mode_hv - Set slow MDIO access mode
2749  *  @hw:   pointer to the HW structure
2750  *  @slow: true for slow mode, false for normal mode
2751  *
2752  *  Assumes semaphore already acquired.
2753  **/
2754 s32 e1000e_set_mdio_slow_mode_hv(struct e1000_hw *hw, bool slow)
2755 {
2756         s32 ret_val = E1000_SUCCESS;
2757         u16 data = 0;
2758
2759         /* Set MDIO mode - page 769, register 16: 0x2580==slow, 0x2180==fast */
2760         hw->phy.addr = 1;
2761         ret_val = e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
2762                                          (BM_PORT_CTRL_PAGE << IGP_PAGE_SHIFT));
2763         if (ret_val)
2764                 goto out;
2765
2766         ret_val = e1000e_write_phy_reg_mdic(hw, BM_CS_CTRL1,
2767                                            (0x2180 | (slow << 10)));
2768         if (ret_val)
2769                 goto out;
2770
2771         /* dummy read when reverting to fast mode - throw away result */
2772         if (!slow)
2773                 ret_val = e1000e_read_phy_reg_mdic(hw, BM_CS_CTRL1, &data);
2774
2775 out:
2776         return ret_val;
2777 }
2778
2779 /**
2780  *  __e1000e_read_phy_reg_hv -  Read HV PHY register
2781  *  @hw: pointer to the HW structure
2782  *  @offset: register offset to be read
2783  *  @data: pointer to the read data
2784  *  @locked: semaphore has already been acquired or not
2785  *
2786  *  Acquires semaphore, if necessary, then reads the PHY register at offset
2787  *  and stores the retrieved information in data.  Release any acquired
2788  *  semaphore before exiting.
2789  **/
2790 static s32 __e1000e_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data,
2791                                    bool locked)
2792 {
2793         s32 ret_val;
2794         u16 page = BM_PHY_REG_PAGE(offset);
2795         u16 reg = BM_PHY_REG_NUM(offset);
2796         bool in_slow_mode = false;
2797
2798         if (!locked) {
2799                 ret_val = hw->phy.ops.acquire(hw);
2800                 if (ret_val)
2801                         return ret_val;
2802         }
2803
2804         /* Workaround failure in MDIO access while cable is disconnected */
2805         if ((hw->phy.type == e1000_phy_82577) &&
2806             !(er32(STATUS) & E1000_STATUS_LU)) {
2807                 ret_val = e1000e_set_mdio_slow_mode_hv(hw, true);
2808                 if (ret_val)
2809                         goto out;
2810
2811                 in_slow_mode = true;
2812         }
2813
2814         /* Page 800 works differently than the rest so it has its own func */
2815         if (page == BM_WUC_PAGE) {
2816                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset,
2817                                                          data, true);
2818                 goto out;
2819         }
2820
2821         if (page > 0 && page < HV_INTC_FC_PAGE_START) {
2822                 ret_val = e1000e_access_phy_debug_regs_hv(hw, offset,
2823                                                          data, true);
2824                 goto out;
2825         }
2826
2827         hw->phy.addr = e1000e_get_phy_addr_for_hv_page(page);
2828
2829         if (page == HV_INTC_FC_PAGE_START)
2830                 page = 0;
2831
2832         if (reg > MAX_PHY_MULTI_PAGE_REG) {
2833                 u32 phy_addr = hw->phy.addr;
2834
2835                 hw->phy.addr = 1;
2836
2837                 /* Page is shifted left, PHY expects (page x 32) */
2838                 ret_val = e1000e_write_phy_reg_mdic(hw,
2839                                              IGP01E1000_PHY_PAGE_SELECT,
2840                                              (page << IGP_PAGE_SHIFT));
2841                 hw->phy.addr = phy_addr;
2842
2843                 if (ret_val)
2844                         goto out;
2845         }
2846
2847         ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & reg,
2848                                           data);
2849 out:
2850         /* Revert to MDIO fast mode, if applicable */
2851         if ((hw->phy.type == e1000_phy_82577) && in_slow_mode)
2852                 ret_val |= e1000e_set_mdio_slow_mode_hv(hw, false);
2853
2854         if (!locked)
2855                 hw->phy.ops.release(hw);
2856
2857         return ret_val;
2858 }
2859
2860 /**
2861  *  e1000e_read_phy_reg_hv -  Read HV PHY register
2862  *  @hw: pointer to the HW structure
2863  *  @offset: register offset to be read
2864  *  @data: pointer to the read data
2865  *
2866  *  Acquires semaphore then reads the PHY register at offset and stores
2867  *  the retrieved information in data.  Release the acquired semaphore
2868  *  before exiting.
2869  **/
2870 s32 e1000e_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data)
2871 {
2872         return __e1000e_read_phy_reg_hv(hw, offset, data, false);
2873 }
2874
2875 /**
2876  *  e1000e_read_phy_reg_hv_locked -  Read HV PHY register
2877  *  @hw: pointer to the HW structure
2878  *  @offset: register offset to be read
2879  *  @data: pointer to the read data
2880  *
2881  *  Reads the PHY register at offset and stores the retrieved information
2882  *  in data.  Assumes semaphore already acquired.
2883  **/
2884 s32 e1000e_read_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 *data)
2885 {
2886         return __e1000e_read_phy_reg_hv(hw, offset, data, true);
2887 }
2888
2889 /**
2890  *  __e1000e_write_phy_reg_hv - Write HV PHY register
2891  *  @hw: pointer to the HW structure
2892  *  @offset: register offset to write to
2893  *  @data: data to write at register offset
2894  *  @locked: semaphore has already been acquired or not
2895  *
2896  *  Acquires semaphore, if necessary, then writes the data to PHY register
2897  *  at the offset.  Release any acquired semaphores before exiting.
2898  **/
2899 static s32 __e1000e_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data,
2900                                     bool locked)
2901 {
2902         s32 ret_val;
2903         u16 page = BM_PHY_REG_PAGE(offset);
2904         u16 reg = BM_PHY_REG_NUM(offset);
2905         bool in_slow_mode = false;
2906
2907         if (!locked) {
2908                 ret_val = hw->phy.ops.acquire(hw);
2909                 if (ret_val)
2910                         return ret_val;
2911         }
2912
2913         /* Workaround failure in MDIO access while cable is disconnected */
2914         if ((hw->phy.type == e1000_phy_82577) &&
2915             !(er32(STATUS) & E1000_STATUS_LU)) {
2916                 ret_val = e1000e_set_mdio_slow_mode_hv(hw, true);
2917                 if (ret_val)
2918                         goto out;
2919
2920                 in_slow_mode = true;
2921         }
2922
2923         /* Page 800 works differently than the rest so it has its own func */
2924         if (page == BM_WUC_PAGE) {
2925                 ret_val = e1000e_access_phy_wakeup_reg_bm(hw, offset,
2926                                                          &data, false);
2927                 goto out;
2928         }
2929
2930         if (page > 0 && page < HV_INTC_FC_PAGE_START) {
2931                 ret_val = e1000e_access_phy_debug_regs_hv(hw, offset,
2932                                                          &data, false);
2933                 goto out;
2934         }
2935
2936         hw->phy.addr = e1000e_get_phy_addr_for_hv_page(page);
2937
2938         if (page == HV_INTC_FC_PAGE_START)
2939                 page = 0;
2940
2941         /*
2942          * Workaround MDIO accesses being disabled after entering IEEE Power
2943          * Down (whenever bit 11 of the PHY Control register is set)
2944          */
2945         if ((hw->phy.type == e1000_phy_82578) &&
2946             (hw->phy.revision >= 1) &&
2947             (hw->phy.addr == 2) &&
2948             ((MAX_PHY_REG_ADDRESS & reg) == 0) &&
2949             (data & (1 << 11))) {
2950                 u16 data2 = 0x7EFF;
2951                 ret_val = e1000e_access_phy_debug_regs_hv(hw, (1 << 6) | 0x3,
2952                                                          &data2, false);
2953                 if (ret_val)
2954                         goto out;
2955         }
2956
2957         if (reg > MAX_PHY_MULTI_PAGE_REG) {
2958                 u32 phy_addr = hw->phy.addr;
2959
2960                 hw->phy.addr = 1;
2961
2962                 /* Page is shifted left, PHY expects (page x 32) */
2963                 ret_val = e1000e_write_phy_reg_mdic(hw,
2964                                              IGP01E1000_PHY_PAGE_SELECT,
2965                                              (page << IGP_PAGE_SHIFT));
2966                 hw->phy.addr = phy_addr;
2967
2968                 if (ret_val)
2969                         goto out;
2970         }
2971
2972         ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & reg,
2973                                           data);
2974
2975 out:
2976         /* Revert to MDIO fast mode, if applicable */
2977         if ((hw->phy.type == e1000_phy_82577) && in_slow_mode)
2978                 ret_val |= e1000e_set_mdio_slow_mode_hv(hw, false);
2979
2980         if (!locked)
2981                 hw->phy.ops.release(hw);
2982
2983         return ret_val;
2984 }
2985
2986 /**
2987  *  e1000e_write_phy_reg_hv - Write HV PHY register
2988  *  @hw: pointer to the HW structure
2989  *  @offset: register offset to write to
2990  *  @data: data to write at register offset
2991  *
2992  *  Acquires semaphore then writes the data to PHY register at the offset.
2993  *  Release the acquired semaphores before exiting.
2994  **/
2995 s32 e1000e_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data)
2996 {
2997         return __e1000e_write_phy_reg_hv(hw, offset, data, false);
2998 }
2999
3000 /**
3001  *  e1000e_write_phy_reg_hv_locked - Write HV PHY register
3002  *  @hw: pointer to the HW structure
3003  *  @offset: register offset to write to
3004  *  @data: data to write at register offset
3005  *
3006  *  Writes the data to PHY register at the offset.  Assumes semaphore
3007  *  already acquired.
3008  **/
3009 s32 e1000e_write_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 data)
3010 {
3011         return __e1000e_write_phy_reg_hv(hw, offset, data, true);
3012 }
3013
3014 /**
3015  *  e1000e_get_phy_addr_for_hv_page - Get PHY adrress based on page
3016  *  @page: page to be accessed
3017  **/
3018 static u32 e1000e_get_phy_addr_for_hv_page(u32 page)
3019 {
3020         u32 phy_addr = 2;
3021
3022         if (page >= HV_INTC_FC_PAGE_START)
3023                 phy_addr = 1;
3024
3025         return phy_addr;
3026 }
3027
3028 /**
3029  *  e1000e_access_phy_debug_regs_hv - Read HV PHY vendor specific high registers
3030  *  @hw: pointer to the HW structure
3031  *  @offset: register offset to be read or written
3032  *  @data: pointer to the data to be read or written
3033  *  @read: determines if operation is read or written
3034  *
3035  *  Reads the PHY register at offset and stores the retreived information
3036  *  in data.  Assumes semaphore already acquired.  Note that the procedure
3037  *  to read these regs uses the address port and data port to read/write.
3038  **/
3039 static s32 e1000e_access_phy_debug_regs_hv(struct e1000_hw *hw, u32 offset,
3040                                           u16 *data, bool read)
3041 {
3042         s32 ret_val;
3043         u32 addr_reg = 0;
3044         u32 data_reg = 0;
3045
3046         /* This takes care of the difference with desktop vs mobile phy */
3047         addr_reg = (hw->phy.type == e1000_phy_82578) ?
3048                    I82578_ADDR_REG : I82577_ADDR_REG;
3049         data_reg = addr_reg + 1;
3050
3051         /* All operations in this function are phy address 2 */
3052         hw->phy.addr = 2;
3053
3054         /* masking with 0x3F to remove the page from offset */
3055         ret_val = e1000e_write_phy_reg_mdic(hw, addr_reg, (u16)offset & 0x3F);
3056         if (ret_val) {
3057                 e_dbg("Could not write PHY the HV address register\n");
3058                 goto out;
3059         }
3060
3061         /* Read or write the data value next */
3062         if (read)
3063                 ret_val = e1000e_read_phy_reg_mdic(hw, data_reg, data);
3064         else
3065                 ret_val = e1000e_write_phy_reg_mdic(hw, data_reg, *data);
3066
3067         if (ret_val) {
3068                 e_dbg("Could not read data value from HV data register\n");
3069                 goto out;
3070         }
3071
3072 out:
3073         return ret_val;
3074 }
3075
3076 /**
3077  *  e1000e_link_stall_workaround_hv - Si workaround
3078  *  @hw: pointer to the HW structure
3079  *
3080  *  This function works around a Si bug where the link partner can get
3081  *  a link up indication before the PHY does.  If small packets are sent
3082  *  by the link partner they can be placed in the packet buffer without
3083  *  being properly accounted for by the PHY and will stall preventing
3084  *  further packets from being received.  The workaround is to clear the
3085  *  packet buffer after the PHY detects link up.
3086  **/
3087 s32 e1000e_link_stall_workaround_hv(struct e1000_hw *hw)
3088 {
3089         s32 ret_val = E1000_SUCCESS;
3090         u16 data;
3091
3092         if (hw->phy.type != e1000_phy_82578)
3093                 goto out;
3094
3095         /* Do not apply workaround if in PHY loopback bit 14 set */
3096         e1e_rphy(hw, PHY_CONTROL, &data);
3097         if (data & PHY_CONTROL_LB)
3098                 goto out;
3099
3100         /* check if link is up and at 1Gbps */
3101         ret_val = e1e_rphy(hw, BM_CS_STATUS, &data);
3102         if (ret_val)
3103                 goto out;
3104
3105         data &= BM_CS_STATUS_LINK_UP |
3106                 BM_CS_STATUS_RESOLVED |
3107                 BM_CS_STATUS_SPEED_MASK;
3108
3109         if (data != (BM_CS_STATUS_LINK_UP |
3110                      BM_CS_STATUS_RESOLVED |
3111                      BM_CS_STATUS_SPEED_1000))
3112                 goto out;
3113
3114         msleep(200);
3115
3116         /* flush the packets in the fifo buffer */
3117         ret_val = e1e_wphy(hw, HV_MUX_DATA_CTRL,
3118                                         HV_MUX_DATA_CTRL_GEN_TO_MAC |
3119                                         HV_MUX_DATA_CTRL_FORCE_SPEED);
3120         if (ret_val)
3121                 goto out;
3122
3123         ret_val = e1e_wphy(hw, HV_MUX_DATA_CTRL,
3124                                         HV_MUX_DATA_CTRL_GEN_TO_MAC);
3125
3126 out:
3127         return ret_val;
3128 }
3129
3130 /**
3131  *  e1000e_check_polarity_82577 - Checks the polarity.
3132  *  @hw: pointer to the HW structure
3133  *
3134  *  Success returns 0, Failure returns -E1000_ERR_PHY (-2)
3135  *
3136  *  Polarity is determined based on the PHY specific status register.
3137  **/
3138 s32 e1000e_check_polarity_82577(struct e1000_hw *hw)
3139 {
3140         struct e1000_phy_info *phy = &hw->phy;
3141         s32 ret_val;
3142         u16 data;
3143
3144         ret_val = e1e_rphy(hw, I82577_PHY_STATUS_2, &data);
3145
3146         if (!ret_val)
3147                 phy->cable_polarity = (data & I82577_PHY_STATUS2_REV_POLARITY)
3148                                       ? e1000_rev_polarity_reversed
3149                                       : e1000_rev_polarity_normal;
3150
3151         return ret_val;
3152 }
3153
3154 #if 0
3155 /**
3156  *  e1000e_phy_force_speed_duplex_82577 - Force speed/duplex for I82577 PHY
3157  *  @hw: pointer to the HW structure
3158  *
3159  *  Calls the PHY setup function to force speed and duplex.  Clears the
3160  *  auto-crossover to force MDI manually.  Waits for link and returns
3161  *  successful if link up is successful, else -E1000_ERR_PHY (-2).
3162  **/
3163 s32 e1000e_phy_force_speed_duplex_82577(struct e1000_hw *hw)
3164 {
3165         struct e1000_phy_info *phy = &hw->phy;
3166         s32 ret_val;
3167         u16 phy_data;
3168         bool link;
3169
3170         ret_val = e1e_rphy(hw, PHY_CONTROL, &phy_data);
3171         if (ret_val)
3172                 goto out;
3173
3174         e1000e_phy_force_speed_duplex_setup(hw, &phy_data);
3175
3176         ret_val = e1e_wphy(hw, PHY_CONTROL, phy_data);
3177         if (ret_val)
3178                 goto out;
3179
3180         /*
3181          * Clear Auto-Crossover to force MDI manually.  82577 requires MDI
3182          * forced whenever speed and duplex are forced.
3183          */
3184         ret_val = e1e_rphy(hw, I82577_PHY_CTRL_2, &phy_data);
3185         if (ret_val)
3186                 goto out;
3187
3188         phy_data &= ~I82577_PHY_CTRL2_AUTO_MDIX;
3189         phy_data &= ~I82577_PHY_CTRL2_FORCE_MDI_MDIX;
3190
3191         ret_val = e1e_wphy(hw, I82577_PHY_CTRL_2, phy_data);
3192         if (ret_val)
3193                 goto out;
3194
3195         e_dbg("I82577_PHY_CTRL_2: %X\n", phy_data);
3196
3197         udelay(1);
3198
3199         if (phy->autoneg_wait_to_complete) {
3200                 e_dbg("Waiting for forced speed/duplex link on 82577 phy\n");
3201
3202                 ret_val = e1000e_phy_has_link_generic(hw,
3203                                                      PHY_FORCE_LIMIT,
3204                                                      100000,
3205                                                      &link);
3206                 if (ret_val)
3207                         goto out;
3208
3209                 if (!link)
3210                         e_dbg("Link taking longer than expected.\n");
3211
3212                 /* Try once more */
3213                 ret_val = e1000e_phy_has_link_generic(hw,
3214                                                      PHY_FORCE_LIMIT,
3215                                                      100000,
3216                                                      &link);
3217                 if (ret_val)
3218                         goto out;
3219         }
3220
3221 out:
3222         return ret_val;
3223 }
3224 #endif
3225
3226 /**
3227  *  e1000e_get_phy_info_82577 - Retrieve I82577 PHY information
3228  *  @hw: pointer to the HW structure
3229  *
3230  *  Read PHY status to determine if link is up.  If link is up, then
3231  *  set/determine 10base-T extended distance and polarity correction.  Read
3232  *  PHY port status to determine MDI/MDIx and speed.  Based on the speed,
3233  *  determine on the cable length, local and remote receiver.
3234  **/
3235 s32 e1000e_get_phy_info_82577(struct e1000_hw *hw)
3236 {
3237         struct e1000_phy_info *phy = &hw->phy;
3238         s32 ret_val;
3239         u16 data;
3240         bool link;
3241
3242         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
3243         if (ret_val)
3244                 goto out;
3245
3246         if (!link) {
3247                 e_dbg("Phy info is only valid if link is up\n");
3248                 ret_val = -E1000_ERR_CONFIG;
3249                 goto out;
3250         }
3251
3252         phy->polarity_correction = true;
3253
3254         ret_val = e1000e_check_polarity_82577(hw);
3255         if (ret_val)
3256                 goto out;
3257
3258         ret_val = e1e_rphy(hw, I82577_PHY_STATUS_2, &data);
3259         if (ret_val)
3260                 goto out;
3261
3262         phy->is_mdix = (data & I82577_PHY_STATUS2_MDIX) ? true : false;
3263
3264         if ((data & I82577_PHY_STATUS2_SPEED_MASK) ==
3265             I82577_PHY_STATUS2_SPEED_1000MBPS) {
3266 #if 0
3267                 ret_val = e1000e_get_cable_length(hw);
3268 #endif
3269                 ret_val = -E1000_ERR_CONFIG;
3270                 if (ret_val)
3271                         goto out;
3272 #if 0
3273                 ret_val = e1e_rphy(hw, PHY_1000T_STATUS, &data);
3274                 if (ret_val)
3275                         goto out;
3276
3277                 phy->local_rx = (data & SR_1000T_LOCAL_RX_STATUS)
3278                                 ? e1000_1000t_rx_status_ok
3279                                 : e1000_1000t_rx_status_not_ok;
3280
3281                 phy->remote_rx = (data & SR_1000T_REMOTE_RX_STATUS)
3282                                  ? e1000_1000t_rx_status_ok
3283                                  : e1000_1000t_rx_status_not_ok;
3284 #endif
3285         } else {
3286                 phy->cable_length = E1000_CABLE_LENGTH_UNDEFINED;
3287                 phy->local_rx = e1000_1000t_rx_status_undefined;
3288                 phy->remote_rx = e1000_1000t_rx_status_undefined;
3289         }
3290 out:
3291         return ret_val;
3292 }
3293
3294 #if 0
3295 /**
3296  *  e1000e_get_cable_length_82577 - Determine cable length for 82577 PHY
3297  *  @hw: pointer to the HW structure
3298  *
3299  * Reads the diagnostic status register and verifies result is valid before
3300  * placing it in the phy_cable_length field.
3301  **/
3302 s32 e1000e_get_cable_length_82577(struct e1000_hw *hw)
3303 {
3304         struct e1000_phy_info *phy = &hw->phy;
3305         s32 ret_val;
3306         u16 phy_data, length;
3307
3308         ret_val = e1e_rphy(hw, I82577_PHY_DIAG_STATUS, &phy_data);
3309         if (ret_val)
3310                 goto out;
3311
3312         length = (phy_data & I82577_DSTATUS_CABLE_LENGTH) >>
3313                  I82577_DSTATUS_CABLE_LENGTH_SHIFT;
3314
3315         if (length == E1000_CABLE_LENGTH_UNDEFINED)
3316                 ret_val = -E1000_ERR_PHY;
3317
3318         phy->cable_length = length;
3319
3320 out:
3321         return ret_val;
3322 }
3323 #endif