A bit further.
[akaros.git] / kern / drivers / net / e1000 / e1000_phy.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2008 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
30 #include "e1000_api.h"
31
32 #if 0
33 /* Cable length tables */
34 static const u16 e1000_m88_cable_length_table[] =
35         { 0, 50, 80, 110, 140, 140, E1000_CABLE_LENGTH_UNDEFINED };
36 #define M88E1000_CABLE_LENGTH_TABLE_SIZE \
37                 (sizeof(e1000_m88_cable_length_table) / \
38                  sizeof(e1000_m88_cable_length_table[0]))
39
40 static const u16 e1000_igp_2_cable_length_table[] =
41     { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
42       0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
43       6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
44       21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
45       40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
46       60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
47       83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
48       104, 109, 114, 118, 121, 124};
49 #define IGP02E1000_CABLE_LENGTH_TABLE_SIZE \
50                 (sizeof(e1000_igp_2_cable_length_table) / \
51                  sizeof(e1000_igp_2_cable_length_table[0]))
52 #endif
53
54 /**
55  *  e1000_init_phy_ops_generic - Initialize PHY function pointers
56  *  @hw: pointer to the HW structure
57  *
58  *  Setups up the function pointers to no-op functions
59  **/
60 void e1000_init_phy_ops_generic(struct e1000_hw *hw)
61 {
62         struct e1000_phy_info *phy = &hw->phy;
63         printd("e1000_init_phy_ops_generic");
64
65         /* Initialize function pointers */
66         phy->ops.init_params = e1000_null_ops_generic;
67         phy->ops.acquire = e1000_null_ops_generic;
68         phy->ops.check_polarity = e1000_null_ops_generic;
69         phy->ops.check_reset_block = e1000_null_ops_generic;
70         phy->ops.commit = e1000_null_ops_generic;
71 #if 0
72         phy->ops.force_speed_duplex = e1000_null_ops_generic;
73 #endif
74         phy->ops.get_cfg_done = e1000_null_ops_generic;
75 #if 0
76         phy->ops.get_cable_length = e1000_null_ops_generic;
77 #endif
78         phy->ops.get_info = e1000_null_ops_generic;
79         phy->ops.read_reg = e1000_null_read_reg;
80         phy->ops.release = e1000_null_phy_generic;
81         phy->ops.reset = e1000_null_ops_generic;
82         phy->ops.set_d0_lplu_state = e1000_null_lplu_state;
83         phy->ops.set_d3_lplu_state = e1000_null_lplu_state;
84         phy->ops.write_reg = e1000_null_write_reg;
85         phy->ops.power_up = e1000_null_phy_generic;
86         phy->ops.power_down = e1000_null_phy_generic;
87 }
88
89 /**
90  *  e1000_null_read_reg - No-op function, return 0
91  *  @hw: pointer to the HW structure
92  **/
93 s32 e1000_null_read_reg(struct e1000_hw *hw __unused, uint32_t offset __unused,
94                         uint16_t *data __unused)
95 {
96         printd("e1000_null_read_reg");
97         return E1000_SUCCESS;
98 }
99
100 /**
101  *  e1000_null_phy_generic - No-op function, return void
102  *  @hw: pointer to the HW structure
103  **/
104 void e1000_null_phy_generic(struct e1000_hw *hw __unused)
105 {
106         printd("e1000_null_phy_generic");
107         return;
108 }
109
110 /**
111  *  e1000_null_lplu_state - No-op function, return 0
112  *  @hw: pointer to the HW structure
113  **/
114 s32 e1000_null_lplu_state(struct e1000_hw *hw __unused, bool active __unused)
115 {
116         printd("e1000_null_lplu_state");
117         return E1000_SUCCESS;
118 }
119
120 /**
121  *  e1000_null_write_reg - No-op function, return 0
122  *  @hw: pointer to the HW structure
123  **/
124 s32 e1000_null_write_reg(struct e1000_hw *hw __unused, uint32_t offset __unused,
125                          uint16_t data __unused)
126 {
127         printd("e1000_null_write_reg");
128         return E1000_SUCCESS;
129 }
130
131 /**
132  *  e1000_check_reset_block_generic - Check if PHY reset is blocked
133  *  @hw: pointer to the HW structure
134  *
135  *  Read the PHY management control register and check whether a PHY reset
136  *  is blocked.  If a reset is not blocked return E1000_SUCCESS, otherwise
137  *  return E1000_BLK_PHY_RESET (12).
138  **/
139 s32 e1000_check_reset_block_generic(struct e1000_hw *hw)
140 {
141         uint32_t manc;
142
143         printd("e1000_check_reset_block");
144
145         manc = E1000_READ_REG(hw, E1000_MANC);
146
147         return (manc & E1000_MANC_BLK_PHY_RST_ON_IDE) ?
148                E1000_BLK_PHY_RESET : E1000_SUCCESS;
149 }
150
151 /**
152  *  e1000_get_phy_id - Retrieve the PHY ID and revision
153  *  @hw: pointer to the HW structure
154  *
155  *  Reads the PHY registers and stores the PHY ID and possibly the PHY
156  *  revision in the hardware structure.
157  **/
158 s32 e1000_get_phy_id(struct e1000_hw *hw)
159 {
160         struct e1000_phy_info *phy = &hw->phy;
161         s32 ret_val = E1000_SUCCESS;
162         uint16_t phy_id;
163
164         printd("e1000_get_phy_id");
165
166         if (!(phy->ops.read_reg))
167                 goto out;
168
169                 ret_val = phy->ops.read_reg(hw, PHY_ID1, &phy_id);
170                 if (ret_val)
171                         goto out;
172
173                 phy->id = (uint32_t)(phy_id << 16);
174                 usec_delay(20);
175                 ret_val = phy->ops.read_reg(hw, PHY_ID2, &phy_id);
176                 if (ret_val)
177                         goto out;
178
179                 phy->id |= (uint32_t)(phy_id & PHY_REVISION_MASK);
180                 phy->revision = (uint32_t)(phy_id & ~PHY_REVISION_MASK);
181
182 out:
183         return ret_val;
184 }
185
186 /**
187  *  e1000_phy_reset_dsp_generic - Reset PHY DSP
188  *  @hw: pointer to the HW structure
189  *
190  *  Reset the digital signal processor.
191  **/
192 s32 e1000_phy_reset_dsp_generic(struct e1000_hw *hw)
193 {
194         s32 ret_val = E1000_SUCCESS;
195
196         printd("e1000_phy_reset_dsp_generic");
197
198         if (!(hw->phy.ops.write_reg))
199                 goto out;
200
201         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xC1);
202         if (ret_val)
203                 goto out;
204
205         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0);
206
207 out:
208         return ret_val;
209 }
210
211 /**
212  *  e1000_read_phy_reg_mdic - Read MDI control register
213  *  @hw: pointer to the HW structure
214  *  @offset: register offset to be read
215  *  @data: pointer to the read data
216  *
217  *  Reads the MDI control register in the PHY at offset and stores the
218  *  information read to data.
219  **/
220 s32 e1000_read_phy_reg_mdic(struct e1000_hw *hw,
221                             uint32_t offset, uint16_t *data)
222 {
223         struct e1000_phy_info *phy = &hw->phy;
224         uint32_t i, mdic = 0;
225         s32 ret_val = E1000_SUCCESS;
226
227         printd("e1000_read_phy_reg_mdic");
228
229         /*
230          * Set up Op-code, Phy Address, and register offset in the MDI
231          * Control register.  The MAC will take care of interfacing with the
232          * PHY to retrieve the desired data.
233          */
234         mdic = ((offset << E1000_MDIC_REG_SHIFT) |
235                 (phy->addr << E1000_MDIC_PHY_SHIFT) |
236                 (E1000_MDIC_OP_READ));
237
238         E1000_WRITE_REG(hw, E1000_MDIC, mdic);
239
240         /*
241          * Poll the ready bit to see if the MDI read completed
242          * Increasing the time out as testing showed failures with
243          * the lower time out
244          */
245         for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {
246                 usec_delay(50);
247                 mdic = E1000_READ_REG(hw, E1000_MDIC);
248                 if (mdic & E1000_MDIC_READY)
249                         break;
250         }
251         if (!(mdic & E1000_MDIC_READY)) {
252                 DEBUGOUT("MDI Read did not complete\n");
253                 ret_val = -E1000_ERR_PHY;
254                 goto out;
255         }
256         if (mdic & E1000_MDIC_ERROR) {
257                 DEBUGOUT("MDI Error\n");
258                 ret_val = -E1000_ERR_PHY;
259                 goto out;
260         }
261         *data = (uint16_t) mdic;
262
263 out:
264         return ret_val;
265 }
266
267 /**
268  *  e1000_write_phy_reg_mdic - Write MDI control register
269  *  @hw: pointer to the HW structure
270  *  @offset: register offset to write to
271  *  @data: data to write to register at offset
272  *
273  *  Writes data to MDI control register in the PHY at offset.
274  **/
275 s32 e1000_write_phy_reg_mdic(struct e1000_hw *hw,
276                              uint32_t offset, uint16_t data)
277 {
278         struct e1000_phy_info *phy = &hw->phy;
279         uint32_t i, mdic = 0;
280         s32 ret_val = E1000_SUCCESS;
281
282         printd("e1000_write_phy_reg_mdic");
283
284         /*
285          * Set up Op-code, Phy Address, and register offset in the MDI
286          * Control register.  The MAC will take care of interfacing with the
287          * PHY to retrieve the desired data.
288          */
289         mdic = (((uint32_t)data) |
290                 (offset << E1000_MDIC_REG_SHIFT) |
291                 (phy->addr << E1000_MDIC_PHY_SHIFT) |
292                 (E1000_MDIC_OP_WRITE));
293
294         E1000_WRITE_REG(hw, E1000_MDIC, mdic);
295
296         /*
297          * Poll the ready bit to see if the MDI read completed
298          * Increasing the time out as testing showed failures with
299          * the lower time out
300          */
301         for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {
302                 usec_delay(50);
303                 mdic = E1000_READ_REG(hw, E1000_MDIC);
304                 if (mdic & E1000_MDIC_READY)
305                         break;
306         }
307         if (!(mdic & E1000_MDIC_READY)) {
308                 DEBUGOUT("MDI Write did not complete\n");
309                 ret_val = -E1000_ERR_PHY;
310                 goto out;
311         }
312         if (mdic & E1000_MDIC_ERROR) {
313                 DEBUGOUT("MDI Error\n");
314                 ret_val = -E1000_ERR_PHY;
315                 goto out;
316         }
317
318 out:
319         return ret_val;
320 }
321
322 /**
323  *  e1000_read_phy_reg_m88 - Read m88 PHY register
324  *  @hw: pointer to the HW structure
325  *  @offset: register offset to be read
326  *  @data: pointer to the read data
327  *
328  *  Acquires semaphore, if necessary, then reads the PHY register at offset
329  *  and storing the retrieved information in data.  Release any acquired
330  *  semaphores before exiting.
331  **/
332 s32 e1000_read_phy_reg_m88(struct e1000_hw *hw,
333                            uint32_t offset, uint16_t *data)
334 {
335         s32 ret_val = E1000_SUCCESS;
336
337         printd("e1000_read_phy_reg_m88");
338
339         if (!(hw->phy.ops.acquire))
340                 goto out;
341
342         ret_val = hw->phy.ops.acquire(hw);
343         if (ret_val)
344                 goto out;
345
346         ret_val = e1000_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
347                                           data);
348
349         hw->phy.ops.release(hw);
350
351 out:
352         return ret_val;
353 }
354
355 /**
356  *  e1000_write_phy_reg_m88 - Write m88 PHY register
357  *  @hw: pointer to the HW structure
358  *  @offset: register offset to write to
359  *  @data: data to write at register offset
360  *
361  *  Acquires semaphore, if necessary, then writes the data to PHY register
362  *  at the offset.  Release any acquired semaphores before exiting.
363  **/
364 s32 e1000_write_phy_reg_m88(struct e1000_hw *hw,
365                             uint32_t offset, uint16_t data)
366 {
367         s32 ret_val = E1000_SUCCESS;
368
369         printd("e1000_write_phy_reg_m88");
370
371         if (!(hw->phy.ops.acquire))
372                 goto out;
373
374         ret_val = hw->phy.ops.acquire(hw);
375         if (ret_val)
376                 goto out;
377
378         ret_val = e1000_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
379                                            data);
380
381         hw->phy.ops.release(hw);
382
383 out:
384         return ret_val;
385 }
386
387 /**
388  *  e1000_read_phy_reg_igp - Read igp PHY register
389  *  @hw: pointer to the HW structure
390  *  @offset: register offset to be read
391  *  @data: pointer to the read data
392  *
393  *  Acquires semaphore, if necessary, then reads the PHY register at offset
394  *  and storing the retrieved information in data.  Release any acquired
395  *  semaphores before exiting.
396  **/
397 s32 e1000_read_phy_reg_igp(struct e1000_hw *hw,
398                            uint32_t offset, uint16_t *data)
399 {
400         s32 ret_val = E1000_SUCCESS;
401
402         printd("e1000_read_phy_reg_igp");
403
404         if (!(hw->phy.ops.acquire))
405                 goto out;
406
407         ret_val = hw->phy.ops.acquire(hw);
408         if (ret_val)
409                 goto out;
410
411         if (offset > MAX_PHY_MULTI_PAGE_REG) {
412                 ret_val = e1000_write_phy_reg_mdic(hw,
413                                                    IGP01E1000_PHY_PAGE_SELECT,
414                                                    (uint16_t)offset);
415                 if (ret_val) {
416                         hw->phy.ops.release(hw);
417                         goto out;
418                 }
419         }
420
421         ret_val = e1000_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
422                                           data);
423
424         hw->phy.ops.release(hw);
425
426 out:
427         return ret_val;
428 }
429
430 /**
431  *  e1000_write_phy_reg_igp - Write igp PHY register
432  *  @hw: pointer to the HW structure
433  *  @offset: register offset to write to
434  *  @data: data to write at register offset
435  *
436  *  Acquires semaphore, if necessary, then writes the data to PHY register
437  *  at the offset.  Release any acquired semaphores before exiting.
438  **/
439 s32 e1000_write_phy_reg_igp(struct e1000_hw *hw,
440                             uint32_t offset, uint16_t data)
441 {
442         s32 ret_val = E1000_SUCCESS;
443
444         printd("e1000_write_phy_reg_igp");
445
446         if (!(hw->phy.ops.acquire))
447                 goto out;
448
449         ret_val = hw->phy.ops.acquire(hw);
450         if (ret_val)
451                 goto out;
452
453         if (offset > MAX_PHY_MULTI_PAGE_REG) {
454                 ret_val = e1000_write_phy_reg_mdic(hw,
455                                                    IGP01E1000_PHY_PAGE_SELECT,
456                                                    (uint16_t)offset);
457                 if (ret_val) {
458                         hw->phy.ops.release(hw);
459                         goto out;
460                 }
461         }
462
463         ret_val = e1000_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
464                                            data);
465
466         hw->phy.ops.release(hw);
467
468 out:
469         return ret_val;
470 }
471
472 /**
473  *  e1000_read_kmrn_reg_generic - Read kumeran register
474  *  @hw: pointer to the HW structure
475  *  @offset: register offset to be read
476  *  @data: pointer to the read data
477  *
478  *  Acquires semaphore, if necessary.  Then reads the PHY register at offset
479  *  using the kumeran interface.  The information retrieved is stored in data.
480  *  Release any acquired semaphores before exiting.
481  **/
482 s32 e1000_read_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
483                                 uint16_t *data)
484 {
485         uint32_t kmrnctrlsta;
486         s32 ret_val = E1000_SUCCESS;
487
488         printd("e1000_read_kmrn_reg_generic");
489
490         if (!(hw->phy.ops.acquire))
491                 goto out;
492
493         ret_val = hw->phy.ops.acquire(hw);
494         if (ret_val)
495                 goto out;
496
497         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
498                        E1000_KMRNCTRLSTA_OFFSET) | E1000_KMRNCTRLSTA_REN;
499         E1000_WRITE_REG(hw, E1000_KMRNCTRLSTA, kmrnctrlsta);
500
501         usec_delay(2);
502
503         kmrnctrlsta = E1000_READ_REG(hw, E1000_KMRNCTRLSTA);
504         *data = (uint16_t)kmrnctrlsta;
505
506         hw->phy.ops.release(hw);
507
508 out:
509         return ret_val;
510 }
511
512 /**
513  *  e1000_write_kmrn_reg_generic - Write kumeran register
514  *  @hw: pointer to the HW structure
515  *  @offset: register offset to write to
516  *  @data: data to write at register offset
517  *
518  *  Acquires semaphore, if necessary.  Then write the data to PHY register
519  *  at the offset using the kumeran interface.  Release any acquired semaphores
520  *  before exiting.
521  **/
522 s32 e1000_write_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
523                                  uint16_t data)
524 {
525         uint32_t kmrnctrlsta;
526         s32 ret_val = E1000_SUCCESS;
527
528         printd("e1000_write_kmrn_reg_generic");
529
530         if (!(hw->phy.ops.acquire))
531                 goto out;
532
533         ret_val = hw->phy.ops.acquire(hw);
534         if (ret_val)
535                 goto out;
536
537         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
538                        E1000_KMRNCTRLSTA_OFFSET) | data;
539         E1000_WRITE_REG(hw, E1000_KMRNCTRLSTA, kmrnctrlsta);
540
541         usec_delay(2);
542         hw->phy.ops.release(hw);
543
544 out:
545         return ret_val;
546 }
547
548 /**
549  *  e1000_copper_link_setup_m88 - Setup m88 PHY's for copper link
550  *  @hw: pointer to the HW structure
551  *
552  *  Sets up MDI/MDI-X and polarity for m88 PHY's.  If necessary, transmit clock
553  *  and downshift values are set also.
554  **/
555 s32 e1000_copper_link_setup_m88(struct e1000_hw *hw)
556 {
557         struct e1000_phy_info *phy = &hw->phy;
558         s32 ret_val;
559         uint16_t phy_data;
560
561         printd("e1000_copper_link_setup_m88");
562
563         if (phy->reset_disable) {
564                 ret_val = E1000_SUCCESS;
565                 goto out;
566         }
567
568         /* Enable CRS on TX. This must be set for half-duplex operation. */
569         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
570         if (ret_val)
571                 goto out;
572
573         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
574
575         /*
576          * Options:
577          *   MDI/MDI-X = 0 (default)
578          *   0 - Auto for all speeds
579          *   1 - MDI mode
580          *   2 - MDI-X mode
581          *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
582          */
583         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
584
585         switch (phy->mdix) {
586         case 1:
587                 phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
588                 break;
589         case 2:
590                 phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
591                 break;
592         case 3:
593                 phy_data |= M88E1000_PSCR_AUTO_X_1000T;
594                 break;
595         case 0:
596         default:
597                 phy_data |= M88E1000_PSCR_AUTO_X_MODE;
598                 break;
599         }
600
601         /*
602          * Options:
603          *   disable_polarity_correction = 0 (default)
604          *       Automatic Correction for Reversed Cable Polarity
605          *   0 - Disabled
606          *   1 - Enabled
607          */
608         phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
609         if (phy->disable_polarity_correction == 1)
610                 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
611
612         ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
613         if (ret_val)
614                 goto out;
615
616         if (phy->revision < E1000_REVISION_4) {
617                 /*
618                  * Force TX_CLK in the Extended PHY Specific Control Register
619                  * to 25MHz clock.
620                  */
621                 ret_val = phy->ops.read_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
622                                              &phy_data);
623                 if (ret_val)
624                         goto out;
625
626                 phy_data |= M88E1000_EPSCR_TX_CLK_25;
627
628                 if ((phy->revision == E1000_REVISION_2) &&
629                     (phy->id == M88E1111_I_PHY_ID)) {
630                         /* 82573L PHY - set the downshift counter to 5x. */
631                         phy_data &= ~M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK;
632                         phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
633                 } else {
634                         /* Configure Master and Slave downshift values */
635                         phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
636                                      M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
637                         phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
638                                      M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
639                 }
640                 ret_val = phy->ops.write_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
641                                              phy_data);
642                 if (ret_val)
643                         goto out;
644         }
645
646         /* Commit the changes. */
647         ret_val = phy->ops.commit(hw);
648         if (ret_val) {
649                 DEBUGOUT("Error committing the PHY changes\n");
650                 goto out;
651         }
652
653 out:
654         return ret_val;
655 }
656
657 /**
658  *  e1000_copper_link_setup_igp - Setup igp PHY's for copper link
659  *  @hw: pointer to the HW structure
660  *
661  *  Sets up LPLU, MDI/MDI-X, polarity, Smartspeed and Master/Slave config for
662  *  igp PHY's.
663  **/
664 s32 e1000_copper_link_setup_igp(struct e1000_hw *hw)
665 {
666         struct e1000_phy_info *phy = &hw->phy;
667         s32 ret_val;
668         uint16_t data;
669
670         printd("e1000_copper_link_setup_igp");
671
672         if (phy->reset_disable) {
673                 ret_val = E1000_SUCCESS;
674                 goto out;
675         }
676
677         ret_val = hw->phy.ops.reset(hw);
678         if (ret_val) {
679                 DEBUGOUT("Error resetting the PHY.\n");
680                 goto out;
681         }
682
683         /*
684          * Wait 100ms for MAC to configure PHY from NVM settings, to avoid
685          * timeout issues when LFS is enabled.
686          */
687         msec_delay(100);
688
689         /*
690          * The NVM settings will configure LPLU in D3 for
691          * non-IGP1 PHYs.
692          */
693         if (phy->type == e1000_phy_igp) {
694                 /* disable lplu d3 during driver init */
695                 ret_val = hw->phy.ops.set_d3_lplu_state(hw, false);
696                 if (ret_val) {
697                         DEBUGOUT("Error Disabling LPLU D3\n");
698                         goto out;
699                 }
700         }
701
702         /* disable lplu d0 during driver init */
703         if (hw->phy.ops.set_d0_lplu_state) {
704                 ret_val = hw->phy.ops.set_d0_lplu_state(hw, false);
705                 if (ret_val) {
706                         DEBUGOUT("Error Disabling LPLU D0\n");
707                         goto out;
708                 }
709         }
710         /* Configure mdi-mdix settings */
711         ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CTRL, &data);
712         if (ret_val)
713                 goto out;
714
715         data &= ~IGP01E1000_PSCR_AUTO_MDIX;
716
717         switch (phy->mdix) {
718         case 1:
719                 data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
720                 break;
721         case 2:
722                 data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
723                 break;
724         case 0:
725         default:
726                 data |= IGP01E1000_PSCR_AUTO_MDIX;
727                 break;
728         }
729         ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CTRL, data);
730         if (ret_val)
731                 goto out;
732
733         /* set auto-master slave resolution settings */
734         if (hw->mac.autoneg) {
735                 /*
736                  * when autonegotiation advertisement is only 1000Mbps then we
737                  * should disable SmartSpeed and enable Auto MasterSlave
738                  * resolution as hardware default.
739                  */
740                 if (phy->autoneg_advertised == ADVERTISE_1000_FULL) {
741                         /* Disable SmartSpeed */
742                         ret_val = phy->ops.read_reg(hw,
743                                                      IGP01E1000_PHY_PORT_CONFIG,
744                                                      &data);
745                         if (ret_val)
746                                 goto out;
747
748                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
749                         ret_val = phy->ops.write_reg(hw,
750                                                      IGP01E1000_PHY_PORT_CONFIG,
751                                                      data);
752                         if (ret_val)
753                                 goto out;
754
755                         /* Set auto Master/Slave resolution process */
756                         ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, &data);
757                         if (ret_val)
758                                 goto out;
759
760                         data &= ~CR_1000T_MS_ENABLE;
761                         ret_val = phy->ops.write_reg(hw, PHY_1000T_CTRL, data);
762                         if (ret_val)
763                                 goto out;
764                 }
765
766                 ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, &data);
767                 if (ret_val)
768                         goto out;
769
770                 /* load defaults for future use */
771                 phy->original_ms_type = (data & CR_1000T_MS_ENABLE) ?
772                         ((data & CR_1000T_MS_VALUE) ?
773                         e1000_ms_force_master :
774                         e1000_ms_force_slave) :
775                         e1000_ms_auto;
776
777                 switch (phy->ms_type) {
778                 case e1000_ms_force_master:
779                         data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
780                         break;
781                 case e1000_ms_force_slave:
782                         data |= CR_1000T_MS_ENABLE;
783                         data &= ~(CR_1000T_MS_VALUE);
784                         break;
785                 case e1000_ms_auto:
786                         data &= ~CR_1000T_MS_ENABLE;
787                 default:
788                         break;
789                 }
790                 ret_val = phy->ops.write_reg(hw, PHY_1000T_CTRL, data);
791                 if (ret_val)
792                         goto out;
793         }
794
795 out:
796         return ret_val;
797 }
798
799 /**
800  *  e1000_copper_link_autoneg - Setup/Enable autoneg for copper link
801  *  @hw: pointer to the HW structure
802  *
803  *  Performs initial bounds checking on autoneg advertisement parameter, then
804  *  configure to advertise the full capability.  Setup the PHY to autoneg
805  *  and restart the negotiation process between the link partner.  If
806  *  autoneg_wait_to_complete, then wait for autoneg to complete before exiting.
807  **/
808 s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
809 {
810         struct e1000_phy_info *phy = &hw->phy;
811         s32 ret_val;
812         uint16_t phy_ctrl;
813
814         printd("e1000_copper_link_autoneg");
815
816         /*
817          * Perform some bounds checking on the autoneg advertisement
818          * parameter.
819          */
820         phy->autoneg_advertised &= phy->autoneg_mask;
821
822         /*
823          * If autoneg_advertised is zero, we assume it was not defaulted
824          * by the calling code so we set to advertise full capability.
825          */
826         if (phy->autoneg_advertised == 0)
827                 phy->autoneg_advertised = phy->autoneg_mask;
828
829         DEBUGOUT("Reconfiguring auto-neg advertisement params\n");
830         ret_val = e1000_phy_setup_autoneg(hw);
831         if (ret_val) {
832                 DEBUGOUT("Error Setting up Auto-Negotiation\n");
833                 goto out;
834         }
835         DEBUGOUT("Restarting Auto-Neg\n");
836
837         /*
838          * Restart auto-negotiation by setting the Auto Neg Enable bit and
839          * the Auto Neg Restart bit in the PHY control register.
840          */
841         ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_ctrl);
842         if (ret_val)
843                 goto out;
844
845         phy_ctrl |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
846         ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_ctrl);
847         if (ret_val)
848                 goto out;
849
850         /*
851          * Does the user want to wait for Auto-Neg to complete here, or
852          * check at a later time (for example, callback routine).
853          */
854         if (phy->autoneg_wait_to_complete) {
855                 ret_val = hw->mac.ops.wait_autoneg(hw);
856                 if (ret_val) {
857                         DEBUGOUT("Error while waiting for "
858                                  "autoneg to complete\n");
859                         goto out;
860                 }
861         }
862
863         hw->mac.get_link_status = true;
864
865 out:
866         return ret_val;
867 }
868
869 /**
870  *  e1000_phy_setup_autoneg - Configure PHY for auto-negotiation
871  *  @hw: pointer to the HW structure
872  *
873  *  Reads the MII auto-neg advertisement register and/or the 1000T control
874  *  register and if the PHY is already setup for auto-negotiation, then
875  *  return successful.  Otherwise, setup advertisement and flow control to
876  *  the appropriate values for the wanted auto-negotiation.
877  **/
878 s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
879 {
880         struct e1000_phy_info *phy = &hw->phy;
881         s32 ret_val;
882         uint16_t mii_autoneg_adv_reg;
883         uint16_t mii_1000t_ctrl_reg = 0;
884
885         printd("e1000_phy_setup_autoneg");
886
887         phy->autoneg_advertised &= phy->autoneg_mask;
888
889         /* Read the MII Auto-Neg Advertisement Register (Address 4). */
890         ret_val = phy->ops.read_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
891         if (ret_val)
892                 goto out;
893
894         if (phy->autoneg_mask & ADVERTISE_1000_FULL) {
895                 /* Read the MII 1000Base-T Control Register (Address 9). */
896                 ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL,
897                                             &mii_1000t_ctrl_reg);
898                 if (ret_val)
899                         goto out;
900         }
901
902         /*
903          * Need to parse both autoneg_advertised and fc and set up
904          * the appropriate PHY registers.  First we will parse for
905          * autoneg_advertised software override.  Since we can advertise
906          * a plethora of combinations, we need to check each bit
907          * individually.
908          */
909
910         /*
911          * First we clear all the 10/100 mb speed bits in the Auto-Neg
912          * Advertisement Register (Address 4) and the 1000 mb speed bits in
913          * the  1000Base-T Control Register (Address 9).
914          */
915         mii_autoneg_adv_reg &= ~(NWAY_AR_100TX_FD_CAPS |
916                                  NWAY_AR_100TX_HD_CAPS |
917                                  NWAY_AR_10T_FD_CAPS   |
918                                  NWAY_AR_10T_HD_CAPS);
919         mii_1000t_ctrl_reg &= ~(CR_1000T_HD_CAPS | CR_1000T_FD_CAPS);
920
921         DEBUGOUT1("autoneg_advertised %x\n", phy->autoneg_advertised);
922
923         /* Do we want to advertise 10 Mb Half Duplex? */
924         if (phy->autoneg_advertised & ADVERTISE_10_HALF) {
925                 DEBUGOUT("Advertise 10mb Half duplex\n");
926                 mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
927         }
928
929         /* Do we want to advertise 10 Mb Full Duplex? */
930         if (phy->autoneg_advertised & ADVERTISE_10_FULL) {
931                 DEBUGOUT("Advertise 10mb Full duplex\n");
932                 mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
933         }
934
935         /* Do we want to advertise 100 Mb Half Duplex? */
936         if (phy->autoneg_advertised & ADVERTISE_100_HALF) {
937                 DEBUGOUT("Advertise 100mb Half duplex\n");
938                 mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
939         }
940
941         /* Do we want to advertise 100 Mb Full Duplex? */
942         if (phy->autoneg_advertised & ADVERTISE_100_FULL) {
943                 DEBUGOUT("Advertise 100mb Full duplex\n");
944                 mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
945         }
946
947         /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
948         if (phy->autoneg_advertised & ADVERTISE_1000_HALF)
949                 DEBUGOUT("Advertise 1000mb Half duplex request denied!\n");
950
951         /* Do we want to advertise 1000 Mb Full Duplex? */
952         if (phy->autoneg_advertised & ADVERTISE_1000_FULL) {
953                 DEBUGOUT("Advertise 1000mb Full duplex\n");
954                 mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
955         }
956
957         /*
958          * Check for a software override of the flow control settings, and
959          * setup the PHY advertisement registers accordingly.  If
960          * auto-negotiation is enabled, then software will have to set the
961          * "PAUSE" bits to the correct value in the Auto-Negotiation
962          * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-
963          * negotiation.
964          *
965          * The possible values of the "fc" parameter are:
966          *      0:  Flow control is completely disabled
967          *      1:  Rx flow control is enabled (we can receive pause frames
968          *          but not send pause frames).
969          *      2:  Tx flow control is enabled (we can send pause frames
970          *          but we do not support receiving pause frames).
971          *      3:  Both Rx and Tx flow control (symmetric) are enabled.
972          *  other:  No software override.  The flow control configuration
973          *          in the EEPROM is used.
974          */
975         switch (hw->fc.current_mode) {
976         case e1000_fc_none:
977                 /*
978                  * Flow control (Rx & Tx) is completely disabled by a
979                  * software over-ride.
980                  */
981                 mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
982                 break;
983         case e1000_fc_rx_pause:
984                 /*
985                  * Rx Flow control is enabled, and Tx Flow control is
986                  * disabled, by a software over-ride.
987                  *
988                  * Since there really isn't a way to advertise that we are
989                  * capable of Rx Pause ONLY, we will advertise that we
990                  * support both symmetric and asymmetric Rx PAUSE.  Later
991                  * (in e1000_config_fc_after_link_up) we will disable the
992                  * hw's ability to send PAUSE frames.
993                  */
994                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
995                 break;
996         case e1000_fc_tx_pause:
997                 /*
998                  * Tx Flow control is enabled, and Rx Flow control is
999                  * disabled, by a software over-ride.
1000                  */
1001                 mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
1002                 mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
1003                 break;
1004         case e1000_fc_full:
1005                 /*
1006                  * Flow control (both Rx and Tx) is enabled by a software
1007                  * over-ride.
1008                  */
1009                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1010                 break;
1011         default:
1012                 DEBUGOUT("Flow control param set incorrectly\n");
1013                 ret_val = -E1000_ERR_CONFIG;
1014                 goto out;
1015         }
1016
1017         ret_val = phy->ops.write_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
1018         if (ret_val)
1019                 goto out;
1020
1021         DEBUGOUT1("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
1022
1023         if (phy->autoneg_mask & ADVERTISE_1000_FULL) {
1024                 ret_val = phy->ops.write_reg(hw,
1025                                               PHY_1000T_CTRL,
1026                                               mii_1000t_ctrl_reg);
1027                 if (ret_val)
1028                         goto out;
1029         }
1030
1031 out:
1032         return ret_val;
1033 }
1034
1035 /**
1036  *  e1000_setup_copper_link_generic - Configure copper link settings
1037  *  @hw: pointer to the HW structure
1038  *
1039  *  Calls the appropriate function to configure the link for auto-neg or forced
1040  *  speed and duplex.  Then we check for link, once link is established calls
1041  *  to configure collision distance and flow control are called.  If link is
1042  *  not established, we return -E1000_ERR_PHY (-2).
1043  **/
1044 s32 e1000_setup_copper_link_generic(struct e1000_hw *hw)
1045 {
1046         s32 ret_val;
1047         bool link;
1048
1049         printd("e1000_setup_copper_link_generic");
1050
1051         if (hw->mac.autoneg) {
1052                 /*
1053                  * Setup autoneg and flow control advertisement and perform
1054                  * autonegotiation.
1055                  */
1056                 ret_val = e1000_copper_link_autoneg(hw);
1057                 if (ret_val)
1058                         goto out;
1059         } else {
1060 #if 0
1061                 /*
1062                  * PHY will be set to 10H, 10F, 100H or 100F
1063                  * depending on user settings.
1064                  */
1065                 DEBUGOUT("Forcing Speed and Duplex\n");
1066                 ret_val = hw->phy.ops.force_speed_duplex(hw);
1067                 if (ret_val) {
1068                         DEBUGOUT("Error Forcing Speed and Duplex\n");
1069                         goto out;
1070                 }
1071 #endif
1072         }
1073
1074         /*
1075          * Check link status. Wait up to 100 microseconds for link to become
1076          * valid.
1077          */
1078         ret_val = e1000_phy_has_link_generic(hw,
1079                                              COPPER_LINK_UP_LIMIT,
1080                                              10,
1081                                              &link);
1082         if (ret_val)
1083                 goto out;
1084
1085         if (link) {
1086                 DEBUGOUT("Valid link established!!!\n");
1087                 e1000_config_collision_dist_generic(hw);
1088                 ret_val = e1000_config_fc_after_link_up_generic(hw);
1089         } else {
1090                 DEBUGOUT("Unable to establish link!!!\n");
1091         }
1092
1093 out:
1094         return ret_val;
1095 }
1096
1097 #if 0
1098 /**
1099  *  e1000_phy_force_speed_duplex_igp - Force speed/duplex for igp PHY
1100  *  @hw: pointer to the HW structure
1101  *
1102  *  Calls the PHY setup function to force speed and duplex.  Clears the
1103  *  auto-crossover to force MDI manually.  Waits for link and returns
1104  *  successful if link up is successful, else -E1000_ERR_PHY (-2).
1105  **/
1106 s32 e1000_phy_force_speed_duplex_igp(struct e1000_hw *hw)
1107 {
1108         struct e1000_phy_info *phy = &hw->phy;
1109         s32 ret_val;
1110         u16 phy_data;
1111         bool link;
1112
1113         DEBUGFUNC("e1000_phy_force_speed_duplex_igp");
1114
1115         ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data);
1116         if (ret_val)
1117                 goto out;
1118
1119         e1000_phy_force_speed_duplex_setup(hw, &phy_data);
1120
1121         ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_data);
1122         if (ret_val)
1123                 goto out;
1124
1125         /*
1126          * Clear Auto-Crossover to force MDI manually.  IGP requires MDI
1127          * forced whenever speed and duplex are forced.
1128          */
1129         ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1130         if (ret_val)
1131                 goto out;
1132
1133         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1134         phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1135
1136         ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1137         if (ret_val)
1138                 goto out;
1139
1140         DEBUGOUT1("IGP PSCR: %X\n", phy_data);
1141
1142         usec_delay(1);
1143
1144         if (phy->autoneg_wait_to_complete) {
1145                 DEBUGOUT("Waiting for forced speed/duplex link on IGP phy.\n");
1146
1147                 ret_val = e1000_phy_has_link_generic(hw,
1148                                                      PHY_FORCE_LIMIT,
1149                                                      100000,
1150                                                      &link);
1151                 if (ret_val)
1152                         goto out;
1153
1154                 if (!link)
1155                         DEBUGOUT("Link taking longer than expected.\n");
1156
1157                 /* Try once more */
1158                 ret_val = e1000_phy_has_link_generic(hw,
1159                                                      PHY_FORCE_LIMIT,
1160                                                      100000,
1161                                                      &link);
1162                 if (ret_val)
1163                         goto out;
1164         }
1165
1166 out:
1167         return ret_val;
1168 }
1169
1170 /**
1171  *  e1000_phy_force_speed_duplex_m88 - Force speed/duplex for m88 PHY
1172  *  @hw: pointer to the HW structure
1173  *
1174  *  Calls the PHY setup function to force speed and duplex.  Clears the
1175  *  auto-crossover to force MDI manually.  Resets the PHY to commit the
1176  *  changes.  If time expires while waiting for link up, we reset the DSP.
1177  *  After reset, TX_CLK and CRS on Tx must be set.  Return successful upon
1178  *  successful completion, else return corresponding error code.
1179  **/
1180 s32 e1000_phy_force_speed_duplex_m88(struct e1000_hw *hw)
1181 {
1182         struct e1000_phy_info *phy = &hw->phy;
1183         s32 ret_val;
1184         u16 phy_data;
1185         bool link;
1186
1187         DEBUGFUNC("e1000_phy_force_speed_duplex_m88");
1188
1189         /*
1190          * Clear Auto-Crossover to force MDI manually.  M88E1000 requires MDI
1191          * forced whenever speed and duplex are forced.
1192          */
1193         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1194         if (ret_val)
1195                 goto out;
1196
1197         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1198         ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1199         if (ret_val)
1200                 goto out;
1201
1202         DEBUGOUT1("M88E1000 PSCR: %X\n", phy_data);
1203
1204         ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data);
1205         if (ret_val)
1206                 goto out;
1207
1208         e1000_phy_force_speed_duplex_setup(hw, &phy_data);
1209
1210         ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_data);
1211         if (ret_val)
1212                 goto out;
1213
1214         /* Reset the phy to commit changes. */
1215         ret_val = hw->phy.ops.commit(hw);
1216         if (ret_val)
1217                 goto out;
1218
1219         if (phy->autoneg_wait_to_complete) {
1220                 DEBUGOUT("Waiting for forced speed/duplex link on M88 phy.\n");
1221
1222                 ret_val = e1000_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
1223                                                      100000, &link);
1224                 if (ret_val)
1225                         goto out;
1226
1227                 if (!link) {
1228                         /*
1229                          * We didn't get link.
1230                          * Reset the DSP and cross our fingers.
1231                          */
1232                         ret_val = phy->ops.write_reg(hw,
1233                                                       M88E1000_PHY_PAGE_SELECT,
1234                                                       0x001d);
1235                         if (ret_val)
1236                                 goto out;
1237                         ret_val = e1000_phy_reset_dsp_generic(hw);
1238                         if (ret_val)
1239                                 goto out;
1240                 }
1241
1242                 /* Try once more */
1243                 ret_val = e1000_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
1244                                                      100000, &link);
1245                 if (ret_val)
1246                         goto out;
1247         }
1248
1249         ret_val = phy->ops.read_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
1250         if (ret_val)
1251                 goto out;
1252
1253         /*
1254          * Resetting the phy means we need to re-force TX_CLK in the
1255          * Extended PHY Specific Control Register to 25MHz clock from
1256          * the reset value of 2.5MHz.
1257          */
1258         phy_data |= M88E1000_EPSCR_TX_CLK_25;
1259         ret_val = phy->ops.write_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1260         if (ret_val)
1261                 goto out;
1262
1263         /*
1264          * In addition, we must re-enable CRS on Tx for both half and full
1265          * duplex.
1266          */
1267         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1268         if (ret_val)
1269                 goto out;
1270
1271         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1272         ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1273
1274 out:
1275         return ret_val;
1276 }
1277
1278 /**
1279  *  e1000_phy_force_speed_duplex_ife - Force PHY speed & duplex
1280  *  @hw: pointer to the HW structure
1281  *
1282  *  Forces the speed and duplex settings of the PHY.
1283  *  This is a function pointer entry point only called by
1284  *  PHY setup routines.
1285  **/
1286 s32 e1000_phy_force_speed_duplex_ife(struct e1000_hw *hw)
1287 {
1288         struct e1000_phy_info *phy = &hw->phy;
1289         s32 ret_val;
1290         u16 data;
1291         bool link;
1292
1293         DEBUGFUNC("e1000_phy_force_speed_duplex_ife");
1294
1295         if (phy->type != e1000_phy_ife) {
1296                 ret_val = e1000_phy_force_speed_duplex_igp(hw);
1297                 goto out;
1298         }
1299
1300         ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &data);
1301         if (ret_val)
1302                 goto out;
1303
1304         e1000_phy_force_speed_duplex_setup(hw, &data);
1305
1306         ret_val = phy->ops.write_reg(hw, PHY_CONTROL, data);
1307         if (ret_val)
1308                 goto out;
1309
1310         /* Disable MDI-X support for 10/100 */
1311         ret_val = phy->ops.read_reg(hw, IFE_PHY_MDIX_CONTROL, &data);
1312         if (ret_val)
1313                 goto out;
1314
1315         data &= ~IFE_PMC_AUTO_MDIX;
1316         data &= ~IFE_PMC_FORCE_MDIX;
1317
1318         ret_val = phy->ops.write_reg(hw, IFE_PHY_MDIX_CONTROL, data);
1319         if (ret_val)
1320                 goto out;
1321
1322         DEBUGOUT1("IFE PMC: %X\n", data);
1323
1324         usec_delay(1);
1325
1326         if (phy->autoneg_wait_to_complete) {
1327                 DEBUGOUT("Waiting for forced speed/duplex link on IFE phy.\n");
1328
1329                 ret_val = e1000_phy_has_link_generic(hw,
1330                                                      PHY_FORCE_LIMIT,
1331                                                      100000,
1332                                                      &link);
1333                 if (ret_val)
1334                         goto out;
1335
1336                 if (!link)
1337                         DEBUGOUT("Link taking longer than expected.\n");
1338
1339                 /* Try once more */
1340                 ret_val = e1000_phy_has_link_generic(hw,
1341                                                      PHY_FORCE_LIMIT,
1342                                                      100000,
1343                                                      &link);
1344                 if (ret_val)
1345                         goto out;
1346         }
1347
1348 out:
1349         return ret_val;
1350 }
1351
1352 /**
1353  *  e1000_phy_force_speed_duplex_setup - Configure forced PHY speed/duplex
1354  *  @hw: pointer to the HW structure
1355  *  @phy_ctrl: pointer to current value of PHY_CONTROL
1356  *
1357  *  Forces speed and duplex on the PHY by doing the following: disable flow
1358  *  control, force speed/duplex on the MAC, disable auto speed detection,
1359  *  disable auto-negotiation, configure duplex, configure speed, configure
1360  *  the collision distance, write configuration to CTRL register.  The
1361  *  caller must write to the PHY_CONTROL register for these settings to
1362  *  take affect.
1363  **/
1364 void e1000_phy_force_speed_duplex_setup(struct e1000_hw *hw, u16 *phy_ctrl)
1365 {
1366         struct e1000_mac_info *mac = &hw->mac;
1367         u32 ctrl;
1368
1369         DEBUGFUNC("e1000_phy_force_speed_duplex_setup");
1370
1371         /* Turn off flow control when forcing speed/duplex */
1372         hw->fc.current_mode = e1000_fc_none;
1373
1374         /* Force speed/duplex on the mac */
1375         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1376         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1377         ctrl &= ~E1000_CTRL_SPD_SEL;
1378
1379         /* Disable Auto Speed Detection */
1380         ctrl &= ~E1000_CTRL_ASDE;
1381
1382         /* Disable autoneg on the phy */
1383         *phy_ctrl &= ~MII_CR_AUTO_NEG_EN;
1384
1385         /* Forcing Full or Half Duplex? */
1386         if (mac->forced_speed_duplex & E1000_ALL_HALF_DUPLEX) {
1387                 ctrl &= ~E1000_CTRL_FD;
1388                 *phy_ctrl &= ~MII_CR_FULL_DUPLEX;
1389                 DEBUGOUT("Half Duplex\n");
1390         } else {
1391                 ctrl |= E1000_CTRL_FD;
1392                 *phy_ctrl |= MII_CR_FULL_DUPLEX;
1393                 DEBUGOUT("Full Duplex\n");
1394         }
1395
1396         /* Forcing 10mb or 100mb? */
1397         if (mac->forced_speed_duplex & E1000_ALL_100_SPEED) {
1398                 ctrl |= E1000_CTRL_SPD_100;
1399                 *phy_ctrl |= MII_CR_SPEED_100;
1400                 *phy_ctrl &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
1401                 DEBUGOUT("Forcing 100mb\n");
1402         } else {
1403                 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1404                 *phy_ctrl |= MII_CR_SPEED_10;
1405                 *phy_ctrl &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
1406                 DEBUGOUT("Forcing 10mb\n");
1407         }
1408
1409         e1000_config_collision_dist_generic(hw);
1410
1411         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1412 }
1413 #endif
1414
1415 /**
1416  *  e1000_set_d3_lplu_state_generic - Sets low power link up state for D3
1417  *  @hw: pointer to the HW structure
1418  *  @active: boolean used to enable/disable lplu
1419  *
1420  *  Success returns 0, Failure returns 1
1421  *
1422  *  The low power link up (lplu) state is set to the power management level D3
1423  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
1424  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1425  *  is used during Dx states where the power conservation is most important.
1426  *  During driver activity, SmartSpeed should be enabled so performance is
1427  *  maintained.
1428  **/
1429 s32 e1000_set_d3_lplu_state_generic(struct e1000_hw *hw, bool active)
1430 {
1431         struct e1000_phy_info *phy = &hw->phy;
1432         s32 ret_val = E1000_SUCCESS;
1433         uint16_t data;
1434
1435         printd("e1000_set_d3_lplu_state_generic");
1436
1437         if (!(hw->phy.ops.read_reg))
1438                 goto out;
1439
1440         ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
1441         if (ret_val)
1442                 goto out;
1443
1444         if (!active) {
1445                 data &= ~IGP02E1000_PM_D3_LPLU;
1446                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
1447                                              data);
1448                 if (ret_val)
1449                         goto out;
1450                 /*
1451                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
1452                  * during Dx states where the power conservation is most
1453                  * important.  During driver activity we should enable
1454                  * SmartSpeed, so performance is maintained.
1455                  */
1456                 if (phy->smart_speed == e1000_smart_speed_on) {
1457                         ret_val = phy->ops.read_reg(hw,
1458                                                     IGP01E1000_PHY_PORT_CONFIG,
1459                                                     &data);
1460                         if (ret_val)
1461                                 goto out;
1462
1463                         data |= IGP01E1000_PSCFR_SMART_SPEED;
1464                         ret_val = phy->ops.write_reg(hw,
1465                                                      IGP01E1000_PHY_PORT_CONFIG,
1466                                                      data);
1467                         if (ret_val)
1468                                 goto out;
1469                 } else if (phy->smart_speed == e1000_smart_speed_off) {
1470                         ret_val = phy->ops.read_reg(hw,
1471                                                      IGP01E1000_PHY_PORT_CONFIG,
1472                                                      &data);
1473                         if (ret_val)
1474                                 goto out;
1475
1476                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1477                         ret_val = phy->ops.write_reg(hw,
1478                                                      IGP01E1000_PHY_PORT_CONFIG,
1479                                                      data);
1480                         if (ret_val)
1481                                 goto out;
1482                 }
1483         } else if ((phy->autoneg_advertised == E1000_ALL_SPEED_DUPLEX) ||
1484                    (phy->autoneg_advertised == E1000_ALL_NOT_GIG) ||
1485                    (phy->autoneg_advertised == E1000_ALL_10_SPEED)) {
1486                 data |= IGP02E1000_PM_D3_LPLU;
1487                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
1488                                               data);
1489                 if (ret_val)
1490                         goto out;
1491
1492                 /* When LPLU is enabled, we should disable SmartSpeed */
1493                 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1494                                              &data);
1495                 if (ret_val)
1496                         goto out;
1497
1498                 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1499                 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1500                                               data);
1501         }
1502
1503 out:
1504         return ret_val;
1505 }
1506
1507 /**
1508  *  e1000_check_downshift_generic - Checks whether a downshift in speed occurred
1509  *  @hw: pointer to the HW structure
1510  *
1511  *  Success returns 0, Failure returns 1
1512  *
1513  *  A downshift is detected by querying the PHY link health.
1514  **/
1515 s32 e1000_check_downshift_generic(struct e1000_hw *hw)
1516 {
1517         struct e1000_phy_info *phy = &hw->phy;
1518         s32 ret_val;
1519         uint16_t phy_data, offset, mask;
1520
1521         printd("e1000_check_downshift_generic");
1522
1523         switch (phy->type) {
1524         case e1000_phy_m88:
1525         case e1000_phy_gg82563:
1526                 offset  = M88E1000_PHY_SPEC_STATUS;
1527                 mask    = M88E1000_PSSR_DOWNSHIFT;
1528                 break;
1529         case e1000_phy_igp_2:
1530         case e1000_phy_igp:
1531         case e1000_phy_igp_3:
1532                 offset  = IGP01E1000_PHY_LINK_HEALTH;
1533                 mask    = IGP01E1000_PLHR_SS_DOWNGRADE;
1534                 break;
1535         default:
1536                 /* speed downshift not supported */
1537                 phy->speed_downgraded = false;
1538                 ret_val = E1000_SUCCESS;
1539                 goto out;
1540         }
1541
1542         ret_val = phy->ops.read_reg(hw, offset, &phy_data);
1543
1544         if (!ret_val)
1545                 phy->speed_downgraded = (phy_data & mask) ? true : false;
1546
1547 out:
1548         return ret_val;
1549 }
1550
1551 /**
1552  *  e1000_check_polarity_m88 - Checks the polarity.
1553  *  @hw: pointer to the HW structure
1554  *
1555  *  Success returns 0, Failure returns -E1000_ERR_PHY (-2)
1556  *
1557  *  Polarity is determined based on the PHY specific status register.
1558  **/
1559 s32 e1000_check_polarity_m88(struct e1000_hw *hw)
1560 {
1561         struct e1000_phy_info *phy = &hw->phy;
1562         s32 ret_val;
1563         uint16_t data;
1564
1565         printd("e1000_check_polarity_m88");
1566
1567         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &data);
1568
1569         if (!ret_val)
1570                 phy->cable_polarity = (data & M88E1000_PSSR_REV_POLARITY)
1571                                       ? e1000_rev_polarity_reversed
1572                                       : e1000_rev_polarity_normal;
1573
1574         return ret_val;
1575 }
1576
1577 /**
1578  *  e1000_check_polarity_igp - Checks the polarity.
1579  *  @hw: pointer to the HW structure
1580  *
1581  *  Success returns 0, Failure returns -E1000_ERR_PHY (-2)
1582  *
1583  *  Polarity is determined based on the PHY port status register, and the
1584  *  current speed (since there is no polarity at 100Mbps).
1585  **/
1586 s32 e1000_check_polarity_igp(struct e1000_hw *hw)
1587 {
1588         struct e1000_phy_info *phy = &hw->phy;
1589         s32 ret_val;
1590         uint16_t data, offset, mask;
1591
1592         printd("e1000_check_polarity_igp");
1593
1594         /*
1595          * Polarity is determined based on the speed of
1596          * our connection.
1597          */
1598         ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data);
1599         if (ret_val)
1600                 goto out;
1601
1602         if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
1603             IGP01E1000_PSSR_SPEED_1000MBPS) {
1604                 offset  = IGP01E1000_PHY_PCS_INIT_REG;
1605                 mask    = IGP01E1000_PHY_POLARITY_MASK;
1606         } else {
1607                 /*
1608                  * This really only applies to 10Mbps since
1609                  * there is no polarity for 100Mbps (always 0).
1610                  */
1611                 offset  = IGP01E1000_PHY_PORT_STATUS;
1612                 mask    = IGP01E1000_PSSR_POLARITY_REVERSED;
1613         }
1614
1615         ret_val = phy->ops.read_reg(hw, offset, &data);
1616
1617         if (!ret_val)
1618                 phy->cable_polarity = (data & mask)
1619                                       ? e1000_rev_polarity_reversed
1620                                       : e1000_rev_polarity_normal;
1621
1622 out:
1623         return ret_val;
1624 }
1625
1626 /**
1627  *  e1000_check_polarity_ife - Check cable polarity for IFE PHY
1628  *  @hw: pointer to the HW structure
1629  *
1630  *  Polarity is determined on the polarity reversal feature being enabled.
1631  **/
1632 s32 e1000_check_polarity_ife(struct e1000_hw *hw)
1633 {
1634         struct e1000_phy_info *phy = &hw->phy;
1635         s32 ret_val;
1636         uint16_t phy_data, offset, mask;
1637
1638         printd("e1000_check_polarity_ife");
1639
1640         /*
1641          * Polarity is determined based on the reversal feature being enabled.
1642          */
1643         if (phy->polarity_correction) {
1644                 offset = IFE_PHY_EXTENDED_STATUS_CONTROL;
1645                 mask = IFE_PESC_POLARITY_REVERSED;
1646         } else {
1647                 offset = IFE_PHY_SPECIAL_CONTROL;
1648                 mask = IFE_PSC_FORCE_POLARITY;
1649         }
1650
1651         ret_val = phy->ops.read_reg(hw, offset, &phy_data);
1652
1653         if (!ret_val)
1654                 phy->cable_polarity = (phy_data & mask)
1655                                        ? e1000_rev_polarity_reversed
1656                                        : e1000_rev_polarity_normal;
1657
1658         return ret_val;
1659 }
1660
1661 /**
1662  *  e1000_wait_autoneg_generic - Wait for auto-neg completion
1663  *  @hw: pointer to the HW structure
1664  *
1665  *  Waits for auto-negotiation to complete or for the auto-negotiation time
1666  *  limit to expire, which ever happens first.
1667  **/
1668 s32 e1000_wait_autoneg_generic(struct e1000_hw *hw)
1669 {
1670         s32 ret_val = E1000_SUCCESS;
1671         uint16_t i, phy_status;
1672
1673         printd("e1000_wait_autoneg_generic");
1674
1675         if (!(hw->phy.ops.read_reg))
1676                 return E1000_SUCCESS;
1677
1678         /* Break after autoneg completes or PHY_AUTO_NEG_LIMIT expires. */
1679         for (i = PHY_AUTO_NEG_LIMIT; i > 0; i--) {
1680                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
1681                 if (ret_val)
1682                         break;
1683                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
1684                 if (ret_val)
1685                         break;
1686                 if (phy_status & MII_SR_AUTONEG_COMPLETE)
1687                         break;
1688                 msec_delay(100);
1689         }
1690
1691         /*
1692          * PHY_AUTO_NEG_TIME expiration doesn't guarantee auto-negotiation
1693          * has completed.
1694          */
1695         return ret_val;
1696 }
1697
1698 /**
1699  *  e1000_phy_has_link_generic - Polls PHY for link
1700  *  @hw: pointer to the HW structure
1701  *  @iterations: number of times to poll for link
1702  *  @usec_interval: delay between polling attempts
1703  *  @success: pointer to whether polling was successful or not
1704  *
1705  *  Polls the PHY status register for link, 'iterations' number of times.
1706  **/
1707 s32 e1000_phy_has_link_generic(struct e1000_hw *hw, uint32_t iterations,
1708                                uint32_t usec_interval, bool *success)
1709 {
1710         s32 ret_val = E1000_SUCCESS;
1711         uint16_t i, phy_status;
1712
1713         printd("e1000_phy_has_link_generic");
1714
1715         if (!(hw->phy.ops.read_reg))
1716                 return E1000_SUCCESS;
1717
1718         for (i = 0; i < iterations; i++) {
1719                 /*
1720                  * Some PHYs require the PHY_STATUS register to be read
1721                  * twice due to the link bit being sticky.  No harm doing
1722                  * it across the board.
1723                  */
1724                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
1725                 if (ret_val) {
1726                         /*
1727                          * If the first read fails, another entity may have
1728                          * ownership of the resources, wait and try again to
1729                          * see if they have relinquished the resources yet.
1730                          */
1731                         usec_delay(usec_interval);
1732                 }
1733                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
1734                 if (ret_val)
1735                         break;
1736                 if (phy_status & MII_SR_LINK_STATUS)
1737                         break;
1738                 if (usec_interval >= 1000)
1739                         msec_delay_irq(usec_interval/1000);
1740                 else
1741                         usec_delay(usec_interval);
1742         }
1743
1744         *success = (i < iterations) ? true : false;
1745
1746         return ret_val;
1747 }
1748
1749 #if 0
1750 /**
1751  *  e1000_get_cable_length_m88 - Determine cable length for m88 PHY
1752  *  @hw: pointer to the HW structure
1753  *
1754  *  Reads the PHY specific status register to retrieve the cable length
1755  *  information.  The cable length is determined by averaging the minimum and
1756  *  maximum values to get the "average" cable length.  The m88 PHY has four
1757  *  possible cable length values, which are:
1758  *      Register Value          Cable Length
1759  *      0                       < 50 meters
1760  *      1                       50 - 80 meters
1761  *      2                       80 - 110 meters
1762  *      3                       110 - 140 meters
1763  *      4                       > 140 meters
1764  **/
1765 s32 e1000_get_cable_length_m88(struct e1000_hw *hw)
1766 {
1767         struct e1000_phy_info *phy = &hw->phy;
1768         s32 ret_val;
1769         u16 phy_data, index;
1770
1771         DEBUGFUNC("e1000_get_cable_length_m88");
1772
1773         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
1774         if (ret_val)
1775                 goto out;
1776
1777         index = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
1778                 M88E1000_PSSR_CABLE_LENGTH_SHIFT;
1779         if (index >= M88E1000_CABLE_LENGTH_TABLE_SIZE + 1) {
1780                 ret_val = E1000_ERR_PHY;
1781                 goto out;
1782         }
1783
1784         phy->min_cable_length = e1000_m88_cable_length_table[index];
1785         phy->max_cable_length = e1000_m88_cable_length_table[index+1];
1786
1787         phy->cable_length = (phy->min_cable_length + phy->max_cable_length) / 2;
1788
1789 out:
1790         return ret_val;
1791 }
1792
1793 /**
1794  *  e1000_get_cable_length_igp_2 - Determine cable length for igp2 PHY
1795  *  @hw: pointer to the HW structure
1796  *
1797  *  The automatic gain control (agc) normalizes the amplitude of the
1798  *  received signal, adjusting for the attenuation produced by the
1799  *  cable.  By reading the AGC registers, which represent the
1800  *  combination of coarse and fine gain value, the value can be put
1801  *  into a lookup table to obtain the approximate cable length
1802  *  for each channel.
1803  **/
1804 s32 e1000_get_cable_length_igp_2(struct e1000_hw *hw)
1805 {
1806         struct e1000_phy_info *phy = &hw->phy;
1807         s32 ret_val = E1000_SUCCESS;
1808         u16 phy_data, i, agc_value = 0;
1809         u16 cur_agc_index, max_agc_index = 0;
1810         u16 min_agc_index = IGP02E1000_CABLE_LENGTH_TABLE_SIZE - 1;
1811         u16 agc_reg_array[IGP02E1000_PHY_CHANNEL_NUM] =
1812                                                          {IGP02E1000_PHY_AGC_A,
1813                                                           IGP02E1000_PHY_AGC_B,
1814                                                           IGP02E1000_PHY_AGC_C,
1815                                                           IGP02E1000_PHY_AGC_D};
1816
1817         DEBUGFUNC("e1000_get_cable_length_igp_2");
1818
1819         /* Read the AGC registers for all channels */
1820         for (i = 0; i < IGP02E1000_PHY_CHANNEL_NUM; i++) {
1821                 ret_val = phy->ops.read_reg(hw, agc_reg_array[i], &phy_data);
1822                 if (ret_val)
1823                         goto out;
1824
1825                 /*
1826                  * Getting bits 15:9, which represent the combination of
1827                  * coarse and fine gain values.  The result is a number
1828                  * that can be put into the lookup table to obtain the
1829                  * approximate cable length.
1830                  */
1831                 cur_agc_index = (phy_data >> IGP02E1000_AGC_LENGTH_SHIFT) &
1832                                 IGP02E1000_AGC_LENGTH_MASK;
1833
1834                 /* Array index bound check. */
1835                 if ((cur_agc_index >= IGP02E1000_CABLE_LENGTH_TABLE_SIZE) ||
1836                     (cur_agc_index == 0)) {
1837                         ret_val = -E1000_ERR_PHY;
1838                         goto out;
1839                 }
1840
1841                 /* Remove min & max AGC values from calculation. */
1842                 if (e1000_igp_2_cable_length_table[min_agc_index] >
1843                     e1000_igp_2_cable_length_table[cur_agc_index])
1844                         min_agc_index = cur_agc_index;
1845                 if (e1000_igp_2_cable_length_table[max_agc_index] <
1846                     e1000_igp_2_cable_length_table[cur_agc_index])
1847                         max_agc_index = cur_agc_index;
1848
1849                 agc_value += e1000_igp_2_cable_length_table[cur_agc_index];
1850         }
1851
1852         agc_value -= (e1000_igp_2_cable_length_table[min_agc_index] +
1853                       e1000_igp_2_cable_length_table[max_agc_index]);
1854         agc_value /= (IGP02E1000_PHY_CHANNEL_NUM - 2);
1855
1856         /* Calculate cable length with the error range of +/- 10 meters. */
1857         phy->min_cable_length = ((agc_value - IGP02E1000_AGC_RANGE) > 0) ?
1858                                  (agc_value - IGP02E1000_AGC_RANGE) : 0;
1859         phy->max_cable_length = agc_value + IGP02E1000_AGC_RANGE;
1860
1861         phy->cable_length = (phy->min_cable_length + phy->max_cable_length) / 2;
1862
1863 out:
1864         return ret_val;
1865 }
1866 #endif
1867
1868 /**
1869  *  e1000_get_phy_info_m88 - Retrieve PHY information
1870  *  @hw: pointer to the HW structure
1871  *
1872  *  Valid for only copper links.  Read the PHY status register (sticky read)
1873  *  to verify that link is up.  Read the PHY special control register to
1874  *  determine the polarity and 10base-T extended distance.  Read the PHY
1875  *  special status register to determine MDI/MDIx and current speed.  If
1876  *  speed is 1000, then determine cable length, local and remote receiver.
1877  **/
1878 s32 e1000_get_phy_info_m88(struct e1000_hw *hw)
1879 {
1880         struct e1000_phy_info *phy = &hw->phy;
1881         s32  ret_val;
1882         uint16_t phy_data;
1883         bool link;
1884
1885         printd("e1000_get_phy_info_m88");
1886
1887         if (hw->phy.media_type != e1000_media_type_copper) {
1888                 DEBUGOUT("Phy info is only valid for copper media\n");
1889                 ret_val = -E1000_ERR_CONFIG;
1890                 goto out;
1891         }
1892
1893         ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
1894         if (ret_val)
1895                 goto out;
1896
1897         if (!link) {
1898                 DEBUGOUT("Phy info is only valid if link is up\n");
1899                 ret_val = -E1000_ERR_CONFIG;
1900                 goto out;
1901         }
1902
1903         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1904         if (ret_val)
1905                 goto out;
1906
1907         phy->polarity_correction = (phy_data & M88E1000_PSCR_POLARITY_REVERSAL)
1908                                    ? true : false;
1909
1910         ret_val = e1000_check_polarity_m88(hw);
1911         if (ret_val)
1912                 goto out;
1913
1914         ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
1915         if (ret_val)
1916                 goto out;
1917
1918         phy->is_mdix = (phy_data & M88E1000_PSSR_MDIX) ? true : false;
1919
1920         if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
1921 #if 0
1922                 ret_val = hw->phy.ops.get_cable_length(hw);
1923 #endif
1924                 ret_val = -E1000_ERR_CONFIG;
1925                 if (ret_val)
1926                         goto out;
1927
1928                 ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &phy_data);
1929                 if (ret_val)
1930                         goto out;
1931
1932                 phy->local_rx = (phy_data & SR_1000T_LOCAL_RX_STATUS)
1933                                 ? e1000_1000t_rx_status_ok
1934                                 : e1000_1000t_rx_status_not_ok;
1935
1936                 phy->remote_rx = (phy_data & SR_1000T_REMOTE_RX_STATUS)
1937                                  ? e1000_1000t_rx_status_ok
1938                                  : e1000_1000t_rx_status_not_ok;
1939         } else {
1940                 /* Set values to "undefined" */
1941                 phy->cable_length = E1000_CABLE_LENGTH_UNDEFINED;
1942                 phy->local_rx = e1000_1000t_rx_status_undefined;
1943                 phy->remote_rx = e1000_1000t_rx_status_undefined;
1944         }
1945
1946 out:
1947         return ret_val;
1948 }
1949
1950 /**
1951  *  e1000_get_phy_info_igp - Retrieve igp PHY information
1952  *  @hw: pointer to the HW structure
1953  *
1954  *  Read PHY status to determine if link is up.  If link is up, then
1955  *  set/determine 10base-T extended distance and polarity correction.  Read
1956  *  PHY port status to determine MDI/MDIx and speed.  Based on the speed,
1957  *  determine on the cable length, local and remote receiver.
1958  **/
1959 s32 e1000_get_phy_info_igp(struct e1000_hw *hw)
1960 {
1961         struct e1000_phy_info *phy = &hw->phy;
1962         s32 ret_val;
1963         uint16_t data;
1964         bool link;
1965
1966         printd("e1000_get_phy_info_igp");
1967
1968         ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
1969         if (ret_val)
1970                 goto out;
1971
1972         if (!link) {
1973                 DEBUGOUT("Phy info is only valid if link is up\n");
1974                 ret_val = -E1000_ERR_CONFIG;
1975                 goto out;
1976         }
1977
1978         phy->polarity_correction = true;
1979
1980         ret_val = e1000_check_polarity_igp(hw);
1981         if (ret_val)
1982                 goto out;
1983
1984         ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data);
1985         if (ret_val)
1986                 goto out;
1987
1988         phy->is_mdix = (data & IGP01E1000_PSSR_MDIX) ? true : false;
1989
1990 #if 0
1991         if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
1992             IGP01E1000_PSSR_SPEED_1000MBPS) {
1993                 ret_val = hw->phy.ops.get_cable_length(hw);
1994                 if (ret_val)
1995                         goto out;
1996
1997                 ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &data);
1998                 if (ret_val)
1999                         goto out;
2000
2001                 phy->local_rx = (data & SR_1000T_LOCAL_RX_STATUS)
2002                                 ? e1000_1000t_rx_status_ok
2003                                 : e1000_1000t_rx_status_not_ok;
2004
2005                 phy->remote_rx = (data & SR_1000T_REMOTE_RX_STATUS)
2006                                  ? e1000_1000t_rx_status_ok
2007                                  : e1000_1000t_rx_status_not_ok;
2008         } else {
2009 #endif
2010                 phy->cable_length = E1000_CABLE_LENGTH_UNDEFINED;
2011                 phy->local_rx = e1000_1000t_rx_status_undefined;
2012                 phy->remote_rx = e1000_1000t_rx_status_undefined;
2013 #if 0
2014         }
2015 #endif
2016
2017 out:
2018         return ret_val;
2019 }
2020
2021 /**
2022  *  e1000_phy_sw_reset_generic - PHY software reset
2023  *  @hw: pointer to the HW structure
2024  *
2025  *  Does a software reset of the PHY by reading the PHY control register and
2026  *  setting/write the control register reset bit to the PHY.
2027  **/
2028 s32 e1000_phy_sw_reset_generic(struct e1000_hw *hw)
2029 {
2030         s32 ret_val = E1000_SUCCESS;
2031         uint16_t phy_ctrl;
2032
2033         printd("e1000_phy_sw_reset_generic");
2034
2035         if (!(hw->phy.ops.read_reg))
2036                 goto out;
2037
2038         ret_val = hw->phy.ops.read_reg(hw, PHY_CONTROL, &phy_ctrl);
2039         if (ret_val)
2040                 goto out;
2041
2042         phy_ctrl |= MII_CR_RESET;
2043         ret_val = hw->phy.ops.write_reg(hw, PHY_CONTROL, phy_ctrl);
2044         if (ret_val)
2045                 goto out;
2046
2047         usec_delay(1);
2048
2049 out:
2050         return ret_val;
2051 }
2052
2053 /**
2054  *  e1000_phy_hw_reset_generic - PHY hardware reset
2055  *  @hw: pointer to the HW structure
2056  *
2057  *  Verify the reset block is not blocking us from resetting.  Acquire
2058  *  semaphore (if necessary) and read/set/write the device control reset
2059  *  bit in the PHY.  Wait the appropriate delay time for the device to
2060  *  reset and release the semaphore (if necessary).
2061  **/
2062 s32 e1000_phy_hw_reset_generic(struct e1000_hw *hw)
2063 {
2064         struct e1000_phy_info *phy = &hw->phy;
2065         s32 ret_val = E1000_SUCCESS;
2066         uint32_t ctrl;
2067
2068         printd("e1000_phy_hw_reset_generic");
2069
2070         ret_val = phy->ops.check_reset_block(hw);
2071         if (ret_val) {
2072                 ret_val = E1000_SUCCESS;
2073                 goto out;
2074         }
2075
2076         ret_val = phy->ops.acquire(hw);
2077         if (ret_val)
2078                 goto out;
2079
2080         ctrl = E1000_READ_REG(hw, E1000_CTRL);
2081         E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_PHY_RST);
2082         E1000_WRITE_FLUSH(hw);
2083
2084         usec_delay(phy->reset_delay_us);
2085
2086         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
2087         E1000_WRITE_FLUSH(hw);
2088
2089         usec_delay(150);
2090
2091         phy->ops.release(hw);
2092
2093         ret_val = phy->ops.get_cfg_done(hw);
2094
2095 out:
2096         return ret_val;
2097 }
2098
2099 /**
2100  *  e1000_get_cfg_done_generic - Generic configuration done
2101  *  @hw: pointer to the HW structure
2102  *
2103  *  Generic function to wait 10 milli-seconds for configuration to complete
2104  *  and return success.
2105  **/
2106 s32 e1000_get_cfg_done_generic(struct e1000_hw *hw __unused)
2107 {
2108         printd("e1000_get_cfg_done_generic");
2109
2110         msec_delay_irq(10);
2111
2112         return E1000_SUCCESS;
2113 }
2114
2115 /**
2116  *  e1000_phy_init_script_igp3 - Inits the IGP3 PHY
2117  *  @hw: pointer to the HW structure
2118  *
2119  *  Initializes a Intel Gigabit PHY3 when an EEPROM is not present.
2120  **/
2121 s32 e1000_phy_init_script_igp3(struct e1000_hw *hw)
2122 {
2123         DEBUGOUT("Running IGP 3 PHY init script\n");
2124
2125         /* PHY init IGP 3 */
2126         /* Enable rise/fall, 10-mode work in class-A */
2127         hw->phy.ops.write_reg(hw, 0x2F5B, 0x9018);
2128         /* Remove all caps from Replica path filter */
2129         hw->phy.ops.write_reg(hw, 0x2F52, 0x0000);
2130         /* Bias trimming for ADC, AFE and Driver (Default) */
2131         hw->phy.ops.write_reg(hw, 0x2FB1, 0x8B24);
2132         /* Increase Hybrid poly bias */
2133         hw->phy.ops.write_reg(hw, 0x2FB2, 0xF8F0);
2134         /* Add 4% to Tx amplitude in Gig mode */
2135         hw->phy.ops.write_reg(hw, 0x2010, 0x10B0);
2136         /* Disable trimming (TTT) */
2137         hw->phy.ops.write_reg(hw, 0x2011, 0x0000);
2138         /* Poly DC correction to 94.6% + 2% for all channels */
2139         hw->phy.ops.write_reg(hw, 0x20DD, 0x249A);
2140         /* ABS DC correction to 95.9% */
2141         hw->phy.ops.write_reg(hw, 0x20DE, 0x00D3);
2142         /* BG temp curve trim */
2143         hw->phy.ops.write_reg(hw, 0x28B4, 0x04CE);
2144         /* Increasing ADC OPAMP stage 1 currents to max */
2145         hw->phy.ops.write_reg(hw, 0x2F70, 0x29E4);
2146         /* Force 1000 ( required for enabling PHY regs configuration) */
2147         hw->phy.ops.write_reg(hw, 0x0000, 0x0140);
2148         /* Set upd_freq to 6 */
2149         hw->phy.ops.write_reg(hw, 0x1F30, 0x1606);
2150         /* Disable NPDFE */
2151         hw->phy.ops.write_reg(hw, 0x1F31, 0xB814);
2152         /* Disable adaptive fixed FFE (Default) */
2153         hw->phy.ops.write_reg(hw, 0x1F35, 0x002A);
2154         /* Enable FFE hysteresis */
2155         hw->phy.ops.write_reg(hw, 0x1F3E, 0x0067);
2156         /* Fixed FFE for short cable lengths */
2157         hw->phy.ops.write_reg(hw, 0x1F54, 0x0065);
2158         /* Fixed FFE for medium cable lengths */
2159         hw->phy.ops.write_reg(hw, 0x1F55, 0x002A);
2160         /* Fixed FFE for long cable lengths */
2161         hw->phy.ops.write_reg(hw, 0x1F56, 0x002A);
2162         /* Enable Adaptive Clip Threshold */
2163         hw->phy.ops.write_reg(hw, 0x1F72, 0x3FB0);
2164         /* AHT reset limit to 1 */
2165         hw->phy.ops.write_reg(hw, 0x1F76, 0xC0FF);
2166         /* Set AHT master delay to 127 msec */
2167         hw->phy.ops.write_reg(hw, 0x1F77, 0x1DEC);
2168         /* Set scan bits for AHT */
2169         hw->phy.ops.write_reg(hw, 0x1F78, 0xF9EF);
2170         /* Set AHT Preset bits */
2171         hw->phy.ops.write_reg(hw, 0x1F79, 0x0210);
2172         /* Change integ_factor of channel A to 3 */
2173         hw->phy.ops.write_reg(hw, 0x1895, 0x0003);
2174         /* Change prop_factor of channels BCD to 8 */
2175         hw->phy.ops.write_reg(hw, 0x1796, 0x0008);
2176         /* Change cg_icount + enable integbp for channels BCD */
2177         hw->phy.ops.write_reg(hw, 0x1798, 0xD008);
2178         /*
2179          * Change cg_icount + enable integbp + change prop_factor_master
2180          * to 8 for channel A
2181          */
2182         hw->phy.ops.write_reg(hw, 0x1898, 0xD918);
2183         /* Disable AHT in Slave mode on channel A */
2184         hw->phy.ops.write_reg(hw, 0x187A, 0x0800);
2185         /*
2186          * Enable LPLU and disable AN to 1000 in non-D0a states,
2187          * Enable SPD+B2B
2188          */
2189         hw->phy.ops.write_reg(hw, 0x0019, 0x008D);
2190         /* Enable restart AN on an1000_dis change */
2191         hw->phy.ops.write_reg(hw, 0x001B, 0x2080);
2192         /* Enable wh_fifo read clock in 10/100 modes */
2193         hw->phy.ops.write_reg(hw, 0x0014, 0x0045);
2194         /* Restart AN, Speed selection is 1000 */
2195         hw->phy.ops.write_reg(hw, 0x0000, 0x1340);
2196
2197         return E1000_SUCCESS;
2198 }
2199
2200 /**
2201  *  e1000_get_phy_type_from_id - Get PHY type from id
2202  *  @phy_id: phy_id read from the phy
2203  *
2204  *  Returns the phy type from the id.
2205  **/
2206 enum e1000_phy_type e1000_get_phy_type_from_id(uint32_t phy_id)
2207 {
2208         enum e1000_phy_type phy_type = e1000_phy_unknown;
2209
2210         switch (phy_id) {
2211         case M88E1000_I_PHY_ID:
2212         case M88E1000_E_PHY_ID:
2213         case M88E1111_I_PHY_ID:
2214         case M88E1011_I_PHY_ID:
2215                 phy_type = e1000_phy_m88;
2216                 break;
2217         case IGP01E1000_I_PHY_ID: /* IGP 1 & 2 share this */
2218                 phy_type = e1000_phy_igp_2;
2219                 break;
2220         case GG82563_E_PHY_ID:
2221                 phy_type = e1000_phy_gg82563;
2222                 break;
2223         case IGP03E1000_E_PHY_ID:
2224                 phy_type = e1000_phy_igp_3;
2225                 break;
2226         case IFE_E_PHY_ID:
2227         case IFE_PLUS_E_PHY_ID:
2228         case IFE_C_E_PHY_ID:
2229                 phy_type = e1000_phy_ife;
2230                 break;
2231         default:
2232                 phy_type = e1000_phy_unknown;
2233                 break;
2234         }
2235         return phy_type;
2236 }
2237
2238 /**
2239  *  e1000_determine_phy_address - Determines PHY address.
2240  *  @hw: pointer to the HW structure
2241  *
2242  *  This uses a trial and error method to loop through possible PHY
2243  *  addresses. It tests each by reading the PHY ID registers and
2244  *  checking for a match.
2245  **/
2246 s32 e1000_determine_phy_address(struct e1000_hw *hw)
2247 {
2248         s32 ret_val = -E1000_ERR_PHY_TYPE;
2249         uint32_t phy_addr = 0;
2250         uint32_t i;
2251         enum e1000_phy_type phy_type = e1000_phy_unknown;
2252
2253         hw->phy.id = phy_type;
2254
2255         for (phy_addr = 0; phy_addr < E1000_MAX_PHY_ADDR; phy_addr++) {
2256                 hw->phy.addr = phy_addr;
2257                 i = 0;
2258
2259                 do {
2260                         e1000_get_phy_id(hw);
2261                         phy_type = e1000_get_phy_type_from_id(hw->phy.id);
2262
2263                         /*
2264                          * If phy_type is valid, break - we found our
2265                          * PHY address
2266                          */
2267                         if (phy_type  != e1000_phy_unknown) {
2268                                 ret_val = E1000_SUCCESS;
2269                                 goto out;
2270                         }
2271                         msec_delay(1);
2272                         i++;
2273                 } while (i < 10);
2274         }
2275
2276 out:
2277         return ret_val;
2278 }
2279
2280 /**
2281  * e1000_power_up_phy_copper - Restore copper link in case of PHY power down
2282  * @hw: pointer to the HW structure
2283  *
2284  * In the case of a PHY power down to save power, or to turn off link during a
2285  * driver unload, or wake on lan is not enabled, restore the link to previous
2286  * settings.
2287  **/
2288 void e1000_power_up_phy_copper(struct e1000_hw *hw)
2289 {
2290         uint16_t mii_reg = 0;
2291
2292         /* The PHY will retain its settings across a power down/up cycle */
2293         hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
2294         mii_reg &= ~MII_CR_POWER_DOWN;
2295         hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);
2296 }
2297
2298 /**
2299  * e1000_power_down_phy_copper - Restore copper link in case of PHY power down
2300  * @hw: pointer to the HW structure
2301  *
2302  * In the case of a PHY power down to save power, or to turn off link during a
2303  * driver unload, or wake on lan is not enabled, restore the link to previous
2304  * settings.
2305  **/
2306 void e1000_power_down_phy_copper(struct e1000_hw *hw)
2307 {
2308         uint16_t mii_reg = 0;
2309
2310         /* The PHY will retain its settings across a power down/up cycle */
2311         hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
2312         mii_reg |= MII_CR_POWER_DOWN;
2313         hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);
2314         msec_delay(1);
2315 }