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