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