Linux update to 4.11-rc5

Linux baseline a71c9a1c779f2499fb2afc0553e543f18aff6edf (4.11-rc5).

5 files changed, 247 insertions, 343 deletions

diff --git a/rtemsbsd/sys/powerpc/compat.c b/rtemsbsd/sys/powerpc/compat.c
index 2ee73a9b..7a9dd955 100644
--- a/rtemsbsd/sys/powerpc/compat.c
+++ b/rtemsbsd/sys/powerpc/compat.c
@@ -43,6 +43,32 @@ of_get_property(const struct device_node *dn, const char *name, int *len)
 	return (fdt_getprop(fdt, dn->offset, name, len));
 }
 
+int
+of_property_read_u32_array(const struct device_node *dn, const char *name,
+    u32 *vals, size_t n)
+{
+	const u32 *prop_vals;
+	int len;
+
+	prop_vals = of_get_property(dn, name, &len);
+	if (prop_vals == NULL) {
+		return (-EINVAL);
+	}
+
+	if (len != n * sizeof(*vals)) {
+		return (-EOVERFLOW);
+	}
+
+	while (n > 0) {
+		*vals = fdt32_to_cpu(*prop_vals);
+		++vals;
+		++prop_vals;
+		--n;
+	}
+
+	return (0);
+}
+
 bool
 of_device_is_available(const struct device_node *dn)
 {
@@ -95,6 +121,48 @@ of_find_compatible_node(struct device_node *dns, const struct device_node *dn,
 	}
 }
 
+struct device_node *
+of_parse_phandle(struct device_node *dns, struct device_node *dn,
+    const char *phandle_name, int index)
+{
+	const void *fdt = bsp_fdt_get();
+	const fdt32_t *phandle;
+	int node;
+	int len;
+
+	phandle = fdt_getprop(fdt, dn->offset, phandle_name, &len);
+	if (phandle == NULL || (len / (int) sizeof(*phandle)) <= index) {
+		return (NULL);
+	}
+
+	node = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(phandle[index]));
+	if (node < 0) {
+		return (NULL);
+	}
+
+	dns->offset = node;
+	dns->full_name = NULL;
+	return (dns);
+}
+
+int
+of_count_phandle_with_args(struct device_node *dn, const char *list_name,
+    const char *cells_name)
+{
+	const void *fdt = bsp_fdt_get();
+	const fdt32_t *phandle;
+	int len;
+
+	BSD_ASSERT(cells_name == NULL);
+
+	phandle = fdt_getprop(fdt, dn->offset, list_name, &len);
+	if (phandle == NULL) {
+		return (-ENOENT);
+	}
+
+	return (len / (int)sizeof(*phandle));
+}
+
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 
@@ -208,11 +276,63 @@ of_irq_to_resource(struct device_node *dn, int index,
 	/* FIXME */
 	irq -= 16;
 #endif
+
+	if (res != NULL) {
+		res->start = irq;
+		res->end = irq;
+	}
+
 	return (irq);
 }
 
 #include <linux/of_net.h>
 #include <linux/if_ether.h>
+#include <linux/phy.h>
+
+static const char * const phy_modes[] = {
+	[PHY_INTERFACE_MODE_MII]	= "mii",
+	[PHY_INTERFACE_MODE_GMII]	= "gmii",
+	[PHY_INTERFACE_MODE_SGMII]	= "sgmii",
+	[PHY_INTERFACE_MODE_TBI]	= "tbi",
+	[PHY_INTERFACE_MODE_REVMII]	= "rev-mii",
+	[PHY_INTERFACE_MODE_RMII]	= "rmii",
+	[PHY_INTERFACE_MODE_RGMII]	= "rgmii",
+	[PHY_INTERFACE_MODE_RGMII_ID]	= "rgmii-id",
+	[PHY_INTERFACE_MODE_RGMII_RXID]	= "rgmii-rxid",
+	[PHY_INTERFACE_MODE_RGMII_TXID]	= "rgmii-txid",
+	[PHY_INTERFACE_MODE_RTBI]	= "rtbi",
+	[PHY_INTERFACE_MODE_SMII]	= "smii",
+	[PHY_INTERFACE_MODE_XGMII]	= "xgmii",
+	[PHY_INTERFACE_MODE_MOCA]	= "moca",
+	[PHY_INTERFACE_MODE_QSGMII]	= "qsgmii"
+};
+
+int
+of_get_phy_mode(struct device_node *dn)
+{
+	const void *fdt = bsp_fdt_get();
+	int len;
+	const char *p;
+	int i;
+
+	p = fdt_getprop(fdt, dn->offset, "phy-mode", &len);
+
+	if (p == NULL) {
+		p = fdt_getprop(fdt, dn->offset, "phy-connection-type", &len);
+	}
+
+	if (p == NULL) {
+		return (-ENODEV);
+	}
+
+	for (i = 0; i < ARRAY_SIZE(phy_modes); i++) {
+		if (phy_modes[i] != NULL && strcmp(p, phy_modes[i]) == 0) {
+			return (i);
+		}
+	}
+
+	return (-ENODEV);
+}
 
 static const void *
 get_mac_address(struct device_node *dn, const char *name)
