xref: /freebsd/sys/dev/mii/mii.c (revision 6472ac3d8a86336899b6cfb789a4cd9897e3fab5)
1 /*	$NetBSD: mii.c,v 1.12 1999/08/03 19:41:49 drochner Exp $	*/
2 
3 /*-
4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9  * NASA Ames Research Center.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 /*
37  * MII bus layer, glues MII-capable network interface drivers to sharable
38  * PHY drivers.  This exports an interface compatible with BSD/OS 3.0's,
39  * plus some NetBSD extensions.
40  */
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/socket.h>
45 #include <sys/malloc.h>
46 #include <sys/module.h>
47 #include <sys/bus.h>
48 
49 #include <net/if.h>
50 #include <net/if_media.h>
51 #include <net/route.h>
52 
53 #include <dev/mii/mii.h>
54 #include <dev/mii/miivar.h>
55 
56 MODULE_VERSION(miibus, 1);
57 
58 #include "miibus_if.h"
59 
60 static int miibus_print_child(device_t dev, device_t child);
61 static int miibus_read_ivar(device_t dev, device_t child, int which,
62     uintptr_t *result);
63 static int miibus_child_location_str(device_t bus, device_t child, char *buf,
64     size_t buflen);
65 static int miibus_child_pnpinfo_str(device_t bus, device_t child, char *buf,
66     size_t buflen);
67 static int miibus_readreg(device_t, int, int);
68 static int miibus_writereg(device_t, int, int, int);
69 static void miibus_statchg(device_t);
70 static void miibus_linkchg(device_t);
71 static void miibus_mediainit(device_t);
72 static unsigned char mii_bitreverse(unsigned char x);
73 
74 static device_method_t miibus_methods[] = {
75 	/* device interface */
76 	DEVMETHOD(device_probe,		miibus_probe),
77 	DEVMETHOD(device_attach,	miibus_attach),
78 	DEVMETHOD(device_detach,	miibus_detach),
79 	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
80 
81 	/* bus interface */
82 	DEVMETHOD(bus_print_child,	miibus_print_child),
83 	DEVMETHOD(bus_read_ivar,	miibus_read_ivar),
84 	DEVMETHOD(bus_driver_added,	bus_generic_driver_added),
85 	DEVMETHOD(bus_child_pnpinfo_str, miibus_child_pnpinfo_str),
86 	DEVMETHOD(bus_child_location_str, miibus_child_location_str),
87 
88 	/* MII interface */
89 	DEVMETHOD(miibus_readreg,	miibus_readreg),
90 	DEVMETHOD(miibus_writereg,	miibus_writereg),
91 	DEVMETHOD(miibus_statchg,	miibus_statchg),
92 	DEVMETHOD(miibus_linkchg,	miibus_linkchg),
93 	DEVMETHOD(miibus_mediainit,	miibus_mediainit),
94 
95 	{ 0, 0 }
96 };
97 
98 devclass_t miibus_devclass;
99 
100 driver_t miibus_driver = {
101 	"miibus",
102 	miibus_methods,
103 	sizeof(struct mii_data)
104 };
105 
106 struct miibus_ivars {
107 	struct ifnet	*ifp;
108 	ifm_change_cb_t	ifmedia_upd;
109 	ifm_stat_cb_t	ifmedia_sts;
110 	int		mii_flags;
111 };
112 
113 int
114 miibus_probe(device_t dev)
115 {
116 
117 	device_set_desc(dev, "MII bus");
118 
119 	return (BUS_PROBE_SPECIFIC);
120 }
121 
122 int
123 miibus_attach(device_t dev)
124 {
125 	struct miibus_ivars	*ivars;
126 	struct mii_attach_args	*ma;
127 	struct mii_data		*mii;
128 	device_t		*children;
129 	int			i, nchildren;
130 
131 	mii = device_get_softc(dev);
132 	nchildren = 0;
133 	if (device_get_children(dev, &children, &nchildren) == 0) {
134 		for (i = 0; i < nchildren; i++) {
135 			ma = device_get_ivars(children[i]);
136 			ma->mii_data = mii;
137 		}
138 		free(children, M_TEMP);
139 	}
140 	if (nchildren == 0) {
141 		device_printf(dev, "cannot get children\n");
142 		return (ENXIO);
143 	}
144 	ivars = device_get_ivars(dev);
145 	ifmedia_init(&mii->mii_media, IFM_IMASK, ivars->ifmedia_upd,
146 	    ivars->ifmedia_sts);
147 	mii->mii_ifp = ivars->ifp;
148 	mii->mii_ifp->if_capabilities |= IFCAP_LINKSTATE;
149 	mii->mii_ifp->if_capenable |= IFCAP_LINKSTATE;
150 	LIST_INIT(&mii->mii_phys);
151 
152 	return (bus_generic_attach(dev));
153 }
154 
155 int
156 miibus_detach(device_t dev)
157 {
158 	struct mii_data		*mii;
159 
160 	bus_generic_detach(dev);
161 	mii = device_get_softc(dev);
162 	ifmedia_removeall(&mii->mii_media);
163 	mii->mii_ifp = NULL;
164 
165 	return (0);
166 }
167 
168 static int
169 miibus_print_child(device_t dev, device_t child)
170 {
171 	struct mii_attach_args *ma;
172 	int retval;
173 
174 	ma = device_get_ivars(child);
175 	retval = bus_print_child_header(dev, child);
176 	retval += printf(" PHY %d", ma->mii_phyno);
177 	retval += bus_print_child_footer(dev, child);
178 
179 	return (retval);
180 }
181 
182 static int
183 miibus_read_ivar(device_t dev, device_t child __unused, int which,
184     uintptr_t *result)
185 {
186 	struct miibus_ivars *ivars;
187 
188 	/*
189 	 * NB: this uses the instance variables of the miibus rather than
190 	 * its PHY children.
191 	 */
192 	ivars = device_get_ivars(dev);
193 	switch (which) {
194 	case MIIBUS_IVAR_FLAGS:
195 		*result = ivars->mii_flags;
196 		break;
197 	default:
198 		return (ENOENT);
199 	}
200 	return (0);
201 }
202 
203 static int
204 miibus_child_pnpinfo_str(device_t bus __unused, device_t child, char *buf,
205     size_t buflen)
206 {
207 	struct mii_attach_args *ma;
208 
209 	ma = device_get_ivars(child);
210 	snprintf(buf, buflen, "oui=0x%x model=0x%x rev=0x%x",
211 	    MII_OUI(ma->mii_id1, ma->mii_id2),
212 	    MII_MODEL(ma->mii_id2), MII_REV(ma->mii_id2));
213 	return (0);
214 }
215 
216 static int
217 miibus_child_location_str(device_t bus __unused, device_t child, char *buf,
218     size_t buflen)
219 {
220 	struct mii_attach_args *ma;
221 
222 	ma = device_get_ivars(child);
223 	snprintf(buf, buflen, "phyno=%d", ma->mii_phyno);
224 	return (0);
225 }
226 
227 static int
228 miibus_readreg(device_t dev, int phy, int reg)
229 {
230 	device_t		parent;
231 
232 	parent = device_get_parent(dev);
233 	return (MIIBUS_READREG(parent, phy, reg));
234 }
235 
236 static int
237 miibus_writereg(device_t dev, int phy, int reg, int data)
238 {
239 	device_t		parent;
240 
241 	parent = device_get_parent(dev);
242 	return (MIIBUS_WRITEREG(parent, phy, reg, data));
243 }
244 
245 static void
246 miibus_statchg(device_t dev)
247 {
248 	device_t		parent;
249 	struct mii_data		*mii;
250 
251 	parent = device_get_parent(dev);
252 	MIIBUS_STATCHG(parent);
253 
254 	mii = device_get_softc(dev);
255 	mii->mii_ifp->if_baudrate = ifmedia_baudrate(mii->mii_media_active);
256 }
257 
258 static void
259 miibus_linkchg(device_t dev)
260 {
261 	struct mii_data		*mii;
262 	device_t		parent;
263 	int			link_state;
264 
265 	parent = device_get_parent(dev);
266 	MIIBUS_LINKCHG(parent);
267 
268 	mii = device_get_softc(dev);
269 
270 	if (mii->mii_media_status & IFM_AVALID) {
271 		if (mii->mii_media_status & IFM_ACTIVE)
272 			link_state = LINK_STATE_UP;
273 		else
274 			link_state = LINK_STATE_DOWN;
275 	} else
276 		link_state = LINK_STATE_UNKNOWN;
277 	if_link_state_change(mii->mii_ifp, link_state);
278 }
279 
280 static void
281 miibus_mediainit(device_t dev)
282 {
283 	struct mii_data		*mii;
284 	struct ifmedia_entry	*m;
285 	int			media = 0;
286 
287 	/* Poke the parent in case it has any media of its own to add. */
288 	MIIBUS_MEDIAINIT(device_get_parent(dev));
289 
290 	mii = device_get_softc(dev);
291 	LIST_FOREACH(m, &mii->mii_media.ifm_list, ifm_list) {
292 		media = m->ifm_media;
293 		if (media == (IFM_ETHER | IFM_AUTO))
294 			break;
295 	}
296 
297 	ifmedia_set(&mii->mii_media, media);
298 }
299 
300 /*
301  * Helper function used by network interface drivers, attaches the miibus and
302  * the PHYs to the network interface driver parent.
303  */
304 int
305 mii_attach(device_t dev, device_t *miibus, struct ifnet *ifp,
306     ifm_change_cb_t ifmedia_upd, ifm_stat_cb_t ifmedia_sts, int capmask,
307     int phyloc, int offloc, int flags)
308 {
309 	struct miibus_ivars *ivars;
310 	struct mii_attach_args ma, *args;
311 	device_t *children, phy;
312 	int bmsr, first, i, nchildren, offset, phymax, phymin, rv;
313 
314 	if (phyloc != MII_PHY_ANY && offloc != MII_OFFSET_ANY) {
315 		printf("%s: phyloc and offloc specified\n", __func__);
316 		return (EINVAL);
317 	}
318 
319 	if (offloc != MII_OFFSET_ANY && (offloc < 0 || offloc >= MII_NPHY)) {
320 		printf("%s: ivalid offloc %d\n", __func__, offloc);
321 		return (EINVAL);
322 	}
323 
324 	if (phyloc == MII_PHY_ANY) {
325 		phymin = 0;
326 		phymax = MII_NPHY - 1;
327 	} else {
328 		if (phyloc < 0 || phyloc >= MII_NPHY) {
329 			printf("%s: ivalid phyloc %d\n", __func__, phyloc);
330 			return (EINVAL);
331 		}
332 		phymin = phymax = phyloc;
333 	}
334 
335 	first = 0;
336 	if (*miibus == NULL) {
337 		first = 1;
338 		ivars = malloc(sizeof(*ivars), M_DEVBUF, M_NOWAIT);
339 		if (ivars == NULL)
340 			return (ENOMEM);
341 		ivars->ifp = ifp;
342 		ivars->ifmedia_upd = ifmedia_upd;
343 		ivars->ifmedia_sts = ifmedia_sts;
344 		ivars->mii_flags = flags;
345 		*miibus = device_add_child(dev, "miibus", -1);
346 		if (*miibus == NULL) {
347 			rv = ENXIO;
348 			goto fail;
349 		}
350 		device_set_ivars(*miibus, ivars);
351 	} else {
352 		ivars = device_get_ivars(*miibus);
353 		if (ivars->ifp != ifp || ivars->ifmedia_upd != ifmedia_upd ||
354 		    ivars->ifmedia_sts != ifmedia_sts ||
355 		    ivars->mii_flags != flags) {
356 			printf("%s: non-matching invariant\n", __func__);
357 			return (EINVAL);
358 		}
359 		/*
360 		 * Assignment of the attach arguments mii_data for the first
361 		 * pass is done in miibus_attach(), i.e. once the miibus softc
362 		 * has been allocated.
363 		 */
364 		ma.mii_data = device_get_softc(*miibus);
365 	}
366 
367 	ma.mii_capmask = capmask;
368 
369 	phy = NULL;
370 	offset = 0;
371 	for (ma.mii_phyno = phymin; ma.mii_phyno <= phymax; ma.mii_phyno++) {
372 		/*
373 		 * Make sure we haven't already configured a PHY at this
374 		 * address.  This allows mii_attach() to be called
375 		 * multiple times.
376 		 */
377 		if (device_get_children(*miibus, &children, &nchildren) == 0) {
378 			for (i = 0; i < nchildren; i++) {
379 				args = device_get_ivars(children[i]);
380 				if (args->mii_phyno == ma.mii_phyno) {
381 					/*
382 					 * Yes, there is already something
383 					 * configured at this address.
384 					 */
385 					free(children, M_TEMP);
386 					goto skip;
387 				}
388 			}
389 			free(children, M_TEMP);
390 		}
391 
392 		/*
393 		 * Check to see if there is a PHY at this address.  Note,
394 		 * many braindead PHYs report 0/0 in their ID registers,
395 		 * so we test for media in the BMSR.
396 		 */
397 		bmsr = MIIBUS_READREG(dev, ma.mii_phyno, MII_BMSR);
398 		if (bmsr == 0 || bmsr == 0xffff ||
399 		    (bmsr & (BMSR_EXTSTAT | BMSR_MEDIAMASK)) == 0) {
400 			/* Assume no PHY at this address. */
401 			continue;
402 		}
403 
404 		/*
405 		 * There is a PHY at this address.  If we were given an
406 		 * `offset' locator, skip this PHY if it doesn't match.
407 		 */
408 		if (offloc != MII_OFFSET_ANY && offloc != offset)
409 			goto skip;
410 
411 		/*
412 		 * Extract the IDs. Braindead PHYs will be handled by
413 		 * the `ukphy' driver, as we have no ID information to
414 		 * match on.
415 		 */
416 		ma.mii_id1 = MIIBUS_READREG(dev, ma.mii_phyno, MII_PHYIDR1);
417 		ma.mii_id2 = MIIBUS_READREG(dev, ma.mii_phyno, MII_PHYIDR2);
418 
419 		ma.mii_offset = offset;
420 		args = malloc(sizeof(struct mii_attach_args), M_DEVBUF,
421 		    M_NOWAIT);
422 		if (args == NULL)
423 			goto skip;
424 		bcopy((char *)&ma, (char *)args, sizeof(ma));
425 		phy = device_add_child(*miibus, NULL, -1);
426 		if (phy == NULL) {
427 			free(args, M_DEVBUF);
428 			goto skip;
429 		}
430 		device_set_ivars(phy, args);
431  skip:
432 		offset++;
433 	}
434 
435 	if (first != 0) {
436 		if (phy == NULL) {
437 			rv = ENXIO;
438 			goto fail;
439 		}
440 		rv = bus_generic_attach(dev);
441 		if (rv != 0)
442 			goto fail;
443 
444 		/* Attaching of the PHY drivers is done in miibus_attach(). */
445 		return (0);
446 	}
447 	rv = bus_generic_attach(*miibus);
448 	if (rv != 0)
449 		goto fail;
450 
451 	return (0);
452 
453  fail:
454 	if (*miibus != NULL)
455 		device_delete_child(dev, *miibus);
456 	free(ivars, M_DEVBUF);
457 	if (first != 0)
458 		*miibus = NULL;
459 	return (rv);
460 }
461 
462 /*
463  * Media changed; notify all PHYs.
464  */
465 int
466 mii_mediachg(struct mii_data *mii)
467 {
468 	struct mii_softc *child;
469 	struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
470 	int rv;
471 
472 	mii->mii_media_status = 0;
473 	mii->mii_media_active = IFM_NONE;
474 
475 	LIST_FOREACH(child, &mii->mii_phys, mii_list) {
476 		/*
477 		 * If the media indicates a different PHY instance,
478 		 * isolate this one.
479 		 */
480 		if (IFM_INST(ife->ifm_media) != child->mii_inst) {
481 			if ((child->mii_flags & MIIF_NOISOLATE) != 0) {
482 				device_printf(child->mii_dev, "%s: "
483 				    "can't handle non-zero PHY instance %d\n",
484 				    __func__, child->mii_inst);
485 				continue;
486 			}
487 			PHY_WRITE(child, MII_BMCR, PHY_READ(child, MII_BMCR) |
488 			    BMCR_ISO);
489 			continue;
490 		}
491 		rv = PHY_SERVICE(child, mii, MII_MEDIACHG);
492 		if (rv)
493 			return (rv);
494 	}
495 	return (0);
496 }
497 
498 /*
499  * Call the PHY tick routines, used during autonegotiation.
500  */
501 void
502 mii_tick(struct mii_data *mii)
503 {
504 	struct mii_softc *child;
505 	struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
506 
507 	LIST_FOREACH(child, &mii->mii_phys, mii_list) {
508 		/*
509 		 * If this PHY instance isn't currently selected, just skip
510 		 * it.
511 		 */
512 		if (IFM_INST(ife->ifm_media) != child->mii_inst)
513 			continue;
514 		(void)PHY_SERVICE(child, mii, MII_TICK);
515 	}
516 }
517 
518 /*
519  * Get media status from PHYs.
520  */
521 void
522 mii_pollstat(struct mii_data *mii)
523 {
524 	struct mii_softc *child;
525 	struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
526 
527 	mii->mii_media_status = 0;
528 	mii->mii_media_active = IFM_NONE;
529 
530 	LIST_FOREACH(child, &mii->mii_phys, mii_list) {
531 		/*
532 		 * If we're not polling this PHY instance, just skip it.
533 		 */
534 		if (IFM_INST(ife->ifm_media) != child->mii_inst)
535 			continue;
536 		(void)PHY_SERVICE(child, mii, MII_POLLSTAT);
537 	}
538 }
539 
540 /*
541  * Inform the PHYs that the interface is down.
542  */
543 void
544 mii_down(struct mii_data *mii)
545 {
546 	struct mii_softc *child;
547 
548 	LIST_FOREACH(child, &mii->mii_phys, mii_list)
549 		mii_phy_down(child);
550 }
551 
552 static unsigned char
553 mii_bitreverse(unsigned char x)
554 {
555 	unsigned const char const nibbletab[16] = {
556 		0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
557 	};
558 
559 	return ((nibbletab[x & 15] << 4) | nibbletab[x >> 4]);
560 }
561 
562 u_int
563 mii_oui(u_int id1, u_int id2)
564 {
565 	u_int h;
566 
567 	h = (id1 << 6) | (id2 >> 10);
568 
569 	return ((mii_bitreverse(h >> 16) << 16) |
570 	    (mii_bitreverse((h >> 8) & 0xff) << 8) |
571 	    mii_bitreverse(h & 0xff));
572 }
573