bnx2x: Remove AutoGrEEEn for BCM84833
[linux-2.6.git] / drivers / net / mii.c
1 /*
2
3         mii.c: MII interface library
4
5         Maintained by Jeff Garzik <jgarzik@pobox.com>
6         Copyright 2001,2002 Jeff Garzik
7
8         Various code came from myson803.c and other files by
9         Donald Becker.  Copyright:
10
11                 Written 1998-2002 by Donald Becker.
12
13                 This software may be used and distributed according
14                 to the terms of the GNU General Public License (GPL),
15                 incorporated herein by reference.  Drivers based on
16                 or derived from this code fall under the GPL and must
17                 retain the authorship, copyright and license notice.
18                 This file is not a complete program and may only be
19                 used when the entire operating system is licensed
20                 under the GPL.
21
22                 The author may be reached as becker@scyld.com, or C/O
23                 Scyld Computing Corporation
24                 410 Severn Ave., Suite 210
25                 Annapolis MD 21403
26
27
28  */
29
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/netdevice.h>
33 #include <linux/ethtool.h>
34 #include <linux/mdio.h>
35
36 static u32 mii_get_an(struct mii_if_info *mii, u16 addr)
37 {
38         int advert;
39
40         advert = mii->mdio_read(mii->dev, mii->phy_id, addr);
41
42         return mii_lpa_to_ethtool_lpa_t(advert);
43 }
44
45 /**
46  * mii_ethtool_gset - get settings that are specified in @ecmd
47  * @mii: MII interface
48  * @ecmd: requested ethtool_cmd
49  *
50  * The @ecmd parameter is expected to have been cleared before calling
51  * mii_ethtool_gset().
52  *
53  * Returns 0 for success, negative on error.
54  */
55 int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
56 {
57         struct net_device *dev = mii->dev;
58         u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
59         u32 nego;
60
61         ecmd->supported =
62             (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
63              SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
64              SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
65         if (mii->supports_gmii)
66                 ecmd->supported |= SUPPORTED_1000baseT_Half |
67                         SUPPORTED_1000baseT_Full;
68
69         /* only supports twisted-pair */
70         ecmd->port = PORT_MII;
71
72         /* only supports internal transceiver */
73         ecmd->transceiver = XCVR_INTERNAL;
74
75         /* this isn't fully supported at higher layers */
76         ecmd->phy_address = mii->phy_id;
77         ecmd->mdio_support = MDIO_SUPPORTS_C22;
78
79         ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
80
81         bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
82         bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
83         if (mii->supports_gmii) {
84                 ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
85                 stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
86         }
87         if (bmcr & BMCR_ANENABLE) {
88                 ecmd->advertising |= ADVERTISED_Autoneg;
89                 ecmd->autoneg = AUTONEG_ENABLE;
90
91                 ecmd->advertising |= mii_get_an(mii, MII_ADVERTISE);
92                 if (mii->supports_gmii)
93                         ecmd->advertising |=
94                                         mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
95
96                 if (bmsr & BMSR_ANEGCOMPLETE) {
97                         ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
98                         ecmd->lp_advertising |=
99                                         mii_stat1000_to_ethtool_lpa_t(stat1000);
100                 } else {
101                         ecmd->lp_advertising = 0;
102                 }
103
104                 nego = ecmd->advertising & ecmd->lp_advertising;
105
106                 if (nego & (ADVERTISED_1000baseT_Full |
107                             ADVERTISED_1000baseT_Half)) {
108                         ethtool_cmd_speed_set(ecmd, SPEED_1000);
109                         ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
110                 } else if (nego & (ADVERTISED_100baseT_Full |
111                                    ADVERTISED_100baseT_Half)) {
112                         ethtool_cmd_speed_set(ecmd, SPEED_100);
113                         ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
114                 } else {
115                         ethtool_cmd_speed_set(ecmd, SPEED_10);
116                         ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
117                 }
118         } else {
119                 ecmd->autoneg = AUTONEG_DISABLE;
120
121                 ethtool_cmd_speed_set(ecmd,
122                                       ((bmcr & BMCR_SPEED1000 &&
123                                         (bmcr & BMCR_SPEED100) == 0) ?
124                                        SPEED_1000 :
125                                        ((bmcr & BMCR_SPEED100) ?
126                                         SPEED_100 : SPEED_10)));
127                 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
128         }
129
130         mii->full_duplex = ecmd->duplex;
131
132         /* ignore maxtxpkt, maxrxpkt for now */
133
134         return 0;
135 }
136
137 /**
138  * mii_ethtool_sset - set settings that are specified in @ecmd
139  * @mii: MII interface
140  * @ecmd: requested ethtool_cmd
141  *
142  * Returns 0 for success, negative on error.
143  */
144 int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
145 {
146         struct net_device *dev = mii->dev;
147         u32 speed = ethtool_cmd_speed(ecmd);
148
149         if (speed != SPEED_10 &&
150             speed != SPEED_100 &&
151             speed != SPEED_1000)
152                 return -EINVAL;
153         if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
154                 return -EINVAL;
155         if (ecmd->port != PORT_MII)
156                 return -EINVAL;
157         if (ecmd->transceiver != XCVR_INTERNAL)
158                 return -EINVAL;
159         if (ecmd->phy_address != mii->phy_id)
160                 return -EINVAL;
161         if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
162                 return -EINVAL;
163         if ((speed == SPEED_1000) && (!mii->supports_gmii))
164                 return -EINVAL;
165
166         /* ignore supported, maxtxpkt, maxrxpkt */
167
168         if (ecmd->autoneg == AUTONEG_ENABLE) {
169                 u32 bmcr, advert, tmp;
170                 u32 advert2 = 0, tmp2 = 0;
171
172                 if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
173                                           ADVERTISED_10baseT_Full |
174                                           ADVERTISED_100baseT_Half |
175                                           ADVERTISED_100baseT_Full |
176                                           ADVERTISED_1000baseT_Half |
177                                           ADVERTISED_1000baseT_Full)) == 0)
178                         return -EINVAL;
179
180                 /* advertise only what has been requested */
181                 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
182                 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
183                 if (mii->supports_gmii) {
184                         advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
185                         tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
186                 }
187                 tmp |= ethtool_adv_to_mii_adv_t(ecmd->advertising);
188
189                 if (mii->supports_gmii)
190                         tmp2 |=
191                               ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising);
192                 if (advert != tmp) {
193                         mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
194                         mii->advertising = tmp;
195                 }
196                 if ((mii->supports_gmii) && (advert2 != tmp2))
197                         mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
198
199                 /* turn on autonegotiation, and force a renegotiate */
200                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
201                 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
202                 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
203
204                 mii->force_media = 0;
205         } else {
206                 u32 bmcr, tmp;
207
208                 /* turn off auto negotiation, set speed and duplexity */
209                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
210                 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
211                                BMCR_SPEED1000 | BMCR_FULLDPLX);
212                 if (speed == SPEED_1000)
213                         tmp |= BMCR_SPEED1000;
214                 else if (speed == SPEED_100)
215                         tmp |= BMCR_SPEED100;
216                 if (ecmd->duplex == DUPLEX_FULL) {
217                         tmp |= BMCR_FULLDPLX;
218                         mii->full_duplex = 1;
219                 } else
220                         mii->full_duplex = 0;
221                 if (bmcr != tmp)
222                         mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
223
224                 mii->force_media = 1;
225         }
226         return 0;
227 }
228
229 /**
230  * mii_check_gmii_support - check if the MII supports Gb interfaces
231  * @mii: the MII interface
232  */
233 int mii_check_gmii_support(struct mii_if_info *mii)
234 {
235         int reg;
236
237         reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
238         if (reg & BMSR_ESTATEN) {
239                 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
240                 if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
241                         return 1;
242         }
243
244         return 0;
245 }
246
247 /**
248  * mii_link_ok - is link status up/ok
249  * @mii: the MII interface
250  *
251  * Returns 1 if the MII reports link status up/ok, 0 otherwise.
252  */
253 int mii_link_ok (struct mii_if_info *mii)
254 {
255         /* first, a dummy read, needed to latch some MII phys */
256         mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
257         if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
258                 return 1;
259         return 0;
260 }
261
262 /**
263  * mii_nway_restart - restart NWay (autonegotiation) for this interface
264  * @mii: the MII interface
265  *
266  * Returns 0 on success, negative on error.
267  */
268 int mii_nway_restart (struct mii_if_info *mii)
269 {
270         int bmcr;
271         int r = -EINVAL;
272
273         /* if autoneg is off, it's an error */
274         bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
275
276         if (bmcr & BMCR_ANENABLE) {
277                 bmcr |= BMCR_ANRESTART;
278                 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
279                 r = 0;
280         }
281
282         return r;
283 }
284
285 /**
286  * mii_check_link - check MII link status
287  * @mii: MII interface
288  *
289  * If the link status changed (previous != current), call
290  * netif_carrier_on() if current link status is Up or call
291  * netif_carrier_off() if current link status is Down.
292  */
293 void mii_check_link (struct mii_if_info *mii)
294 {
295         int cur_link = mii_link_ok(mii);
296         int prev_link = netif_carrier_ok(mii->dev);
297
298         if (cur_link && !prev_link)
299                 netif_carrier_on(mii->dev);
300         else if (prev_link && !cur_link)
301                 netif_carrier_off(mii->dev);
302 }
303
304 /**
305  * mii_check_media - check the MII interface for a duplex change
306  * @mii: the MII interface
307  * @ok_to_print: OK to print link up/down messages
308  * @init_media: OK to save duplex mode in @mii
309  *
310  * Returns 1 if the duplex mode changed, 0 if not.
311  * If the media type is forced, always returns 0.
312  */
313 unsigned int mii_check_media (struct mii_if_info *mii,
314                               unsigned int ok_to_print,
315                               unsigned int init_media)
316 {
317         unsigned int old_carrier, new_carrier;
318         int advertise, lpa, media, duplex;
319         int lpa2 = 0;
320
321         /* if forced media, go no further */
322         if (mii->force_media)
323                 return 0; /* duplex did not change */
324
325         /* check current and old link status */
326         old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
327         new_carrier = (unsigned int) mii_link_ok(mii);
328
329         /* if carrier state did not change, this is a "bounce",
330          * just exit as everything is already set correctly
331          */
332         if ((!init_media) && (old_carrier == new_carrier))
333                 return 0; /* duplex did not change */
334
335         /* no carrier, nothing much to do */
336         if (!new_carrier) {
337                 netif_carrier_off(mii->dev);
338                 if (ok_to_print)
339                         netdev_info(mii->dev, "link down\n");
340                 return 0; /* duplex did not change */
341         }
342
343         /*
344          * we have carrier, see who's on the other end
345          */
346         netif_carrier_on(mii->dev);
347
348         /* get MII advertise and LPA values */
349         if ((!init_media) && (mii->advertising))
350                 advertise = mii->advertising;
351         else {
352                 advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
353                 mii->advertising = advertise;
354         }
355         lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
356         if (mii->supports_gmii)
357                 lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
358
359         /* figure out media and duplex from advertise and LPA values */
360         media = mii_nway_result(lpa & advertise);
361         duplex = (media & ADVERTISE_FULL) ? 1 : 0;
362         if (lpa2 & LPA_1000FULL)
363                 duplex = 1;
364
365         if (ok_to_print)
366                 netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
367                             lpa2 & (LPA_1000FULL | LPA_1000HALF) ? 1000 :
368                             media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ?
369                             100 : 10,
370                             duplex ? "full" : "half",
371                             lpa);
372
373         if ((init_media) || (mii->full_duplex != duplex)) {
374                 mii->full_duplex = duplex;
375                 return 1; /* duplex changed */
376         }
377
378         return 0; /* duplex did not change */
379 }
380
381 /**
382  * generic_mii_ioctl - main MII ioctl interface
383  * @mii_if: the MII interface
384  * @mii_data: MII ioctl data structure
385  * @cmd: MII ioctl command
386  * @duplex_chg_out: pointer to @duplex_changed status if there was no
387  *      ioctl error
388  *
389  * Returns 0 on success, negative on error.
390  */
391 int generic_mii_ioctl(struct mii_if_info *mii_if,
392                       struct mii_ioctl_data *mii_data, int cmd,
393                       unsigned int *duplex_chg_out)
394 {
395         int rc = 0;
396         unsigned int duplex_changed = 0;
397
398         if (duplex_chg_out)
399                 *duplex_chg_out = 0;
400
401         mii_data->phy_id &= mii_if->phy_id_mask;
402         mii_data->reg_num &= mii_if->reg_num_mask;
403
404         switch(cmd) {
405         case SIOCGMIIPHY:
406                 mii_data->phy_id = mii_if->phy_id;
407                 /* fall through */
408
409         case SIOCGMIIREG:
410                 mii_data->val_out =
411                         mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
412                                           mii_data->reg_num);
413                 break;
414
415         case SIOCSMIIREG: {
416                 u16 val = mii_data->val_in;
417
418                 if (mii_data->phy_id == mii_if->phy_id) {
419                         switch(mii_data->reg_num) {
420                         case MII_BMCR: {
421                                 unsigned int new_duplex = 0;
422                                 if (val & (BMCR_RESET|BMCR_ANENABLE))
423                                         mii_if->force_media = 0;
424                                 else
425                                         mii_if->force_media = 1;
426                                 if (mii_if->force_media &&
427                                     (val & BMCR_FULLDPLX))
428                                         new_duplex = 1;
429                                 if (mii_if->full_duplex != new_duplex) {
430                                         duplex_changed = 1;
431                                         mii_if->full_duplex = new_duplex;
432                                 }
433                                 break;
434                         }
435                         case MII_ADVERTISE:
436                                 mii_if->advertising = val;
437                                 break;
438                         default:
439                                 /* do nothing */
440                                 break;
441                         }
442                 }
443
444                 mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
445                                    mii_data->reg_num, val);
446                 break;
447         }
448
449         default:
450                 rc = -EOPNOTSUPP;
451                 break;
452         }
453
454         if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
455                 *duplex_chg_out = 1;
456
457         return rc;
458 }
459
460 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
461 MODULE_DESCRIPTION ("MII hardware support library");
462 MODULE_LICENSE("GPL");
463
464 EXPORT_SYMBOL(mii_link_ok);
465 EXPORT_SYMBOL(mii_nway_restart);
466 EXPORT_SYMBOL(mii_ethtool_gset);
467 EXPORT_SYMBOL(mii_ethtool_sset);
468 EXPORT_SYMBOL(mii_check_link);
469 EXPORT_SYMBOL(mii_check_media);
470 EXPORT_SYMBOL(mii_check_gmii_support);
471 EXPORT_SYMBOL(generic_mii_ioctl);
472