@@ -289,9 +409,35 @@ const uint8_t bitrev_nibbles[16] = {
 #include <linux/platform_device.h>
 
 struct resource *
-platform_get_resource_impl(struct platform_device *dev,
-    unsigned int type, unsigned int num, struct resource *res)
+platform_get_resource(struct resource *res, struct platform_device *pdev,
+    unsigned int type, unsigned int num)
+{
+	struct device_node *dn;
+	int ret;
+
+	dn = pdev->dev.of_node;
+
+	switch (type) {
+	case IORESOURCE_MEM:
+		ret = of_address_to_resource(dn, num, res);
+		if (ret == 0)
+			return res;
+	case IORESOURCE_IRQ:
+		ret = of_irq_to_resource(dn, num, res);
+		if (ret >= 0)
+			return res;
+	default:
+		break;
+	}
+
+	return (NULL);
+}
+
+int platform_get_irq(struct platform_device *pdev, unsigned int num)
 {
+	struct resource res_storage;
+	struct resource *res;
 
-	return (res);
+	res = platform_get_resource(&res_storage, pdev, IORESOURCE_IRQ, num);
+	return (res != NULL ? res->start : -ENXIO);
 }
diff --git a/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.c b/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.c
index 35e83d18..4a538b26 100644
--- a/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.c
+++ b/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.c
@@ -45,7 +45,6 @@
 #include <linux/phy.h>
 
 #include "../../../../../../../../linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h"
-#include "../../../../../../../../linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth_common.h"
 
 #define	FMAN_MAC_LOCK(sc)		mtx_lock(&(sc)->mtx)
 #define	FMAN_MAC_UNLOCK(sc)		mtx_unlock(&(sc)->mtx)
@@ -55,9 +54,9 @@
     CSUM_UDP_IPV6)
 
 struct fman_mac_sgt {
-	char priv[DPA_TX_PRIV_DATA_SIZE];
+	char priv[DPAA_TX_PRIV_DATA_SIZE];
 	struct fman_prs_result prs;
-	struct qm_sg_entry sg[DPA_SGT_MAX_ENTRIES];
+	struct qm_sg_entry sg[DPAA_SGT_MAX_ENTRIES];
 	struct mbuf *m;
 };
 
@@ -109,11 +108,11 @@ fman_mac_txstart_locked(struct ifnet *ifp, struct fman_mac_softc *sc)
 		struct mbuf *m;
 		struct mbuf *n;
 		struct qm_fd fd;
-		struct dpa_priv_s *priv;
+		struct dpaa_priv *priv;
 		struct qman_fq *egress_fq;
 		int queue = 0;
 		size_t i;
