[PATCH] silence cs89x0
[linux-2.6] / 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/mii.h>
35
36 int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
37 {
38         struct net_device *dev = mii->dev;
39         u32 advert, bmcr, lpa, nego;
40         u32 advert2 = 0, bmcr2 = 0, lpa2 = 0;
41
42         ecmd->supported =
43             (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
44              SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
45              SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
46         if (mii->supports_gmii)
47                 ecmd->supported |= SUPPORTED_1000baseT_Half |
48                         SUPPORTED_1000baseT_Full;
49
50         /* only supports twisted-pair */
51         ecmd->port = PORT_MII;
52
53         /* only supports internal transceiver */
54         ecmd->transceiver = XCVR_INTERNAL;
55
56         /* this isn't fully supported at higher layers */
57         ecmd->phy_address = mii->phy_id;
58
59         ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
60         advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
61         if (mii->supports_gmii)
62                 advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
63
64         if (advert & ADVERTISE_10HALF)
65                 ecmd->advertising |= ADVERTISED_10baseT_Half;
66         if (advert & ADVERTISE_10FULL)
67                 ecmd->advertising |= ADVERTISED_10baseT_Full;
68         if (advert & ADVERTISE_100HALF)
69                 ecmd->advertising |= ADVERTISED_100baseT_Half;
70         if (advert & ADVERTISE_100FULL)
71                 ecmd->advertising |= ADVERTISED_100baseT_Full;
72         if (advert2 & ADVERTISE_1000HALF)
73                 ecmd->advertising |= ADVERTISED_1000baseT_Half;
74         if (advert2 & ADVERTISE_1000FULL)
75                 ecmd->advertising |= ADVERTISED_1000baseT_Full;
76
77         bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
78         lpa = mii->mdio_read(dev, mii->phy_id, MII_LPA);
79         if (mii->supports_gmii) {
80                 bmcr2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
81                 lpa2 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
82         }
83         if (bmcr & BMCR_ANENABLE) {
84                 ecmd->advertising |= ADVERTISED_Autoneg;
85                 ecmd->autoneg = AUTONEG_ENABLE;
86                 
87                 nego = mii_nway_result(advert & lpa);
88                 if ((bmcr2 & (ADVERTISE_1000HALF | ADVERTISE_1000FULL)) & 
89                     (lpa2 >> 2))
90                         ecmd->speed = SPEED_1000;
91                 else if (nego == LPA_100FULL || nego == LPA_100HALF)
92                         ecmd->speed = SPEED_100;
93                 else
94                         ecmd->speed = SPEED_10;
95                 if ((lpa2 & LPA_1000FULL) || nego == LPA_100FULL ||
96                     nego == LPA_10FULL) {
97                         ecmd->duplex = DUPLEX_FULL;
98                         mii->full_duplex = 1;
99                 } else {
100                         ecmd->duplex = DUPLEX_HALF;
101                         mii->full_duplex = 0;
102                 }
103         } else {
104                 ecmd->autoneg = AUTONEG_DISABLE;
105
106                 ecmd->speed = ((bmcr & BMCR_SPEED1000 && 
107                                 (bmcr & BMCR_SPEED100) == 0) ? SPEED_1000 :
108                                (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10);
109                 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
110         }
111
112         /* ignore maxtxpkt, maxrxpkt for now */
113
114         return 0;
115 }
116
117 int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
118 {
119         struct net_device *dev = mii->dev;
120
121         if (ecmd->speed != SPEED_10 && 
122             ecmd->speed != SPEED_100 && 
123             ecmd->speed != SPEED_1000)
124                 return -EINVAL;
125         if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
126                 return -EINVAL;
127         if (ecmd->port != PORT_MII)
128                 return -EINVAL;
129         if (ecmd->transceiver != XCVR_INTERNAL)
130                 return -EINVAL;
131         if (ecmd->phy_address != mii->phy_id)
132                 return -EINVAL;
133         if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
134                 return -EINVAL;
135         if ((ecmd->speed == SPEED_1000) && (!mii->supports_gmii))
136                 return -EINVAL;
137                                   
138         /* ignore supported, maxtxpkt, maxrxpkt */
139         
140         if (ecmd->autoneg == AUTONEG_ENABLE) {
141                 u32 bmcr, advert, tmp;
142                 u32 advert2 = 0, tmp2 = 0;
143
144                 if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
145                                           ADVERTISED_10baseT_Full |
146                                           ADVERTISED_100baseT_Half |
147                                           ADVERTISED_100baseT_Full |
148                                           ADVERTISED_1000baseT_Half |
149                                           ADVERTISED_1000baseT_Full)) == 0)
150                         return -EINVAL;
151
152                 /* advertise only what has been requested */
153                 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
154                 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
155                 if (mii->supports_gmii) {
156                         advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
157                         tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
158                 }
159                 if (ecmd->advertising & ADVERTISED_10baseT_Half)
160                         tmp |= ADVERTISE_10HALF;
161                 if (ecmd->advertising & ADVERTISED_10baseT_Full)
162                         tmp |= ADVERTISE_10FULL;
163                 if (ecmd->advertising & ADVERTISED_100baseT_Half)
164                         tmp |= ADVERTISE_100HALF;
165                 if (ecmd->advertising & ADVERTISED_100baseT_Full)
166                         tmp |= ADVERTISE_100FULL;
167                 if (mii->supports_gmii) {
168                         if (ecmd->advertising & ADVERTISED_1000baseT_Half)
169                                 tmp2 |= ADVERTISE_1000HALF;
170                         if (ecmd->advertising & ADVERTISED_1000baseT_Full)
171                                 tmp2 |= ADVERTISE_1000FULL;
172                 }
173                 if (advert != tmp) {
174                         mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
175                         mii->advertising = tmp;
176                 }
177                 if ((mii->supports_gmii) && (advert2 != tmp2))
178                         mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
179                 
180                 /* turn on autonegotiation, and force a renegotiate */
181                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
182                 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
183                 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
184
185                 mii->force_media = 0;
186         } else {
187                 u32 bmcr, tmp;
188
189                 /* turn off auto negotiation, set speed and duplexity */
190                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
191                 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 | 
192                                BMCR_SPEED1000 | BMCR_FULLDPLX);
193                 if (ecmd->speed == SPEED_1000)
194                         tmp |= BMCR_SPEED1000;
195                 else if (ecmd->speed == SPEED_100)
196                         tmp |= BMCR_SPEED100;
197                 if (ecmd->duplex == DUPLEX_FULL) {
198                         tmp |= BMCR_FULLDPLX;
199                         mii->full_duplex = 1;
200                 } else
201                         mii->full_duplex = 0;
202                 if (bmcr != tmp)
203                         mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
204
205                 mii->force_media = 1;
206         }
207         return 0;
208 }
209
210 int mii_link_ok (struct mii_if_info *mii)
211 {
212         /* first, a dummy read, needed to latch some MII phys */
213         mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
214         if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
215                 return 1;
216         return 0;
217 }
218
219 int mii_nway_restart (struct mii_if_info *mii)
220 {
221         int bmcr;
222         int r = -EINVAL;
223
224         /* if autoneg is off, it's an error */
225         bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
226
227         if (bmcr & BMCR_ANENABLE) {
228                 bmcr |= BMCR_ANRESTART;
229                 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
230                 r = 0;
231         }
232
233         return r;
234 }
235
236 void mii_check_link (struct mii_if_info *mii)
237 {
238         int cur_link = mii_link_ok(mii);
239         int prev_link = netif_carrier_ok(mii->dev);
240
241         if (cur_link && !prev_link)
242                 netif_carrier_on(mii->dev);
243         else if (prev_link && !cur_link)
244                 netif_carrier_off(mii->dev);
245 }
246
247 unsigned int mii_check_media (struct mii_if_info *mii,
248                               unsigned int ok_to_print,
249                               unsigned int init_media)
250 {
251         unsigned int old_carrier, new_carrier;
252         int advertise, lpa, media, duplex;
253         int lpa2 = 0;
254
255         /* if forced media, go no further */
256         if (mii->force_media)
257                 return 0; /* duplex did not change */
258
259         /* check current and old link status */
260         old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
261         new_carrier = (unsigned int) mii_link_ok(mii);
262
263         /* if carrier state did not change, this is a "bounce",
264          * just exit as everything is already set correctly
265          */
266         if ((!init_media) && (old_carrier == new_carrier))
267                 return 0; /* duplex did not change */
268
269         /* no carrier, nothing much to do */
270         if (!new_carrier) {
271                 netif_carrier_off(mii->dev);
272                 if (ok_to_print)
273                         printk(KERN_INFO "%s: link down\n", mii->dev->name);
274                 return 0; /* duplex did not change */
275         }
276
277         /*
278          * we have carrier, see who's on the other end
279          */
280         netif_carrier_on(mii->dev);
281
282         /* get MII advertise and LPA values */
283         if ((!init_media) && (mii->advertising))
284                 advertise = mii->advertising;
285         else {
286                 advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
287                 mii->advertising = advertise;
288         }
289         lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
290         if (mii->supports_gmii)
291                 lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
292
293         /* figure out media and duplex from advertise and LPA values */
294         media = mii_nway_result(lpa & advertise);
295         duplex = (media & ADVERTISE_FULL) ? 1 : 0;
296         if (lpa2 & LPA_1000FULL)
297                 duplex = 1;
298
299         if (ok_to_print)
300                 printk(KERN_INFO "%s: link up, %sMbps, %s-duplex, lpa 0x%04X\n",
301                        mii->dev->name,
302                        lpa2 & (LPA_1000FULL | LPA_1000HALF) ? "1000" :
303                        media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ? "100" : "10",
304                        duplex ? "full" : "half",
305                        lpa);
306
307         if ((init_media) || (mii->full_duplex != duplex)) {
308                 mii->full_duplex = duplex;
309                 return 1; /* duplex changed */
310         }
311
312         return 0; /* duplex did not change */
313 }
314
315 int generic_mii_ioctl(struct mii_if_info *mii_if,
316                       struct mii_ioctl_data *mii_data, int cmd,
317                       unsigned int *duplex_chg_out)
318 {
319         int rc = 0;
320         unsigned int duplex_changed = 0;
321
322         if (duplex_chg_out)
323                 *duplex_chg_out = 0;
324
325         mii_data->phy_id &= mii_if->phy_id_mask;
326         mii_data->reg_num &= mii_if->reg_num_mask;
327
328         switch(cmd) {
329         case SIOCGMIIPHY:
330                 mii_data->phy_id = mii_if->phy_id;
331                 /* fall through */
332
333         case SIOCGMIIREG:
334                 mii_data->val_out =
335                         mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
336                                           mii_data->reg_num);
337                 break;
338
339         case SIOCSMIIREG: {
340                 u16 val = mii_data->val_in;
341
342                 if (!capable(CAP_NET_ADMIN))
343                         return -EPERM;
344
345                 if (mii_data->phy_id == mii_if->phy_id) {
346                         switch(mii_data->reg_num) {
347                         case MII_BMCR: {
348                                 unsigned int new_duplex = 0;
349                                 if (val & (BMCR_RESET|BMCR_ANENABLE))
350                                         mii_if->force_media = 0;
351                                 else
352                                         mii_if->force_media = 1;
353                                 if (mii_if->force_media &&
354                                     (val & BMCR_FULLDPLX))
355                                         new_duplex = 1;
356                                 if (mii_if->full_duplex != new_duplex) {
357                                         duplex_changed = 1;
358                                         mii_if->full_duplex = new_duplex;
359                                 }
360                                 break;
361                         }
362                         case MII_ADVERTISE:
363                                 mii_if->advertising = val;
364                                 break;
365                         default:
366                                 /* do nothing */
367                                 break;
368                         }
369                 }
370
371                 mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
372                                    mii_data->reg_num, val);
373                 break;
374         }
375
376         default:
377                 rc = -EOPNOTSUPP;
378                 break;
379         }
380
381         if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
382                 *duplex_chg_out = 1;
383
384         return rc;
385 }
386
387 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
388 MODULE_DESCRIPTION ("MII hardware support library");
389 MODULE_LICENSE("GPL");
390
391 EXPORT_SYMBOL(mii_link_ok);
392 EXPORT_SYMBOL(mii_nway_restart);
393 EXPORT_SYMBOL(mii_ethtool_gset);
394 EXPORT_SYMBOL(mii_ethtool_sset);
395 EXPORT_SYMBOL(mii_check_link);
396 EXPORT_SYMBOL(mii_check_media);
397 EXPORT_SYMBOL(generic_mii_ioctl);
398