Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6
[linux-2.6.git] / drivers / net / sungem_phy.c
1 /*
2  * PHY drivers for the sungem ethernet driver.
3  *
4  * This file could be shared with other drivers.
5  *
6  * (c) 2002-2007, Benjamin Herrenscmidt (benh@kernel.crashing.org)
7  *
8  * TODO:
9  *  - Add support for PHYs that provide an IRQ line
10  *  - Eventually moved the entire polling state machine in
11  *    there (out of the eth driver), so that it can easily be
12  *    skipped on PHYs that implement it in hardware.
13  *  - On LXT971 & BCM5201, Apple uses some chip specific regs
14  *    to read the link status. Figure out why and if it makes
15  *    sense to do the same (magic aneg ?)
16  *  - Apple has some additional power management code for some
17  *    Broadcom PHYs that they "hide" from the OpenSource version
18  *    of darwin, still need to reverse engineer that
19  */
20
21
22 #include <linux/module.h>
23
24 #include <linux/kernel.h>
25 #include <linux/types.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/mii.h>
29 #include <linux/ethtool.h>
30 #include <linux/delay.h>
31
32 #ifdef CONFIG_PPC_PMAC
33 #include <asm/prom.h>
34 #endif
35
36 #include "sungem_phy.h"
37
38 /* Link modes of the BCM5400 PHY */
39 static const int phy_BCM5400_link_table[8][3] = {
40         { 0, 0, 0 },    /* No link */
41         { 0, 0, 0 },    /* 10BT Half Duplex */
42         { 1, 0, 0 },    /* 10BT Full Duplex */
43         { 0, 1, 0 },    /* 100BT Half Duplex */
44         { 0, 1, 0 },    /* 100BT Half Duplex */
45         { 1, 1, 0 },    /* 100BT Full Duplex*/
46         { 1, 0, 1 },    /* 1000BT */
47         { 1, 0, 1 },    /* 1000BT */
48 };
49
50 static inline int __phy_read(struct mii_phy* phy, int id, int reg)
51 {
52         return phy->mdio_read(phy->dev, id, reg);
53 }
54
55 static inline void __phy_write(struct mii_phy* phy, int id, int reg, int val)
56 {
57         phy->mdio_write(phy->dev, id, reg, val);
58 }
59
60 static inline int phy_read(struct mii_phy* phy, int reg)
61 {
62         return phy->mdio_read(phy->dev, phy->mii_id, reg);
63 }
64
65 static inline void phy_write(struct mii_phy* phy, int reg, int val)
66 {
67         phy->mdio_write(phy->dev, phy->mii_id, reg, val);
68 }
69
70 static int reset_one_mii_phy(struct mii_phy* phy, int phy_id)
71 {
72         u16 val;
73         int limit = 10000;
74
75         val = __phy_read(phy, phy_id, MII_BMCR);
76         val &= ~(BMCR_ISOLATE | BMCR_PDOWN);
77         val |= BMCR_RESET;
78         __phy_write(phy, phy_id, MII_BMCR, val);
79
80         udelay(100);
81
82         while (--limit) {
83                 val = __phy_read(phy, phy_id, MII_BMCR);
84                 if ((val & BMCR_RESET) == 0)
85                         break;
86                 udelay(10);
87         }
88         if ((val & BMCR_ISOLATE) && limit > 0)
89                 __phy_write(phy, phy_id, MII_BMCR, val & ~BMCR_ISOLATE);
90
91         return (limit <= 0);
92 }
93
94 static int bcm5201_init(struct mii_phy* phy)
95 {
96         u16 data;
97
98         data = phy_read(phy, MII_BCM5201_MULTIPHY);
99         data &= ~MII_BCM5201_MULTIPHY_SUPERISOLATE;
100         phy_write(phy, MII_BCM5201_MULTIPHY, data);
101
102         phy_write(phy, MII_BCM5201_INTERRUPT, 0);
103
104         return 0;
105 }
106
107 static int bcm5201_suspend(struct mii_phy* phy)
108 {
109         phy_write(phy, MII_BCM5201_INTERRUPT, 0);
110         phy_write(phy, MII_BCM5201_MULTIPHY, MII_BCM5201_MULTIPHY_SUPERISOLATE);
111
112         return 0;
113 }
114
115 static int bcm5221_init(struct mii_phy* phy)
116 {
117         u16 data;
118
119         data = phy_read(phy, MII_BCM5221_TEST);
120         phy_write(phy, MII_BCM5221_TEST,
121                 data | MII_BCM5221_TEST_ENABLE_SHADOWS);
122
123         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_STAT2);
124         phy_write(phy, MII_BCM5221_SHDOW_AUX_STAT2,
125                 data | MII_BCM5221_SHDOW_AUX_STAT2_APD);
126
127         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_MODE4);
128         phy_write(phy, MII_BCM5221_SHDOW_AUX_MODE4,
129                 data | MII_BCM5221_SHDOW_AUX_MODE4_CLKLOPWR);
130
131         data = phy_read(phy, MII_BCM5221_TEST);
132         phy_write(phy, MII_BCM5221_TEST,
133                 data & ~MII_BCM5221_TEST_ENABLE_SHADOWS);
134
135         return 0;
136 }
137
138 static int bcm5221_suspend(struct mii_phy* phy)
139 {
140         u16 data;
141
142         data = phy_read(phy, MII_BCM5221_TEST);
143         phy_write(phy, MII_BCM5221_TEST,
144                 data | MII_BCM5221_TEST_ENABLE_SHADOWS);
145
146         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_MODE4);
147         phy_write(phy, MII_BCM5221_SHDOW_AUX_MODE4,
148                   data | MII_BCM5221_SHDOW_AUX_MODE4_IDDQMODE);
149
150         return 0;
151 }
152
153 static int bcm5241_init(struct mii_phy* phy)
154 {
155         u16 data;
156
157         data = phy_read(phy, MII_BCM5221_TEST);
158         phy_write(phy, MII_BCM5221_TEST,
159                 data | MII_BCM5221_TEST_ENABLE_SHADOWS);
160
161         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_STAT2);
162         phy_write(phy, MII_BCM5221_SHDOW_AUX_STAT2,
163                 data | MII_BCM5221_SHDOW_AUX_STAT2_APD);
164
165         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_MODE4);
166         phy_write(phy, MII_BCM5221_SHDOW_AUX_MODE4,
167                 data & ~MII_BCM5241_SHDOW_AUX_MODE4_STANDBYPWR);
168
169         data = phy_read(phy, MII_BCM5221_TEST);
170         phy_write(phy, MII_BCM5221_TEST,
171                 data & ~MII_BCM5221_TEST_ENABLE_SHADOWS);
172
173         return 0;
174 }
175
176 static int bcm5241_suspend(struct mii_phy* phy)
177 {
178         u16 data;
179
180         data = phy_read(phy, MII_BCM5221_TEST);
181         phy_write(phy, MII_BCM5221_TEST,
182                 data | MII_BCM5221_TEST_ENABLE_SHADOWS);
183
184         data = phy_read(phy, MII_BCM5221_SHDOW_AUX_MODE4);
185         phy_write(phy, MII_BCM5221_SHDOW_AUX_MODE4,
186                   data | MII_BCM5241_SHDOW_AUX_MODE4_STANDBYPWR);
187
188         return 0;
189 }
190
191 static int bcm5400_init(struct mii_phy* phy)
192 {
193         u16 data;
194
195         /* Configure for gigabit full duplex */
196         data = phy_read(phy, MII_BCM5400_AUXCONTROL);
197         data |= MII_BCM5400_AUXCONTROL_PWR10BASET;
198         phy_write(phy, MII_BCM5400_AUXCONTROL, data);
199
200         data = phy_read(phy, MII_BCM5400_GB_CONTROL);
201         data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
202         phy_write(phy, MII_BCM5400_GB_CONTROL, data);
203
204         udelay(100);
205
206         /* Reset and configure cascaded 10/100 PHY */
207         (void)reset_one_mii_phy(phy, 0x1f);
208
209         data = __phy_read(phy, 0x1f, MII_BCM5201_MULTIPHY);
210         data |= MII_BCM5201_MULTIPHY_SERIALMODE;
211         __phy_write(phy, 0x1f, MII_BCM5201_MULTIPHY, data);
212
213         data = phy_read(phy, MII_BCM5400_AUXCONTROL);
214         data &= ~MII_BCM5400_AUXCONTROL_PWR10BASET;
215         phy_write(phy, MII_BCM5400_AUXCONTROL, data);
216
217         return 0;
218 }
219
220 static int bcm5400_suspend(struct mii_phy* phy)
221 {
222 #if 0 /* Commented out in Darwin... someone has those dawn docs ? */
223         phy_write(phy, MII_BMCR, BMCR_PDOWN);
224 #endif
225         return 0;
226 }
227
228 static int bcm5401_init(struct mii_phy* phy)
229 {
230         u16 data;
231         int rev;
232
233         rev = phy_read(phy, MII_PHYSID2) & 0x000f;
234         if (rev == 0 || rev == 3) {
235                 /* Some revisions of 5401 appear to need this
236                  * initialisation sequence to disable, according
237                  * to OF, "tap power management"
238                  *
239                  * WARNING ! OF and Darwin don't agree on the
240                  * register addresses. OF seem to interpret the
241                  * register numbers below as decimal
242                  *
243                  * Note: This should (and does) match tg3_init_5401phy_dsp
244                  *       in the tg3.c driver. -DaveM
245                  */
246                 phy_write(phy, 0x18, 0x0c20);
247                 phy_write(phy, 0x17, 0x0012);
248                 phy_write(phy, 0x15, 0x1804);
249                 phy_write(phy, 0x17, 0x0013);
250                 phy_write(phy, 0x15, 0x1204);
251                 phy_write(phy, 0x17, 0x8006);
252                 phy_write(phy, 0x15, 0x0132);
253                 phy_write(phy, 0x17, 0x8006);
254                 phy_write(phy, 0x15, 0x0232);
255                 phy_write(phy, 0x17, 0x201f);
256                 phy_write(phy, 0x15, 0x0a20);
257         }
258
259         /* Configure for gigabit full duplex */
260         data = phy_read(phy, MII_BCM5400_GB_CONTROL);
261         data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
262         phy_write(phy, MII_BCM5400_GB_CONTROL, data);
263
264         udelay(10);
265
266         /* Reset and configure cascaded 10/100 PHY */
267         (void)reset_one_mii_phy(phy, 0x1f);
268
269         data = __phy_read(phy, 0x1f, MII_BCM5201_MULTIPHY);
270         data |= MII_BCM5201_MULTIPHY_SERIALMODE;
271         __phy_write(phy, 0x1f, MII_BCM5201_MULTIPHY, data);
272
273         return 0;
274 }
275
276 static int bcm5401_suspend(struct mii_phy* phy)
277 {
278 #if 0 /* Commented out in Darwin... someone has those dawn docs ? */
279         phy_write(phy, MII_BMCR, BMCR_PDOWN);
280 #endif
281         return 0;
282 }
283
284 static int bcm5411_init(struct mii_phy* phy)
285 {
286         u16 data;
287
288         /* Here's some more Apple black magic to setup
289          * some voltage stuffs.
290          */
291         phy_write(phy, 0x1c, 0x8c23);
292         phy_write(phy, 0x1c, 0x8ca3);
293         phy_write(phy, 0x1c, 0x8c23);
294
295         /* Here, Apple seems to want to reset it, do
296          * it as well
297          */
298         phy_write(phy, MII_BMCR, BMCR_RESET);
299         phy_write(phy, MII_BMCR, 0x1340);
300
301         data = phy_read(phy, MII_BCM5400_GB_CONTROL);
302         data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
303         phy_write(phy, MII_BCM5400_GB_CONTROL, data);
304
305         udelay(10);
306
307         /* Reset and configure cascaded 10/100 PHY */
308         (void)reset_one_mii_phy(phy, 0x1f);
309
310         return 0;
311 }
312
313 static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
314 {
315         u16 ctl, adv;
316
317         phy->autoneg = 1;
318         phy->speed = SPEED_10;
319         phy->duplex = DUPLEX_HALF;
320         phy->pause = 0;
321         phy->advertising = advertise;
322
323         /* Setup standard advertise */
324         adv = phy_read(phy, MII_ADVERTISE);
325         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
326         if (advertise & ADVERTISED_10baseT_Half)
327                 adv |= ADVERTISE_10HALF;
328         if (advertise & ADVERTISED_10baseT_Full)
329                 adv |= ADVERTISE_10FULL;
330         if (advertise & ADVERTISED_100baseT_Half)
331                 adv |= ADVERTISE_100HALF;
332         if (advertise & ADVERTISED_100baseT_Full)
333                 adv |= ADVERTISE_100FULL;
334         phy_write(phy, MII_ADVERTISE, adv);
335
336         /* Start/Restart aneg */
337         ctl = phy_read(phy, MII_BMCR);
338         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
339         phy_write(phy, MII_BMCR, ctl);
340
341         return 0;
342 }
343
344 static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
345 {
346         u16 ctl;
347
348         phy->autoneg = 0;
349         phy->speed = speed;
350         phy->duplex = fd;
351         phy->pause = 0;
352
353         ctl = phy_read(phy, MII_BMCR);
354         ctl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_ANENABLE);
355
356         /* First reset the PHY */
357         phy_write(phy, MII_BMCR, ctl | BMCR_RESET);
358
359         /* Select speed & duplex */
360         switch(speed) {
361         case SPEED_10:
362                 break;
363         case SPEED_100:
364                 ctl |= BMCR_SPEED100;
365                 break;
366         case SPEED_1000:
367         default:
368                 return -EINVAL;
369         }
370         if (fd == DUPLEX_FULL)
371                 ctl |= BMCR_FULLDPLX;
372         phy_write(phy, MII_BMCR, ctl);
373
374         return 0;
375 }
376
377 static int genmii_poll_link(struct mii_phy *phy)
378 {
379         u16 status;
380
381         (void)phy_read(phy, MII_BMSR);
382         status = phy_read(phy, MII_BMSR);
383         if ((status & BMSR_LSTATUS) == 0)
384                 return 0;
385         if (phy->autoneg && !(status & BMSR_ANEGCOMPLETE))
386                 return 0;
387         return 1;
388 }
389
390 static int genmii_read_link(struct mii_phy *phy)
391 {
392         u16 lpa;
393
394         if (phy->autoneg) {
395                 lpa = phy_read(phy, MII_LPA);
396
397                 if (lpa & (LPA_10FULL | LPA_100FULL))
398                         phy->duplex = DUPLEX_FULL;
399                 else
400                         phy->duplex = DUPLEX_HALF;
401                 if (lpa & (LPA_100FULL | LPA_100HALF))
402                         phy->speed = SPEED_100;
403                 else
404                         phy->speed = SPEED_10;
405                 phy->pause = 0;
406         }
407         /* On non-aneg, we assume what we put in BMCR is the speed,
408          * though magic-aneg shouldn't prevent this case from occurring
409          */
410
411          return 0;
412 }
413
414 static int generic_suspend(struct mii_phy* phy)
415 {
416         phy_write(phy, MII_BMCR, BMCR_PDOWN);
417
418         return 0;
419 }
420
421 static int bcm5421_init(struct mii_phy* phy)
422 {
423         u16 data;
424         unsigned int id;
425
426         id = (phy_read(phy, MII_PHYSID1) << 16 | phy_read(phy, MII_PHYSID2));
427
428         /* Revision 0 of 5421 needs some fixups */
429         if (id == 0x002060e0) {
430                 /* This is borrowed from MacOS
431                  */
432                 phy_write(phy, 0x18, 0x1007);
433                 data = phy_read(phy, 0x18);
434                 phy_write(phy, 0x18, data | 0x0400);
435                 phy_write(phy, 0x18, 0x0007);
436                 data = phy_read(phy, 0x18);
437                 phy_write(phy, 0x18, data | 0x0800);
438                 phy_write(phy, 0x17, 0x000a);
439                 data = phy_read(phy, 0x15);
440                 phy_write(phy, 0x15, data | 0x0200);
441         }
442
443         /* Pick up some init code from OF for K2 version */
444         if ((id & 0xfffffff0) == 0x002062e0) {
445                 phy_write(phy, 4, 0x01e1);
446                 phy_write(phy, 9, 0x0300);
447         }
448
449         /* Check if we can enable automatic low power */
450 #ifdef CONFIG_PPC_PMAC
451         if (phy->platform_data) {
452                 struct device_node *np = of_get_parent(phy->platform_data);
453                 int can_low_power = 1;
454                 if (np == NULL || of_get_property(np, "no-autolowpower", NULL))
455                         can_low_power = 0;
456                 if (can_low_power) {
457                         /* Enable automatic low-power */
458                         phy_write(phy, 0x1c, 0x9002);
459                         phy_write(phy, 0x1c, 0xa821);
460                         phy_write(phy, 0x1c, 0x941d);
461                 }
462         }
463 #endif /* CONFIG_PPC_PMAC */
464
465         return 0;
466 }
467
468 static int bcm54xx_setup_aneg(struct mii_phy *phy, u32 advertise)
469 {
470         u16 ctl, adv;
471
472         phy->autoneg = 1;
473         phy->speed = SPEED_10;
474         phy->duplex = DUPLEX_HALF;
475         phy->pause = 0;
476         phy->advertising = advertise;
477
478         /* Setup standard advertise */
479         adv = phy_read(phy, MII_ADVERTISE);
480         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
481         if (advertise & ADVERTISED_10baseT_Half)
482                 adv |= ADVERTISE_10HALF;
483         if (advertise & ADVERTISED_10baseT_Full)
484                 adv |= ADVERTISE_10FULL;
485         if (advertise & ADVERTISED_100baseT_Half)
486                 adv |= ADVERTISE_100HALF;
487         if (advertise & ADVERTISED_100baseT_Full)
488                 adv |= ADVERTISE_100FULL;
489         if (advertise & ADVERTISED_Pause)
490                 adv |= ADVERTISE_PAUSE_CAP;
491         if (advertise & ADVERTISED_Asym_Pause)
492                 adv |= ADVERTISE_PAUSE_ASYM;
493         phy_write(phy, MII_ADVERTISE, adv);
494
495         /* Setup 1000BT advertise */
496         adv = phy_read(phy, MII_1000BASETCONTROL);
497         adv &= ~(MII_1000BASETCONTROL_FULLDUPLEXCAP|MII_1000BASETCONTROL_HALFDUPLEXCAP);
498         if (advertise & SUPPORTED_1000baseT_Half)
499                 adv |= MII_1000BASETCONTROL_HALFDUPLEXCAP;
500         if (advertise & SUPPORTED_1000baseT_Full)
501                 adv |= MII_1000BASETCONTROL_FULLDUPLEXCAP;
502         phy_write(phy, MII_1000BASETCONTROL, adv);
503
504         /* Start/Restart aneg */
505         ctl = phy_read(phy, MII_BMCR);
506         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
507         phy_write(phy, MII_BMCR, ctl);
508
509         return 0;
510 }
511
512 static int bcm54xx_setup_forced(struct mii_phy *phy, int speed, int fd)
513 {
514         u16 ctl;
515
516         phy->autoneg = 0;
517         phy->speed = speed;
518         phy->duplex = fd;
519         phy->pause = 0;
520
521         ctl = phy_read(phy, MII_BMCR);
522         ctl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_SPD2|BMCR_ANENABLE);
523
524         /* First reset the PHY */
525         phy_write(phy, MII_BMCR, ctl | BMCR_RESET);
526
527         /* Select speed & duplex */
528         switch(speed) {
529         case SPEED_10:
530                 break;
531         case SPEED_100:
532                 ctl |= BMCR_SPEED100;
533                 break;
534         case SPEED_1000:
535                 ctl |= BMCR_SPD2;
536         }
537         if (fd == DUPLEX_FULL)
538                 ctl |= BMCR_FULLDPLX;
539
540         // XXX Should we set the sungem to GII now on 1000BT ?
541
542         phy_write(phy, MII_BMCR, ctl);
543
544         return 0;
545 }
546
547 static int bcm54xx_read_link(struct mii_phy *phy)
548 {
549         int link_mode;
550         u16 val;
551
552         if (phy->autoneg) {
553                 val = phy_read(phy, MII_BCM5400_AUXSTATUS);
554                 link_mode = ((val & MII_BCM5400_AUXSTATUS_LINKMODE_MASK) >>
555                              MII_BCM5400_AUXSTATUS_LINKMODE_SHIFT);
556                 phy->duplex = phy_BCM5400_link_table[link_mode][0] ?
557                         DUPLEX_FULL : DUPLEX_HALF;
558                 phy->speed = phy_BCM5400_link_table[link_mode][2] ?
559                                 SPEED_1000 :
560                                 (phy_BCM5400_link_table[link_mode][1] ?
561                                  SPEED_100 : SPEED_10);
562                 val = phy_read(phy, MII_LPA);
563                 phy->pause = (phy->duplex == DUPLEX_FULL) &&
564                         ((val & LPA_PAUSE) != 0);
565         }
566         /* On non-aneg, we assume what we put in BMCR is the speed,
567          * though magic-aneg shouldn't prevent this case from occurring
568          */
569
570         return 0;
571 }
572
573 static int marvell88e1111_init(struct mii_phy* phy)
574 {
575         u16 rev;
576
577         /* magic init sequence for rev 0 */
578         rev = phy_read(phy, MII_PHYSID2) & 0x000f;
579         if (rev == 0) {
580                 phy_write(phy, 0x1d, 0x000a);
581                 phy_write(phy, 0x1e, 0x0821);
582
583                 phy_write(phy, 0x1d, 0x0006);
584                 phy_write(phy, 0x1e, 0x8600);
585
586                 phy_write(phy, 0x1d, 0x000b);
587                 phy_write(phy, 0x1e, 0x0100);
588
589                 phy_write(phy, 0x1d, 0x0004);
590                 phy_write(phy, 0x1e, 0x4850);
591         }
592         return 0;
593 }
594
595 #define BCM5421_MODE_MASK       (1 << 5)
596
597 static int bcm5421_poll_link(struct mii_phy* phy)
598 {
599         u32 phy_reg;
600         int mode;
601
602         /* find out in what mode we are */
603         phy_write(phy, MII_NCONFIG, 0x1000);
604         phy_reg = phy_read(phy, MII_NCONFIG);
605
606         mode = (phy_reg & BCM5421_MODE_MASK) >> 5;
607
608         if ( mode == BCM54XX_COPPER)
609                 return genmii_poll_link(phy);
610
611         /* try to find out wether we have a link */
612         phy_write(phy, MII_NCONFIG, 0x2000);
613         phy_reg = phy_read(phy, MII_NCONFIG);
614
615         if (phy_reg & 0x0020)
616                 return 0;
617         else
618                 return 1;
619 }
620
621 static int bcm5421_read_link(struct mii_phy* phy)
622 {
623         u32 phy_reg;
624         int mode;
625
626         /* find out in what mode we are */
627         phy_write(phy, MII_NCONFIG, 0x1000);
628         phy_reg = phy_read(phy, MII_NCONFIG);
629
630         mode = (phy_reg & BCM5421_MODE_MASK ) >> 5;
631
632         if ( mode == BCM54XX_COPPER)
633                 return bcm54xx_read_link(phy);
634
635         phy->speed = SPEED_1000;
636
637         /* find out wether we are running half- or full duplex */
638         phy_write(phy, MII_NCONFIG, 0x2000);
639         phy_reg = phy_read(phy, MII_NCONFIG);
640
641         if ( (phy_reg & 0x0080) >> 7)
642                 phy->duplex |=  DUPLEX_HALF;
643         else
644                 phy->duplex |=  DUPLEX_FULL;
645
646         return 0;
647 }
648
649 static int bcm5421_enable_fiber(struct mii_phy* phy, int autoneg)
650 {
651         /* enable fiber mode */
652         phy_write(phy, MII_NCONFIG, 0x9020);
653         /* LEDs active in both modes, autosense prio = fiber */
654         phy_write(phy, MII_NCONFIG, 0x945f);
655
656         if (!autoneg) {
657                 /* switch off fibre autoneg */
658                 phy_write(phy, MII_NCONFIG, 0xfc01);
659                 phy_write(phy, 0x0b, 0x0004);
660         }
661
662         phy->autoneg = autoneg;
663
664         return 0;
665 }
666
667 #define BCM5461_FIBER_LINK      (1 << 2)
668 #define BCM5461_MODE_MASK       (3 << 1)
669
670 static int bcm5461_poll_link(struct mii_phy* phy)
671 {
672         u32 phy_reg;
673         int mode;
674
675         /* find out in what mode we are */
676         phy_write(phy, MII_NCONFIG, 0x7c00);
677         phy_reg = phy_read(phy, MII_NCONFIG);
678
679         mode = (phy_reg & BCM5461_MODE_MASK ) >> 1;
680
681         if ( mode == BCM54XX_COPPER)
682                 return genmii_poll_link(phy);
683
684         /* find out wether we have a link */
685         phy_write(phy, MII_NCONFIG, 0x7000);
686         phy_reg = phy_read(phy, MII_NCONFIG);
687
688         if (phy_reg & BCM5461_FIBER_LINK)
689                 return 1;
690         else
691                 return 0;
692 }
693
694 #define BCM5461_FIBER_DUPLEX    (1 << 3)
695
696 static int bcm5461_read_link(struct mii_phy* phy)
697 {
698         u32 phy_reg;
699         int mode;
700
701         /* find out in what mode we are */
702         phy_write(phy, MII_NCONFIG, 0x7c00);
703         phy_reg = phy_read(phy, MII_NCONFIG);
704
705         mode = (phy_reg & BCM5461_MODE_MASK ) >> 1;
706
707         if ( mode == BCM54XX_COPPER) {
708                 return bcm54xx_read_link(phy);
709         }
710
711         phy->speed = SPEED_1000;
712
713         /* find out wether we are running half- or full duplex */
714         phy_write(phy, MII_NCONFIG, 0x7000);
715         phy_reg = phy_read(phy, MII_NCONFIG);
716
717         if (phy_reg & BCM5461_FIBER_DUPLEX)
718                 phy->duplex |=  DUPLEX_FULL;
719         else
720                 phy->duplex |=  DUPLEX_HALF;
721
722         return 0;
723 }
724
725 static int bcm5461_enable_fiber(struct mii_phy* phy, int autoneg)
726 {
727         /* select fiber mode, enable 1000 base-X registers */
728         phy_write(phy, MII_NCONFIG, 0xfc0b);
729
730         if (autoneg) {
731                 /* enable fiber with no autonegotiation */
732                 phy_write(phy, MII_ADVERTISE, 0x01e0);
733                 phy_write(phy, MII_BMCR, 0x1140);
734         } else {
735                 /* enable fiber with autonegotiation */
736                 phy_write(phy, MII_BMCR, 0x0140);
737         }
738
739         phy->autoneg = autoneg;
740
741         return 0;
742 }
743
744 static int marvell_setup_aneg(struct mii_phy *phy, u32 advertise)
745 {
746         u16 ctl, adv;
747
748         phy->autoneg = 1;
749         phy->speed = SPEED_10;
750         phy->duplex = DUPLEX_HALF;
751         phy->pause = 0;
752         phy->advertising = advertise;
753
754         /* Setup standard advertise */
755         adv = phy_read(phy, MII_ADVERTISE);
756         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
757         if (advertise & ADVERTISED_10baseT_Half)
758                 adv |= ADVERTISE_10HALF;
759         if (advertise & ADVERTISED_10baseT_Full)
760                 adv |= ADVERTISE_10FULL;
761         if (advertise & ADVERTISED_100baseT_Half)
762                 adv |= ADVERTISE_100HALF;
763         if (advertise & ADVERTISED_100baseT_Full)
764                 adv |= ADVERTISE_100FULL;
765         if (advertise & ADVERTISED_Pause)
766                 adv |= ADVERTISE_PAUSE_CAP;
767         if (advertise & ADVERTISED_Asym_Pause)
768                 adv |= ADVERTISE_PAUSE_ASYM;
769         phy_write(phy, MII_ADVERTISE, adv);
770
771         /* Setup 1000BT advertise & enable crossover detect
772          * XXX How do we advertise 1000BT ? Darwin source is
773          * confusing here, they read from specific control and
774          * write to control... Someone has specs for those
775          * beasts ?
776          */
777         adv = phy_read(phy, MII_M1011_PHY_SPEC_CONTROL);
778         adv |= MII_M1011_PHY_SPEC_CONTROL_AUTO_MDIX;
779         adv &= ~(MII_1000BASETCONTROL_FULLDUPLEXCAP |
780                         MII_1000BASETCONTROL_HALFDUPLEXCAP);
781         if (advertise & SUPPORTED_1000baseT_Half)
782                 adv |= MII_1000BASETCONTROL_HALFDUPLEXCAP;
783         if (advertise & SUPPORTED_1000baseT_Full)
784                 adv |= MII_1000BASETCONTROL_FULLDUPLEXCAP;
785         phy_write(phy, MII_1000BASETCONTROL, adv);
786
787         /* Start/Restart aneg */
788         ctl = phy_read(phy, MII_BMCR);
789         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
790         phy_write(phy, MII_BMCR, ctl);
791
792         return 0;
793 }
794
795 static int marvell_setup_forced(struct mii_phy *phy, int speed, int fd)
796 {
797         u16 ctl, ctl2;
798
799         phy->autoneg = 0;
800         phy->speed = speed;
801         phy->duplex = fd;
802         phy->pause = 0;
803
804         ctl = phy_read(phy, MII_BMCR);
805         ctl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_SPD2|BMCR_ANENABLE);
806         ctl |= BMCR_RESET;
807
808         /* Select speed & duplex */
809         switch(speed) {
810         case SPEED_10:
811                 break;
812         case SPEED_100:
813                 ctl |= BMCR_SPEED100;
814                 break;
815         /* I'm not sure about the one below, again, Darwin source is
816          * quite confusing and I lack chip specs
817          */
818         case SPEED_1000:
819                 ctl |= BMCR_SPD2;
820         }
821         if (fd == DUPLEX_FULL)
822                 ctl |= BMCR_FULLDPLX;
823
824         /* Disable crossover. Again, the way Apple does it is strange,
825          * though I don't assume they are wrong ;)
826          */
827         ctl2 = phy_read(phy, MII_M1011_PHY_SPEC_CONTROL);
828         ctl2 &= ~(MII_M1011_PHY_SPEC_CONTROL_MANUAL_MDIX |
829                 MII_M1011_PHY_SPEC_CONTROL_AUTO_MDIX |
830                 MII_1000BASETCONTROL_FULLDUPLEXCAP |
831                 MII_1000BASETCONTROL_HALFDUPLEXCAP);
832         if (speed == SPEED_1000)
833                 ctl2 |= (fd == DUPLEX_FULL) ?
834                         MII_1000BASETCONTROL_FULLDUPLEXCAP :
835                         MII_1000BASETCONTROL_HALFDUPLEXCAP;
836         phy_write(phy, MII_1000BASETCONTROL, ctl2);
837
838         // XXX Should we set the sungem to GII now on 1000BT ?
839
840         phy_write(phy, MII_BMCR, ctl);
841
842         return 0;
843 }
844
845 static int marvell_read_link(struct mii_phy *phy)
846 {
847         u16 status, pmask;
848
849         if (phy->autoneg) {
850                 status = phy_read(phy, MII_M1011_PHY_SPEC_STATUS);
851                 if ((status & MII_M1011_PHY_SPEC_STATUS_RESOLVED) == 0)
852                         return -EAGAIN;
853                 if (status & MII_M1011_PHY_SPEC_STATUS_1000)
854                         phy->speed = SPEED_1000;
855                 else if (status & MII_M1011_PHY_SPEC_STATUS_100)
856                         phy->speed = SPEED_100;
857                 else
858                         phy->speed = SPEED_10;
859                 if (status & MII_M1011_PHY_SPEC_STATUS_FULLDUPLEX)
860                         phy->duplex = DUPLEX_FULL;
861                 else
862                         phy->duplex = DUPLEX_HALF;
863                 pmask = MII_M1011_PHY_SPEC_STATUS_TX_PAUSE |
864                         MII_M1011_PHY_SPEC_STATUS_RX_PAUSE;
865                 phy->pause = (status & pmask) == pmask;
866         }
867         /* On non-aneg, we assume what we put in BMCR is the speed,
868          * though magic-aneg shouldn't prevent this case from occurring
869          */
870
871         return 0;
872 }
873
874 #define MII_BASIC_FEATURES \
875         (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |      \
876          SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |    \
877          SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII |     \
878          SUPPORTED_Pause)
879
880 /* On gigabit capable PHYs, we advertise Pause support but not asym pause
881  * support for now as I'm not sure it's supported and Darwin doesn't do
882  * it neither. --BenH.
883  */
884 #define MII_GBIT_FEATURES \
885         (MII_BASIC_FEATURES |   \
886          SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full)
887
888 /* Broadcom BCM 5201 */
889 static struct mii_phy_ops bcm5201_phy_ops = {
890         .init           = bcm5201_init,
891         .suspend        = bcm5201_suspend,
892         .setup_aneg     = genmii_setup_aneg,
893         .setup_forced   = genmii_setup_forced,
894         .poll_link      = genmii_poll_link,
895         .read_link      = genmii_read_link,
896 };
897
898 static struct mii_phy_def bcm5201_phy_def = {
899         .phy_id         = 0x00406210,
900         .phy_id_mask    = 0xfffffff0,
901         .name           = "BCM5201",
902         .features       = MII_BASIC_FEATURES,
903         .magic_aneg     = 1,
904         .ops            = &bcm5201_phy_ops
905 };
906
907 /* Broadcom BCM 5221 */
908 static struct mii_phy_ops bcm5221_phy_ops = {
909         .suspend        = bcm5221_suspend,
910         .init           = bcm5221_init,
911         .setup_aneg     = genmii_setup_aneg,
912         .setup_forced   = genmii_setup_forced,
913         .poll_link      = genmii_poll_link,
914         .read_link      = genmii_read_link,
915 };
916
917 static struct mii_phy_def bcm5221_phy_def = {
918         .phy_id         = 0x004061e0,
919         .phy_id_mask    = 0xfffffff0,
920         .name           = "BCM5221",
921         .features       = MII_BASIC_FEATURES,
922         .magic_aneg     = 1,
923         .ops            = &bcm5221_phy_ops
924 };
925
926 /* Broadcom BCM 5241 */
927 static struct mii_phy_ops bcm5241_phy_ops = {
928         .suspend        = bcm5241_suspend,
929         .init           = bcm5241_init,
930         .setup_aneg     = genmii_setup_aneg,
931         .setup_forced   = genmii_setup_forced,
932         .poll_link      = genmii_poll_link,
933         .read_link      = genmii_read_link,
934 };
935 static struct mii_phy_def bcm5241_phy_def = {
936         .phy_id         = 0x0143bc30,
937         .phy_id_mask    = 0xfffffff0,
938         .name           = "BCM5241",
939         .features       = MII_BASIC_FEATURES,
940         .magic_aneg     = 1,
941         .ops            = &bcm5241_phy_ops
942 };
943
944 /* Broadcom BCM 5400 */
945 static struct mii_phy_ops bcm5400_phy_ops = {
946         .init           = bcm5400_init,
947         .suspend        = bcm5400_suspend,
948         .setup_aneg     = bcm54xx_setup_aneg,
949         .setup_forced   = bcm54xx_setup_forced,
950         .poll_link      = genmii_poll_link,
951         .read_link      = bcm54xx_read_link,
952 };
953
954 static struct mii_phy_def bcm5400_phy_def = {
955         .phy_id         = 0x00206040,
956         .phy_id_mask    = 0xfffffff0,
957         .name           = "BCM5400",
958         .features       = MII_GBIT_FEATURES,
959         .magic_aneg     = 1,
960         .ops            = &bcm5400_phy_ops
961 };
962
963 /* Broadcom BCM 5401 */
964 static struct mii_phy_ops bcm5401_phy_ops = {
965         .init           = bcm5401_init,
966         .suspend        = bcm5401_suspend,
967         .setup_aneg     = bcm54xx_setup_aneg,
968         .setup_forced   = bcm54xx_setup_forced,
969         .poll_link      = genmii_poll_link,
970         .read_link      = bcm54xx_read_link,
971 };
972
973 static struct mii_phy_def bcm5401_phy_def = {
974         .phy_id         = 0x00206050,
975         .phy_id_mask    = 0xfffffff0,
976         .name           = "BCM5401",
977         .features       = MII_GBIT_FEATURES,
978         .magic_aneg     = 1,
979         .ops            = &bcm5401_phy_ops
980 };
981
982 /* Broadcom BCM 5411 */
983 static struct mii_phy_ops bcm5411_phy_ops = {
984         .init           = bcm5411_init,
985         .suspend        = generic_suspend,
986         .setup_aneg     = bcm54xx_setup_aneg,
987         .setup_forced   = bcm54xx_setup_forced,
988         .poll_link      = genmii_poll_link,
989         .read_link      = bcm54xx_read_link,
990 };
991
992 static struct mii_phy_def bcm5411_phy_def = {
993         .phy_id         = 0x00206070,
994         .phy_id_mask    = 0xfffffff0,
995         .name           = "BCM5411",
996         .features       = MII_GBIT_FEATURES,
997         .magic_aneg     = 1,
998         .ops            = &bcm5411_phy_ops
999 };
1000
1001 /* Broadcom BCM 5421 */
1002 static struct mii_phy_ops bcm5421_phy_ops = {
1003         .init           = bcm5421_init,
1004         .suspend        = generic_suspend,
1005         .setup_aneg     = bcm54xx_setup_aneg,
1006         .setup_forced   = bcm54xx_setup_forced,
1007         .poll_link      = bcm5421_poll_link,
1008         .read_link      = bcm5421_read_link,
1009         .enable_fiber   = bcm5421_enable_fiber,
1010 };
1011
1012 static struct mii_phy_def bcm5421_phy_def = {
1013         .phy_id         = 0x002060e0,
1014         .phy_id_mask    = 0xfffffff0,
1015         .name           = "BCM5421",
1016         .features       = MII_GBIT_FEATURES,
1017         .magic_aneg     = 1,
1018         .ops            = &bcm5421_phy_ops
1019 };
1020
1021 /* Broadcom BCM 5421 built-in K2 */
1022 static struct mii_phy_ops bcm5421k2_phy_ops = {
1023         .init           = bcm5421_init,
1024         .suspend        = generic_suspend,
1025         .setup_aneg     = bcm54xx_setup_aneg,
1026         .setup_forced   = bcm54xx_setup_forced,
1027         .poll_link      = genmii_poll_link,
1028         .read_link      = bcm54xx_read_link,
1029 };
1030
1031 static struct mii_phy_def bcm5421k2_phy_def = {
1032         .phy_id         = 0x002062e0,
1033         .phy_id_mask    = 0xfffffff0,
1034         .name           = "BCM5421-K2",
1035         .features       = MII_GBIT_FEATURES,
1036         .magic_aneg     = 1,
1037         .ops            = &bcm5421k2_phy_ops
1038 };
1039
1040 static struct mii_phy_ops bcm5461_phy_ops = {
1041         .init           = bcm5421_init,
1042         .suspend        = generic_suspend,
1043         .setup_aneg     = bcm54xx_setup_aneg,
1044         .setup_forced   = bcm54xx_setup_forced,
1045         .poll_link      = bcm5461_poll_link,
1046         .read_link      = bcm5461_read_link,
1047         .enable_fiber   = bcm5461_enable_fiber,
1048 };
1049
1050 static struct mii_phy_def bcm5461_phy_def = {
1051         .phy_id         = 0x002060c0,
1052         .phy_id_mask    = 0xfffffff0,
1053         .name           = "BCM5461",
1054         .features       = MII_GBIT_FEATURES,
1055         .magic_aneg     = 1,
1056         .ops            = &bcm5461_phy_ops
1057 };
1058
1059 /* Broadcom BCM 5462 built-in Vesta */
1060 static struct mii_phy_ops bcm5462V_phy_ops = {
1061         .init           = bcm5421_init,
1062         .suspend        = generic_suspend,
1063         .setup_aneg     = bcm54xx_setup_aneg,
1064         .setup_forced   = bcm54xx_setup_forced,
1065         .poll_link      = genmii_poll_link,
1066         .read_link      = bcm54xx_read_link,
1067 };
1068
1069 static struct mii_phy_def bcm5462V_phy_def = {
1070         .phy_id         = 0x002060d0,
1071         .phy_id_mask    = 0xfffffff0,
1072         .name           = "BCM5462-Vesta",
1073         .features       = MII_GBIT_FEATURES,
1074         .magic_aneg     = 1,
1075         .ops            = &bcm5462V_phy_ops
1076 };
1077
1078 /* Marvell 88E1101 amd 88E1111 */
1079 static struct mii_phy_ops marvell88e1101_phy_ops = {
1080         .suspend        = generic_suspend,
1081         .setup_aneg     = marvell_setup_aneg,
1082         .setup_forced   = marvell_setup_forced,
1083         .poll_link      = genmii_poll_link,
1084         .read_link      = marvell_read_link
1085 };
1086
1087 static struct mii_phy_ops marvell88e1111_phy_ops = {
1088         .init           = marvell88e1111_init,
1089         .suspend        = generic_suspend,
1090         .setup_aneg     = marvell_setup_aneg,
1091         .setup_forced   = marvell_setup_forced,
1092         .poll_link      = genmii_poll_link,
1093         .read_link      = marvell_read_link
1094 };
1095
1096 /* two revs in darwin for the 88e1101 ... I could use a datasheet
1097  * to get the proper names...
1098  */
1099 static struct mii_phy_def marvell88e1101v1_phy_def = {
1100         .phy_id         = 0x01410c20,
1101         .phy_id_mask    = 0xfffffff0,
1102         .name           = "Marvell 88E1101v1",
1103         .features       = MII_GBIT_FEATURES,
1104         .magic_aneg     = 1,
1105         .ops            = &marvell88e1101_phy_ops
1106 };
1107 static struct mii_phy_def marvell88e1101v2_phy_def = {
1108         .phy_id         = 0x01410c60,
1109         .phy_id_mask    = 0xfffffff0,
1110         .name           = "Marvell 88E1101v2",
1111         .features       = MII_GBIT_FEATURES,
1112         .magic_aneg     = 1,
1113         .ops            = &marvell88e1101_phy_ops
1114 };
1115 static struct mii_phy_def marvell88e1111_phy_def = {
1116         .phy_id         = 0x01410cc0,
1117         .phy_id_mask    = 0xfffffff0,
1118         .name           = "Marvell 88E1111",
1119         .features       = MII_GBIT_FEATURES,
1120         .magic_aneg     = 1,
1121         .ops            = &marvell88e1111_phy_ops
1122 };
1123
1124 /* Generic implementation for most 10/100 PHYs */
1125 static struct mii_phy_ops generic_phy_ops = {
1126         .setup_aneg     = genmii_setup_aneg,
1127         .setup_forced   = genmii_setup_forced,
1128         .poll_link      = genmii_poll_link,
1129         .read_link      = genmii_read_link
1130 };
1131
1132 static struct mii_phy_def genmii_phy_def = {
1133         .phy_id         = 0x00000000,
1134         .phy_id_mask    = 0x00000000,
1135         .name           = "Generic MII",
1136         .features       = MII_BASIC_FEATURES,
1137         .magic_aneg     = 0,
1138         .ops            = &generic_phy_ops
1139 };
1140
1141 static struct mii_phy_def* mii_phy_table[] = {
1142         &bcm5201_phy_def,
1143         &bcm5221_phy_def,
1144         &bcm5241_phy_def,
1145         &bcm5400_phy_def,
1146         &bcm5401_phy_def,
1147         &bcm5411_phy_def,
1148         &bcm5421_phy_def,
1149         &bcm5421k2_phy_def,
1150         &bcm5461_phy_def,
1151         &bcm5462V_phy_def,
1152         &marvell88e1101v1_phy_def,
1153         &marvell88e1101v2_phy_def,
1154         &marvell88e1111_phy_def,
1155         &genmii_phy_def,
1156         NULL
1157 };
1158
1159 int mii_phy_probe(struct mii_phy *phy, int mii_id)
1160 {
1161         int rc;
1162         u32 id;
1163         struct mii_phy_def* def;
1164         int i;
1165
1166         /* We do not reset the mii_phy structure as the driver
1167          * may re-probe the PHY regulary
1168          */
1169         phy->mii_id = mii_id;
1170
1171         /* Take PHY out of isloate mode and reset it. */
1172         rc = reset_one_mii_phy(phy, mii_id);
1173         if (rc)
1174                 goto fail;
1175
1176         /* Read ID and find matching entry */
1177         id = (phy_read(phy, MII_PHYSID1) << 16 | phy_read(phy, MII_PHYSID2));
1178         printk(KERN_DEBUG "PHY ID: %x, addr: %x\n", id, mii_id);
1179         for (i=0; (def = mii_phy_table[i]) != NULL; i++)
1180                 if ((id & def->phy_id_mask) == def->phy_id)
1181                         break;
1182         /* Should never be NULL (we have a generic entry), but... */
1183         if (def == NULL)
1184                 goto fail;
1185
1186         phy->def = def;
1187
1188         return 0;
1189 fail:
1190         phy->speed = 0;
1191         phy->duplex = 0;
1192         phy->pause = 0;
1193         phy->advertising = 0;
1194         return -ENODEV;
1195 }
1196
1197 EXPORT_SYMBOL(mii_phy_probe);
1198 MODULE_LICENSE("GPL");
1199