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