-		uintptr_t addr;
+		int err;
 
 		IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
 		if (m == NULL) {
@@ -122,20 +121,16 @@ fman_mac_txstart_locked(struct ifnet *ifp, struct fman_mac_softc *sc)
 
 		sgt = uma_zalloc(sc->sgt_zone, M_NOWAIT);
 		if (sgt == NULL) {
-			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
+			if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
 			m_freem(m);
 			continue;
 		}
 
-		clear_fd(&fd);
-		fd.bpid = 0xff;
-		fd.offset = offsetof(struct fman_mac_sgt, sg);
-		fd.format = qm_fd_sg;
-		fd.length20 = m->m_pkthdr.len;
-		fd.cmd |= FM_FD_CMD_FCO;
-		addr = (uintptr_t)sgt;
-		fd.addr_hi = (u8)upper_32_bits(addr);
-		fd.addr_lo = lower_32_bits(addr);
+		qm_fd_clear_fd(&fd);
+		qm_fd_set_sg(&fd, offsetof(struct fman_mac_sgt, sg), m->m_pkthdr.len);
+		fd.bpid = FSL_DPAA_BPID_INV;
+		fd.cmd |= cpu_to_be32(FM_FD_CMD_FCO);
+		qm_fd_addr_set64(&fd, (uintptr_t)sgt);
 		fman_mac_enable_tx_csum(m, &fd, &sgt->prs);
 
 repeat_with_collapsed_mbuf_chain:
@@ -143,31 +138,27 @@ repeat_with_collapsed_mbuf_chain:
 		i = 0;
 		n = m;
 
-		while (n != NULL && i < DPA_SGT_MAX_ENTRIES) {
+		while (n != NULL && i < DPAA_SGT_MAX_ENTRIES) {
 			int len = n->m_len;
 
 			if (len > 0) {
-				sgt->sg[i].bpid = 0xff;
+				qm_sg_entry_set_len(&sgt->sg[i], len);
+				sgt->sg[i].bpid = FSL_DPAA_BPID_INV;
 				sgt->sg[i].offset = 0;
-				sgt->sg[i].length = len;
-				sgt->sg[i].extension = 0;
-				sgt->sg[i].final = 0;
-				addr = mtod(n, uintptr_t);
-				sgt->sg[i].addr_hi = (u8)upper_32_bits(addr);
-				sgt->sg[i].addr_lo =
-				    cpu_to_be32(lower_32_bits(addr));
+				qm_sg_entry_set64(&sgt->sg[i],
+				    mtod(n, uintptr_t));
 				++i;
 			}
 
 			n = n->m_next;
 		}
 
-		if (n != NULL && i == DPA_SGT_MAX_ENTRIES) {
+		if (n != NULL && i == DPAA_SGT_MAX_ENTRIES) {
 			struct mbuf *c;
 
-			c = m_collapse(m, M_NOWAIT, DPA_SGT_MAX_ENTRIES);
+			c = m_collapse(m, M_NOWAIT, DPAA_SGT_MAX_ENTRIES);
 			if (c == NULL) {
-				if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
+				if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
 				m_freem(m);
 				uma_zfree(sc->sgt_zone, sgt);
 				continue;
@@ -177,12 +168,24 @@ repeat_with_collapsed_mbuf_chain:
 			goto repeat_with_collapsed_mbuf_chain;
 		}
 
-		sgt->sg[i - 1].final = 1;
+		sgt->sg[i - 1].cfg |= cpu_to_be32(QM_SG_FIN);
 		sgt->m = m;
 		priv = netdev_priv(&sc->mac_dev.net_dev);
 		egress_fq = priv->egress_fqs[queue];
-		fd.cmd |= qman_fq_fqid(priv->conf_fqs[queue]);
-		qman_enqueue(egress_fq, &fd, QMAN_ENQUEUE_FLAG_WAIT);
+		fd.cmd |= cpu_to_be32(qman_fq_fqid(priv->conf_fqs[queue]));
+
+		for (i = 0; i < DPAA_ENQUEUE_RETRIES; ++i) {
+			err = qman_enqueue(egress_fq, &fd);
+			if (err != -EBUSY) {
+				break;
+			}
+		}
+
+		if (unlikely(err < 0)) {
+			if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
+			m_freem(m);
+			continue;
+		}
 	}
 }
 
@@ -273,8 +276,10 @@ fman_mac_init_locked(struct fman_mac_softc *sc)
 	error = dpa_eth_priv_start(&sc->mac_dev.net_dev);
 	BSD_ASSERT(error == 0);
 
-	mii_mediachg(sc->mii_softc);
-	callout_reset(&sc->fman_mac_callout, hz, fman_mac_tick, sc);
+	if (sc->mii_softc != NULL) {
+		mii_mediachg(sc->mii_softc);
+		callout_reset(&sc->fman_mac_callout, hz, fman_mac_tick, sc);
+	}
 
 	fman_mac_set_multi(sc);
 }
@@ -351,7 +356,13 @@ fman_mac_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 	case SIOCSIFMEDIA:
 	case SIOCGIFMEDIA:
 		mii = sc->mii_softc;
-		error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
+
+		if (mii != NULL) {
+			error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
+		} else {
+			error = EINVAL;
+		}
+
 		break;
 	default:
 		error = ether_ioctl(ifp, cmd, data);
@@ -393,8 +404,8 @@ int
 fman_mac_dev_attach(device_t dev)
 {
 	struct fman_mac_softc *sc;
-	struct fman_ivars *ivars;
 	struct ifnet *ifp;
+	struct phy_device *phy_dev;
 	int error;
 
 	sc = device_get_softc(dev);
@@ -435,12 +446,11 @@ fman_mac_dev_attach(device_t dev)
 	ifp->if_hdrlen = sizeof(struct ether_vlan_header);
 
 	/* Attach the MII driver if necessary */
-	ivars = device_get_ivars(dev);
-	sc->phy_dev = fdt_phy_obtain(ivars->of_dev.dev.of_node->offset);
-	if (sc->phy_dev != NULL) {
+	phy_dev = sc->mac_dev.phy_dev;
+	if (phy_dev != NULL) {
 		error = mii_attach(dev, &sc->miibus, ifp,
 		    fman_mac_media_change, fman_mac_media_status,
-		    BMSR_DEFCAPMASK, sc->phy_dev->phy, MII_OFFSET_ANY, 0);
+		    BMSR_DEFCAPMASK, phy_dev->mdio.addr, MII_OFFSET_ANY, 0);
 		if (error != 0) {
 			goto error_2;
 		}
@@ -487,28 +497,24 @@ int
 fman_mac_miibus_read_reg(device_t dev, int phy, int reg)
 {
 	struct fman_mac_softc *sc;
-	struct fdt_phy_device *phy_dev;
-	struct fdt_mdio_device *mdio_dev;
+	struct phy_device *phy_dev;
 
 	sc = device_get_softc(dev);
-	phy_dev = sc->phy_dev;
-	BSD_ASSERT(phy == phy_dev->phy);
-	mdio_dev = phy_dev->mdio_dev;
-	return ((*mdio_dev->read)(mdio_dev, phy, reg));
+	phy_dev = sc->mac_dev.phy_dev;
+	BSD_ASSERT(phy == phy_dev->mdio.addr);
+	return (phy_read(phy_dev, reg));
 }
 
 int
 fman_mac_miibus_write_reg(device_t dev, int phy, int reg, int val)
 {
 	struct fman_mac_softc *sc;
-	struct fdt_phy_device *phy_dev;
-	struct fdt_mdio_device *mdio_dev;
+	struct phy_device *phy_dev;
 
 	sc = device_get_softc(dev);
-	phy_dev = sc->phy_dev;
-	BSD_ASSERT(phy == phy_dev->phy);
-	mdio_dev = phy_dev->mdio_dev;
-	return ((*mdio_dev->write)(mdio_dev, phy, reg, val));
+	phy_dev = sc->mac_dev.phy_dev;
+	BSD_ASSERT(phy == phy_dev->mdio.addr);
+	return (phy_write(phy_dev, reg, val));
 }
 
 void
@@ -562,236 +568,12 @@ fman_mac_miibus_statchg(device_t dev)
 	(*mac_dev->adjust_link)(mac_dev, speed);
 }
 
-static int _dpa_bp_add_8_bufs(const struct dpa_bp *dpa_bp)
-{
-	struct bm_buffer bmb[8];
-	u8 i;
-
-	memset(bmb, 0, sizeof(bmb));
-
-	for (i = 0; i < 8; ++i) {
-		struct mbuf *m;
-
-		m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
-		if (unlikely(m == NULL)) {
-			goto cl_alloc_failed;
-		}
-
-		RTEMS_STATIC_ASSERT(DPA_BP_RAW_SIZE == MCLBYTES, DPA_BP_RAW_SIZE);
-		*(struct mbuf **)(mtod(m, char *) + DPA_MBUF_POINTER_OFFSET) = m;
-
-		bm_buffer_set64(&bmb[i], mtod(m, uintptr_t));
-	}
-
-release_bufs:
-	/* Release the buffers. In case bman is busy, keep trying
-	 * until successful. bman_release() is guaranteed to succeed
-	 * in a reasonable amount of time
-	 */
-	while (unlikely(bman_release(dpa_bp->pool, bmb, i, 0)))
-		cpu_relax();
-	return i;
-
-cl_alloc_failed:
-	bm_buffer_set64(&bmb[i], 0);
-	/* Avoid releasing a completely null buffer; bman_release() requires
-	 * at least one buffer.
-	 */
-	if (likely(i))
-		goto release_bufs;
-
-	return 0;
-}
-
-/* Cold path wrapper over _dpa_bp_add_8_bufs(). */
-static void dpa_bp_add_8_bufs(const struct dpa_bp *dpa_bp, int cpu)
-{
-	int *count_ptr = per_cpu_ptr(dpa_bp->percpu_count, cpu);
-	*count_ptr += _dpa_bp_add_8_bufs(dpa_bp);
-}
-
-int dpa_bp_priv_seed(struct dpa_bp *dpa_bp)
-{
-	int i;
-
-	/* Give each CPU an allotment of "config_count" buffers */
-#ifndef __rtems__
-	for_each_possible_cpu(i) {
-#else /* __rtems__ */
-	for (i = 0; i < (int)rtems_get_processor_count(); ++i) {
-#endif /* __rtems__ */
-		int j;
-
-		/* Although we access another CPU's counters here
-		 * we do it at boot time so it is safe
-		 */
-		for (j = 0; j < dpa_bp->config_count; j += 8)
-			dpa_bp_add_8_bufs(dpa_bp, i);
-	}
-	return 0;
-}
-
-/* Add buffers/(pages) for Rx processing whenever bpool count falls below
- * REFILL_THRESHOLD.
- */
-int dpaa_eth_refill_bpools(struct dpa_bp *dpa_bp, int *countptr)
-{
-	int count = *countptr;
-	int new_bufs;
-
-	if (unlikely(count < FSL_DPAA_ETH_REFILL_THRESHOLD)) {
-		do {
-			new_bufs = _dpa_bp_add_8_bufs(dpa_bp);
-			if (unlikely(!new_bufs)) {
-				/* Avoid looping forever if we've temporarily
-				 * run out of memory. We'll try again at the
-				 * next NAPI cycle.
-				 */
-				break;
-			}
-			count += new_bufs;
-		} while (count < FSL_DPAA_ETH_MAX_BUF_COUNT);
-
-		*countptr = count;
-		if (unlikely(count < FSL_DPAA_ETH_MAX_BUF_COUNT))
-			return -ENOMEM;
-	}
-
-	return 0;
-}
-
-static struct mbuf *
-addr_to_mbuf(dma_addr_t addr)
-{
-	void *vaddr = phys_to_virt(addr);
-
-	return (*(struct mbuf **)(vaddr + DPA_MBUF_POINTER_OFFSET));
-}
-
-static struct mbuf *
-contig_fd_to_mbuf(const struct qm_fd *fd, struct ifnet *ifp)
-{
-	struct mbuf *m;
-	ssize_t fd_off = dpa_fd_offset(fd);
-	dma_addr_t addr = qm_fd_addr(fd);
-
-	m = addr_to_mbuf(addr);
-	m->m_pkthdr.rcvif = ifp;
-	m->m_pkthdr.len = m->m_len = dpa_fd_length(fd);
-	m->m_data = mtod(m, char *) + fd_off;
-
-	return (m);
-}
-
-static void
-dpa_bp_recycle_frag(struct dpa_bp *dpa_bp, dma_addr_t addr, int *count_ptr)
-{
-	struct bm_buffer bmb;
-
-	bm_buffer_set64(&bmb, addr);
-
-	while (bman_release(dpa_bp->pool, &bmb, 1, 0))
-		cpu_relax();
-
-	++(*count_ptr);
-}
-
-static struct mbuf *
-sg_fd_to_mbuf(struct dpa_bp *dpa_bp, const struct qm_fd *fd,
-    struct ifnet *ifp, int *count_ptr)
-{
-	ssize_t fd_off = dpa_fd_offset(fd);
-	dma_addr_t addr = qm_fd_addr(fd);
-	const struct qm_sg_entry *sgt;
-	int i;
-	int len;
-	struct mbuf *m;
-	struct mbuf *last;
-
-	sgt = (const struct qm_sg_entry *)((char *)phys_to_virt(addr) + fd_off);
-	len = 0;
-
-	for (i = 0; i < DPA_SGT_MAX_ENTRIES; ++i) {
-		dma_addr_t sg_addr;
-		int sg_len;
-		struct mbuf *n;
-
-		BSD_ASSERT(sgt[i].extension == 0);
-		BSD_ASSERT(dpa_bp == dpa_bpid2pool(sgt[i].bpid));
-
-		sg_addr = qm_sg_addr(&sgt[i]);
-		n = addr_to_mbuf(sg_addr);
-
-		sg_len = sgt[i].length;
-		len += sg_len;
-
-		if (i == 0) {
-			m = n;
-		} else {
-			last->m_next = n;
-		}
-
-		n->m_len = sg_len;
-		m->m_data = mtod(m, char *) + sgt[i].offset;
-		last = n;
-
-		--(*count_ptr);
-
-		if (sgt[i].final) {
-			break;
-		}
-	}
-
-	m->m_pkthdr.rcvif = ifp;
-	m->m_pkthdr.len = len;
-
-	dpa_bp_recycle_frag(dpa_bp, addr, count_ptr);
-
-	return (m);
-}
-
-void
-_dpa_rx(struct net_device *net_dev, struct qman_portal *portal,
-    const struct dpa_priv_s *priv, struct dpa_percpu_priv_s *percpu_priv,
-    const struct qm_fd *fd, u32 fqid, int *count_ptr)
-{
-	struct dpa_bp *dpa_bp;
-	struct mbuf *m;
-	struct ifnet *ifp;
-
-	ifp = net_dev->ifp;
-
-	if (unlikely(fd->status & FM_FD_STAT_RX_ERRORS) != 0) {
-		if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
-		dpa_fd_release(net_dev, fd);
-		return;
-	}
-
-	dpa_bp = priv->dpa_bp;
-	BSD_ASSERT(dpa_bp == dpa_bpid2pool(fd->bpid));
-
-	if (likely(fd->format == qm_fd_contig)) {
-		m = contig_fd_to_mbuf(fd, ifp);
-	} else {
-		BSD_ASSERT(fd->format == qm_fd_sg);
-		m = sg_fd_to_mbuf(dpa_bp, fd, ifp, count_ptr);
-	}
-
-	/* Account for either the contig buffer or the SGT buffer (depending on
-	 * which case we were in) having been removed from the pool.
-	 */
-	(*count_ptr)--;
-
-	if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
-	(*ifp->if_input)(ifp, m);
-}
-
-void _dpa_cleanup_tx_fd(struct ifnet *ifp, const struct qm_fd *fd)
+void dpaa_cleanup_tx_fd(struct ifnet *ifp, const struct qm_fd *fd)
 {
 	struct fman_mac_softc *sc;
 	struct fman_mac_sgt *sgt;
 
-	BSD_ASSERT(fd->format == qm_fd_sg);
+	BSD_ASSERT(qm_fd_get_format(fd) == qm_fd_sg);
 
 	sc = ifp->if_softc;
 	sgt = (struct fman_mac_sgt *)qm_fd_addr(fd);
diff --git a/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.h b/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.h
index ba07e362..92242ae6 100644
--- a/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.h
+++ b/rtemsbsd/sys/powerpc/drivers/net/ethernet/freescale/dpaa/if_fmanmac.h
@@ -43,8 +43,7 @@
 #include <dev/mii/miivar.h>
 
 #include <linux/netdevice.h>
-
-#include <fdt_phy.h>
+#include <linux/phy.h>
 
 #include "mac.h"
 
diff --git a/rtemsbsd/sys/powerpc/fdt_phy.c b/rtemsbsd/sys/powerpc/fdt_phy.c
index b6f87f90..04fad064 100644
--- a/rtemsbsd/sys/powerpc/fdt_phy.c
+++ b/rtemsbsd/sys/powerpc/fdt_phy.c
@@ -29,8 +29,6 @@
 
 #include <machine/rtems-bsd-kernel-space.h>
 
-#include <fdt_phy.h>
-
 #include <sys/param.h>
 #include <sys/lock.h>
 #include <sys/time.h>
@@ -45,17 +43,13 @@
 
 #include <bsp/fdt.h>
 
+#include <linux/of_mdio.h>
+
 #define	MDIO_LOCK()	mtx_lock(&mdio.mutex)
 #define	MDIO_UNLOCK()	mtx_unlock(&mdio.mutex)
 
-struct mdio_device {
-	struct fdt_mdio_device base;
-	SLIST_ENTRY(mdio_device) next;
-	int node;
-};
-
 static struct {
-	SLIST_HEAD(, mdio_device) instances;
+	SLIST_HEAD(, mdio_bus) instances;
 	struct mtx mutex;
 } mdio = {
 	.instances = SLIST_HEAD_INITIALIZER(mdio.instances)
@@ -133,8 +127,8 @@ struct fman_mdio_regs {
 #define	MDIO_CTRL_REG_ADDR(x)	((x) & 0x1fU)
 #define	MDIO_CTRL_PHY_ADDR(x)	(((x) & 0x1fU) << 5)
 
-struct fman_mdio_device {
-	struct mdio_device base;
+struct fman_mdio_bus {
+	struct mdio_bus base;
 	volatile struct fman_mdio_regs *regs;
 };
 
@@ -163,14 +157,14 @@ fman_mdio_wait(volatile struct fman_mdio_regs *regs)
 }
 
 static int
-fman_mdio_read(struct fdt_mdio_device *base, int phy, int reg)
+fman_mdio_read(struct mdio_bus *base, int phy, int reg)
 {
-	struct fman_mdio_device *fm;
+	struct fman_mdio_bus *fm;
 	volatile struct fman_mdio_regs *regs;
 	int val;
 	int err;
 
-	fm = (struct fman_mdio_device *)base;
+	fm = (struct fman_mdio_bus *)base;
 	regs = fm->regs;
 
 	MDIO_LOCK();
@@ -205,13 +199,13 @@ fman_mdio_read(struct fdt_mdio_device *base, int phy, int reg)
 }
 
 static int
-fman_mdio_write(struct fdt_mdio_device *base, int phy, int reg, int val)
+fman_mdio_write(struct mdio_bus *base, int phy, int reg, int val)
 {
-	struct fman_mdio_device *fm;
+	struct fman_mdio_bus *fm;
 	volatile struct fman_mdio_regs *regs;
 	int err;
 
-	fm = (struct fman_mdio_device *)base;
+	fm = (struct fman_mdio_bus *)base;
 	regs = fm->regs;
 
 	MDIO_LOCK();
@@ -238,26 +232,27 @@ fman_mdio_write(struct fdt_mdio_device *base, int phy, int reg, int val)
 	return (0);
 }
 
-static struct mdio_device *
+static struct mdio_bus *
 create_fman_mdio(const void *fdt, int mdio_node)
 {
-	struct fman_mdio_device *fm = NULL;
+	struct fman_mdio_bus *fm = NULL;
 
 	fm = malloc(sizeof(*fm), M_TEMP, M_WAITOK | M_ZERO);
 	if (fm == NULL) {
 		return (NULL);
 	}
 
+	fm->base.read = fman_mdio_read;
+	fm->base.write = fman_mdio_write;
+	fm->base.node = mdio_node;
 	fm->regs = (volatile struct fman_mdio_regs *)(uintptr_t)
 	    fdt_get_address(fdt, mdio_node);
-	fm->base.base.read = fman_mdio_read;
-	fm->base.base.write = fman_mdio_write;
 
 	return (&fm->base);
 }
 
-static struct mdio_device *
-create_mdio_device(const void *fdt, int mdio_node)
+static struct mdio_bus *
+create_mdio_bus(const void *fdt, int mdio_node)
 {
 
 	if (fdt_node_check_compatible(fdt, mdio_node,
@@ -271,33 +266,33 @@ create_mdio_device(const void *fdt, int mdio_node)
 }
 
 static int
-find_mdio_device(const void *fdt, int mdio_node,
-    struct fdt_phy_device *phy_dev)
+find_mdio_bus(const void *fdt, int mdio_node,
+    struct phy_device *phy_dev)
 {
-	struct mdio_device *mdio_dev = NULL;
+	struct mdio_bus *mdio_bus = NULL;
 
-	SLIST_FOREACH(mdio_dev, &mdio.instances, next) {
-		if (mdio_dev->node == mdio_node) {
+	SLIST_FOREACH(mdio_bus, &mdio.instances, next) {
+		if (mdio_bus->node == mdio_node) {
 			break;
 		}
 	}
 
-	if (mdio_dev == NULL) {
-		mdio_dev = create_mdio_device(fdt, mdio_node);
+	if (mdio_bus == NULL) {
+		mdio_bus = create_mdio_bus(fdt, mdio_node);
 	}
 
-	if (mdio_dev == NULL) {
+	if (mdio_bus == NULL) {
 		return (ENXIO);
 	}
 
-	phy_dev->mdio_dev = &mdio_dev->base;
+	phy_dev->mdio.bus = mdio_bus;
 	return (0);
 }
 
-static struct fdt_phy_device *
+static struct phy_device *
 phy_obtain(const void *fdt, int mdio_node, int phy)
 {
-	struct fdt_phy_device *phy_dev;
+	struct phy_device *phy_dev;
 	int err;
 
 	phy_dev = malloc(sizeof(*phy_dev), M_TEMP, M_WAITOK | M_ZERO);
@@ -305,9 +300,9 @@ phy_obtain(const void *fdt, int mdio_node, int phy)
 		return (NULL);
 	}
 
-	phy_dev->phy = phy;
+	phy_dev->mdio.addr = phy;
 	MDIO_LOCK();
-	err = find_mdio_device(fdt, mdio_node, phy_dev);
+	err = find_mdio_bus(fdt, mdio_node, phy_dev);
 	MDIO_UNLOCK();
 
 	if (err != 0) {
@@ -318,43 +313,25 @@ phy_obtain(const void *fdt, int mdio_node, int phy)
 	return (phy_dev);
 }
 
-struct fdt_phy_device *
-fdt_phy_obtain(int device_node)
+struct phy_device *
+of_phy_find_device(struct device_node *dn)
 {
 	const void *fdt;
-	const fdt32_t *phandle;
 	const fdt32_t *phy;
 	int len;
-	int node;
+	int mdio_node;
 
 	fdt = bsp_fdt_get();
 
-	phandle = fdt_getprop(fdt, device_node, "phy-handle", &len);
-	if (phandle == NULL || len != sizeof(*phandle)) {
-		return (NULL);
-	}
-
-	node = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*phandle));
-	if (node < 0) {
-		return (NULL);
-	}
-
-	phy = fdt_getprop(fdt, node, "reg", &len);
+	phy = fdt_getprop(fdt, dn->offset, "reg", &len);
 	if (phy == NULL || len != sizeof(*phy)) {
 		return (NULL);
 	}
 
-	node = fdt_parent_offset(fdt, node);
-	if (node < 0) {
+	mdio_node = fdt_parent_offset(fdt, dn->offset);
+	if (mdio_node < 0) {
 		return (NULL);
 	}
 
-	return (phy_obtain(fdt, node, (int)fdt32_to_cpu(*phy)));
-}
-
-void
-fdt_phy_release(struct fdt_phy_device *phy_dev)
-{
-
-	free(phy_dev, M_TEMP);
+	return (phy_obtain(fdt, mdio_node, (int)fdt32_to_cpu(*phy)));
 }
diff --git a/rtemsbsd/sys/powerpc/fman_muram.c b/rtemsbsd/sys/powerpc/fman_muram.c
index c4a8e8de..51e4307f 100644
--- a/rtemsbsd/sys/powerpc/fman_muram.c
+++ b/rtemsbsd/sys/powerpc/fman_muram.c
@@ -88,7 +88,7 @@ fman_muram_offset_to_vbase(struct muram_info *muram, unsigned long offset)
 	return (offset + muram->base);
 }
 
-int
+unsigned long
 fman_muram_alloc(struct muram_info *muram, size_t size)
 {
 	void *p;