fs_enet: Be an of_platform device when CONFIG_PPC_CPM_NEW_BINDING is set.

The existing OF glue code was crufty and broken. Rather than fix it, it will be removed, and the ethernet driver now talks to the device tree directly. The old, non-CONFIG_PPC_CPM_NEW_BINDING code can go away once CPM platforms are dropped from arch/ppc (which will hopefully be soon), and existing arch/powerpc boards that I wasn't able to test on for this patchset get converted (which should be even sooner). Signed-off-by: Scott Wood <scottwood@freescale.com> Signed-off-by: Jeff Garzik <jeff@garzik.org>

fs_enet: Be an of_platform device when CONFIG_PPC_CPM_NEW_BINDING is set.
The existing OF glue code was crufty and broken. Rather than fix it, it will be removed, and the ethernet driver now talks to the device tree directly. The old, non-CONFIG_PPC_CPM_NEW_BINDING code can go away once CPM platforms are dropped from arch/ppc (which will hopefully be soon), and existing arch/powerpc boards that I wasn't able to test on for this patchset get converted (which should be even sooner). Signed-off-by: Scott Wood <scottwood@freescale.com> Signed-off-by: Jeff Garzik <jeff@garzik.org>
Scott Wood · David S. Miller
1 parent 0d0d9c150c
Showing 9 changed files with 714 additions and 178 deletions Side-by-side Diff
drivers/net/fs_enet/Kconfig
drivers/net/fs_enet/fs_enet-main.c
drivers/net/fs_enet/fs_enet.h
drivers/net/fs_enet/mac-fcc.c
drivers/net/fs_enet/mac-fec.c
drivers/net/fs_enet/mac-scc.c
drivers/net/fs_enet/mii-bitbang.c
drivers/net/fs_enet/mii-fec.c
include/linux/fs_enet_pd.h
@@ -11,6 +11,7 @@
 config FS_ENET_HAS_FCC
 	bool "Chip has an FCC usable for ethernet"
 	depends on FS_ENET && CPM2
+	select MDIO_BITBANG
 	default y
  
 config FS_ENET_HAS_FEC
@@ -42,12 +42,18 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <asm/of_platform.h>
+#endif
+
 #include "fs_enet.h"
  
 /*************************************************/
  
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
 static char version[] __devinitdata =
     DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
+#endif
  
 MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
 MODULE_DESCRIPTION("Freescale Ethernet Driver");
@@ -948,6 +954,7 @@
 extern int fs_mii_connect(struct net_device *dev);
 extern void fs_mii_disconnect(struct net_device *dev);
  
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
 static struct net_device *fs_init_instance(struct device *dev,
 		struct fs_platform_info *fpi)
 {
@@ -1129,6 +1136,7 @@
  
 	return 0;
 }
+#endif
  
 /**************************************************************************************/
  
  
  
  
  
@@ -1137,35 +1145,250 @@
  
 static int setup_immap(void)
 {
-	phys_addr_t paddr = 0;
-	unsigned long size = 0;
-
 #ifdef CONFIG_CPM1
-	paddr = IMAP_ADDR;
-	size = 0x10000;	/* map 64K */
+	fs_enet_immap = ioremap(IMAP_ADDR, 0x4000);
+	WARN_ON(!fs_enet_immap);
+#elif defined(CONFIG_CPM2)
+	fs_enet_immap = cpm2_immr;
 #endif
  
-#ifdef CONFIG_CPM2
-	paddr = CPM_MAP_ADDR;
-	size = 0x40000;	/* map 256 K */
-#endif
-	fs_enet_immap = ioremap(paddr, size);
-	if (fs_enet_immap == NULL)
-		return -EBADF;	/* XXX ahem; maybe just BUG_ON? */
-
 	return 0;
 }
  
 static void cleanup_immap(void)
 {
-	if (fs_enet_immap != NULL) {
-		iounmap(fs_enet_immap);
-		fs_enet_immap = NULL;
-	}
+#if defined(CONFIG_CPM1)
+	iounmap(fs_enet_immap);
+#endif
 }
  
 /**************************************************************************************/
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+static int __devinit find_phy(struct device_node *np,
+                              struct fs_platform_info *fpi)
+{
+	struct device_node *phynode, *mdionode;
+	struct resource res;
+	int ret = 0, len;
+
+	const u32 *data = of_get_property(np, "phy-handle", &len);
+	if (!data || len != 4)
+		return -EINVAL;
+
+	phynode = of_find_node_by_phandle(*data);
+	if (!phynode)
+		return -EINVAL;
+
+	mdionode = of_get_parent(phynode);
+	if (!mdionode)
+		goto out_put_phy;
+
+	ret = of_address_to_resource(mdionode, 0, &res);
+	if (ret)
+		goto out_put_mdio;
+
+	data = of_get_property(phynode, "reg", &len);
+	if (!data || len != 4)
+		goto out_put_mdio;
+
+	snprintf(fpi->bus_id, 16, PHY_ID_FMT, res.start, *data);
+
+out_put_mdio:
+	of_node_put(mdionode);
+out_put_phy:
+	of_node_put(phynode);
+	return ret;
+}
+
+#ifdef CONFIG_FS_ENET_HAS_FEC
+#define IS_FEC(match) ((match)->data == &fs_fec_ops)
+#else
+#define IS_FEC(match) 0
+#endif
+
+static int __devinit fs_enet_probe(struct of_device *ofdev,
+                                   const struct of_device_id *match)
+{
+	struct net_device *ndev;
+	struct fs_enet_private *fep;
+	struct fs_platform_info *fpi;
+	const u32 *data;
+	const u8 *mac_addr;
+	int privsize, len, ret = -ENODEV;
+
+	fpi = kzalloc(sizeof(*fpi), GFP_KERNEL);
+	if (!fpi)
+		return -ENOMEM;
+
+	if (!IS_FEC(match)) {
+		data = of_get_property(ofdev->node, "fsl,cpm-command", &len);
+		if (!data || len != 4)
+			goto out_free_fpi;
+
+		fpi->cp_command = *data;
+	}
+
+	fpi->rx_ring = 32;
+	fpi->tx_ring = 32;
+	fpi->rx_copybreak = 240;
+	fpi->use_napi = 0;
+	fpi->napi_weight = 17;
+
+	ret = find_phy(ofdev->node, fpi);
+	if (ret)
+		goto out_free_fpi;
+
+	privsize = sizeof(*fep) +
+	           sizeof(struct sk_buff **) *
+	           (fpi->rx_ring + fpi->tx_ring);
+
+	ndev = alloc_etherdev(privsize);
+	if (!ndev) {
+		ret = -ENOMEM;
+		goto out_free_fpi;
+	}
+
+	SET_MODULE_OWNER(ndev);
+	dev_set_drvdata(&ofdev->dev, ndev);
+
+	fep = netdev_priv(ndev);
+	fep->dev = &ofdev->dev;
+	fep->fpi = fpi;
+	fep->ops = match->data;
+
+	ret = fep->ops->setup_data(ndev);
+	if (ret)
+		goto out_free_dev;
+
+	fep->rx_skbuff = (struct sk_buff **)&fep[1];
+	fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
+
+	spin_lock_init(&fep->lock);
+	spin_lock_init(&fep->tx_lock);
+
+	mac_addr = of_get_mac_address(ofdev->node);
+	if (mac_addr)
+		memcpy(ndev->dev_addr, mac_addr, 6);
+
+	ret = fep->ops->allocate_bd(ndev);
+	if (ret)
+		goto out_cleanup_data;
+
+	fep->rx_bd_base = fep->ring_base;
+	fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
+
+	fep->tx_ring = fpi->tx_ring;
+	fep->rx_ring = fpi->rx_ring;
+
+	ndev->open = fs_enet_open;
+	ndev->hard_start_xmit = fs_enet_start_xmit;
+	ndev->tx_timeout = fs_timeout;
+	ndev->watchdog_timeo = 2 * HZ;
+	ndev->stop = fs_enet_close;
+	ndev->get_stats = fs_enet_get_stats;
+	ndev->set_multicast_list = fs_set_multicast_list;
+	if (fpi->use_napi) {
+		ndev->poll = fs_enet_rx_napi;
+		ndev->weight = fpi->napi_weight;
+	}
+	ndev->ethtool_ops = &fs_ethtool_ops;
+	ndev->do_ioctl = fs_ioctl;
+
+	init_timer(&fep->phy_timer_list);
+
+	netif_carrier_off(ndev);
+
+	ret = register_netdev(ndev);
+	if (ret)
+		goto out_free_bd;
+
+	printk(KERN_INFO "%s: fs_enet: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	       ndev->name,
+	       ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
+	       ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
+
+	return 0;
+
+out_free_bd:
+	fep->ops->free_bd(ndev);
+out_cleanup_data:
+	fep->ops->cleanup_data(ndev);
+out_free_dev:
+	free_netdev(ndev);
+	dev_set_drvdata(&ofdev->dev, NULL);
+out_free_fpi:
+	kfree(fpi);
+	return ret;
+}
+
+static int fs_enet_remove(struct of_device *ofdev)
+{
+	struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
+	struct fs_enet_private *fep = netdev_priv(ndev);
+
+	unregister_netdev(ndev);
+
+	fep->ops->free_bd(ndev);
+	fep->ops->cleanup_data(ndev);
+	dev_set_drvdata(fep->dev, NULL);
+
+	free_netdev(ndev);
+	return 0;
+}
+
+static struct of_device_id fs_enet_match[] = {
+#ifdef CONFIG_FS_ENET_HAS_SCC
+	{
+		.compatible = "fsl,cpm1-scc-enet",
+		.data = (void *)&fs_scc_ops,
+	},
+#endif
+#ifdef CONFIG_FS_ENET_HAS_FCC
+	{
+		.compatible = "fsl,cpm2-fcc-enet",
+		.data = (void *)&fs_fcc_ops,
+	},
+#endif
+#ifdef CONFIG_FS_ENET_HAS_FEC
+	{
+		.compatible = "fsl,pq1-fec-enet",
+		.data = (void *)&fs_fec_ops,
+	},
+#endif
+	{}
+};
+
+static struct of_platform_driver fs_enet_driver = {
+	.name	= "fs_enet",
+	.match_table = fs_enet_match,
+	.probe = fs_enet_probe,
+	.remove = fs_enet_remove,
+};
+
+static int __init fs_init(void)
+{
+	int r = setup_immap();
+	if (r != 0)
+		return r;
+
+	r = of_register_platform_driver(&fs_enet_driver);
+	if (r != 0)
+		goto out;
+
+	return 0;
+
+out:
+	cleanup_immap();
+	return r;
+}
+
+static void __exit fs_cleanup(void)
+{
+	of_unregister_platform_driver(&fs_enet_driver);
+	cleanup_immap();
+}
+#else
 static int __devinit fs_enet_probe(struct device *dev)
 {
 	struct net_device *ndev;
@@ -1279,6 +1502,7 @@
 	driver_unregister(&fs_enet_scc_driver);
 	cleanup_immap();
 }
+#endif
  
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void fs_enet_netpoll(struct net_device *dev)
@@ -24,19 +24,6 @@
 #include <asm/cpm2.h>
 #endif
  
-/* This is used to operate with pins.
-  Note that the actual port size may
-    be different; cpm(s) handle it OK  */
-struct bb_info {
-	u8 mdio_dat_msk;
-	u8 mdio_dir_msk;
-	u8 *mdio_dir;
-	u8 *mdio_dat;
-	u8 mdc_msk;
-	u8 *mdc_dat;
-	int delay;
-};
-
 /* hw driver ops */
 struct fs_ops {
 	int (*setup_data)(struct net_device *dev);
  
@@ -85,48 +72,12 @@
 #define ENET_RX_ALIGN  16
 #define ENET_RX_FRSIZE L1_CACHE_ALIGN(PKT_MAXBUF_SIZE + ENET_RX_ALIGN - 1)
  
-struct fs_enet_mii_bus {
-	struct list_head list;
-	spinlock_t mii_lock;
-	const struct fs_mii_bus_info *bus_info;
-	int refs;
-	u32 usage_map;
-
-	int (*mii_read)(struct fs_enet_mii_bus *bus,
-			int phy_id, int location);
-
-	void (*mii_write)(struct fs_enet_mii_bus *bus,
-			int phy_id, int location, int value);
-
-	union {
-		struct {
-			unsigned int mii_speed;
-			void *fecp;
-		} fec;
-
-		struct {
-			/* note that the actual port size may */
-			/* be different; cpm(s) handle it OK  */
-			u8 mdio_msk;
-			u8 *mdio_dir;
-			u8 *mdio_dat;
-			u8 mdc_msk;
-			u8 *mdc_dir;
-			u8 *mdc_dat;
-		} bitbang;
-
-		struct {
-			u16 lpa;
-		} fixed;
-	};
-};
-
 struct fs_enet_private {
 	struct napi_struct napi;
 	struct device *dev;	/* pointer back to the device (must be initialized first) */
 	spinlock_t lock;	/* during all ops except TX pckt processing */
 	spinlock_t tx_lock;	/* during fs_start_xmit and fs_tx         */
-	const struct fs_platform_info *fpi;
+	struct fs_platform_info *fpi;
 	const struct fs_ops *ops;
 	int rx_ring, tx_ring;
 	dma_addr_t ring_mem_addr;
@@ -145,7 +96,6 @@
 	u32 msg_enable;
 	struct mii_if_info mii_if;
 	unsigned int last_mii_status;
-	struct fs_enet_mii_bus *mii_bus;
 	int interrupt;
  
 	struct phy_device *phydev;
  
  
@@ -187,9 +137,10 @@
 };
  
 /***************************************************************************/
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
 int fs_enet_mdio_bb_init(void);
-int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
 int fs_enet_mdio_fec_init(void);
+#endif
  
 void fs_init_bds(struct net_device *dev);
 void fs_cleanup_bds(struct net_device *dev);
@@ -42,6 +42,10 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <asm/of_device.h>
+#endif
+
 #include "fs_enet.h"
  
 /*************************************************/
  
  
  
  
  
@@ -74,33 +78,64 @@
  
 #define MAX_CR_CMD_LOOPS	10000
  
-static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 mcn, u32 op)
+static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 op)
 {
 	const struct fs_platform_info *fpi = fep->fpi;
 	cpm2_map_t *immap = fs_enet_immap;
 	cpm_cpm2_t *cpmp = &immap->im_cpm;
-	u32 v;
 	int i;
  
-	/* Currently I don't know what feature call will look like. But
-	   I guess there'd be something like do_cpm_cmd() which will require page & sblock */
-	v = mk_cr_cmd(fpi->cp_page, fpi->cp_block, mcn, op);
-	W32(cpmp, cp_cpcr, v | CPM_CR_FLG);
+	W32(cpmp, cp_cpcr, fpi->cp_command | op | CPM_CR_FLG);
 	for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
 		if ((R32(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
-			break;
+			return 0;
  
-	if (i >= MAX_CR_CMD_LOOPS) {
-		printk(KERN_ERR "%s(): Not able to issue CPM command\n",
-		       __FUNCTION__);
-		return 1;
-	}
-
-	return 0;
+	printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+	       __FUNCTION__);
+	return 1;
 }
  
 static int do_pd_setup(struct fs_enet_private *fep)
 {
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+	struct of_device *ofdev = to_of_device(fep->dev);
+	struct fs_platform_info *fpi = fep->fpi;
+	int ret = -EINVAL;
+
+	fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+	if (fep->interrupt == NO_IRQ)
+		goto out;
+
+	fep->fcc.fccp = of_iomap(ofdev->node, 0);
+	if (!fep->fcc.fccp)
+		goto out;
+
+	fep->fcc.ep = of_iomap(ofdev->node, 1);
+	if (!fep->fcc.ep)
+		goto out_fccp;
+
+	fep->fcc.fcccp = of_iomap(ofdev->node, 2);
+	if (!fep->fcc.fcccp)
+		goto out_ep;
+
+	fep->fcc.mem = (void *)cpm_dpalloc(128, 8);
+	fpi->dpram_offset = (u32)cpm2_immr;
+	if (IS_ERR_VALUE(fpi->dpram_offset)) {
+		ret = fpi->dpram_offset;
+		goto out_fcccp;
+	}
+
+	return 0;
+
+out_fcccp:
+	iounmap(fep->fcc.fcccp);
+out_ep:
+	iounmap(fep->fcc.ep);
+out_fccp:
+	iounmap(fep->fcc.fccp);
+out:
+	return ret;
+#else
 	struct platform_device *pdev = to_platform_device(fep->dev);
 	struct resource *r;
  
@@ -138,6 +173,7 @@
 		return -EINVAL;
  
 	return 0;
+#endif
 }
  
 #define FCC_NAPI_RX_EVENT_MSK	(FCC_ENET_RXF | FCC_ENET_RXB)
  
  
@@ -148,11 +184,17 @@
 static int setup_data(struct net_device *dev)
 {
 	struct fs_enet_private *fep = netdev_priv(dev);
-	const struct fs_platform_info *fpi = fep->fpi;
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
+	struct fs_platform_info *fpi = fep->fpi;
  
+	fpi->cp_command = (fpi->cp_page << 26) |
+	                  (fpi->cp_block << 21) |
+	                  (12 << 6);
+
 	fep->fcc.idx = fs_get_fcc_index(fpi->fs_no);
 	if ((unsigned int)fep->fcc.idx >= 3)	/* max 3 FCCs */
 		return -EINVAL;
+#endif
  
 	if (do_pd_setup(fep) != 0)
 		return -EINVAL;
@@ -226,7 +268,7 @@
 	W16(ep, fen_taddrh, taddrh);
 	W16(ep, fen_taddrm, taddrm);
 	W16(ep, fen_taddrl, taddrl);
-	fcc_cr_cmd(fep, 0x0C, CPM_CR_SET_GADDR);
+	fcc_cr_cmd(fep, CPM_CR_SET_GADDR);
 }
  
 static void set_multicast_finish(struct net_device *dev)
@@ -281,7 +323,7 @@
  
 	/* clear everything (slow & steady does it) */
 	for (i = 0; i < sizeof(*ep); i++)
-		out_8((char *)ep + i, 0);
+		out_8((u8 __iomem *)ep + i, 0);
  
 	/* get physical address */
 	rx_bd_base_phys = fep->ring_mem_addr;
@@ -397,7 +439,7 @@
 			S8(fcccp, fcc_gfemr, 0x20);
 	}
  
-	fcc_cr_cmd(fep, 0x0c, CPM_CR_INIT_TRX);
+	fcc_cr_cmd(fep, CPM_CR_INIT_TRX);
  
 	/* clear events */
 	W16(fccp, fcc_fcce, 0xffff);
  
  
  
  
@@ -515,23 +557,22 @@
 {
 	struct fs_enet_private *fep = netdev_priv(dev);
  
-	if (*sizep < sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t))
+	if (*sizep < sizeof(fcc_t) + sizeof(fcc_enet_t) + 1)
 		return -EINVAL;
  
 	memcpy_fromio(p, fep->fcc.fccp, sizeof(fcc_t));
 	p = (char *)p + sizeof(fcc_t);
  
-	memcpy_fromio(p, fep->fcc.fcccp, sizeof(fcc_c_t));
-	p = (char *)p + sizeof(fcc_c_t);
-
 	memcpy_fromio(p, fep->fcc.ep, sizeof(fcc_enet_t));
+	p = (char *)p + sizeof(fcc_enet_t);
  
+	memcpy_fromio(p, fep->fcc.fcccp, 1);
 	return 0;
 }
  
 int get_regs_len(struct net_device *dev)
 {
-	return sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t);
+	return sizeof(fcc_t) + sizeof(fcc_enet_t) + 1;
 }
  
 /* Some transmit errors cause the transmitter to shut
@@ -551,7 +592,7 @@
 	udelay(10);
 	S32(fccp, fcc_gfmr, FCC_GFMR_ENT);
  
-	fcc_cr_cmd(fep, 0x0C, CPM_CR_RESTART_TX);
+	fcc_cr_cmd(fep, CPM_CR_RESTART_TX);
 }
  
 /*************************************************************************/
@@ -43,6 +43,10 @@
 #include <asm/commproc.h>
 #endif
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <asm/of_device.h>
+#endif
+
 #include "fs_enet.h"
 #include "fec.h"
  
@@ -95,6 +99,19 @@
  
 static int do_pd_setup(struct fs_enet_private *fep)
 {
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+	struct of_device *ofdev = to_of_device(fep->dev);
+
+	fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+	if (fep->interrupt == NO_IRQ)
+		return -EINVAL;
+
+	fep->fec.fecp = of_iomap(ofdev->node, 0);
+	if (!fep->fcc.fccp)
+		return -EINVAL;
+
+	return 0;
+#else
 	struct platform_device *pdev = to_platform_device(fep->dev);
 	struct resource	*r;
  
@@ -110,7 +127,7 @@
 		return -EINVAL;
  
 	return 0;
-
+#endif
 }
  
 #define FEC_NAPI_RX_EVENT_MSK	(FEC_ENET_RXF | FEC_ENET_RXB)
@@ -43,6 +43,10 @@
 #include <asm/commproc.h>
 #endif
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <asm/of_platform.h>
+#endif
+
 #include "fs_enet.h"
  
 /*************************************************/
  
  
  
  
@@ -89,27 +93,38 @@
  
 static inline int scc_cr_cmd(struct fs_enet_private *fep, u32 op)
 {
-	cpm8xx_t *cpmp = &((immap_t *)fs_enet_immap)->im_cpm;
-	u32 v, ch;
-	int i = 0;
+	const struct fs_platform_info *fpi = fep->fpi;
+	int i;
  
-	ch = fep->scc.idx << 2;
-	v = mk_cr_cmd(ch, op);
-	W16(cpmp, cp_cpcr, v | CPM_CR_FLG);
+	W16(cpmp, cp_cpcr, fpi->cp_command | CPM_CR_FLG | (op << 8));
 	for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
 		if ((R16(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
-			break;
+			return 0;
  
-	if (i >= MAX_CR_CMD_LOOPS) {
-		printk(KERN_ERR "%s(): Not able to issue CPM command\n",
-			__FUNCTION__);
-		return 1;
-	}
-	return 0;
+	printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+		__FUNCTION__);
+	return 1;
 }
  
 static int do_pd_setup(struct fs_enet_private *fep)
 {
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+	struct of_device *ofdev = to_of_device(fep->dev);
+
+	fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+	if (fep->interrupt == NO_IRQ)
+		return -EINVAL;
+
+	fep->scc.sccp = of_iomap(ofdev->node, 0);
+	if (!fep->scc.sccp)
+		return -EINVAL;
+
+	fep->scc.ep = of_iomap(ofdev->node, 1);
+	if (!fep->scc.ep) {
+		iounmap(fep->scc.sccp);
+		return -EINVAL;
+	}
+#else
 	struct platform_device *pdev = to_platform_device(fep->dev);
 	struct resource *r;
  
@@ -129,6 +144,7 @@
  
 	if (fep->scc.ep == NULL)
 		return -EINVAL;
+#endif
  
 	return 0;
 }
  
  
  
@@ -141,12 +157,17 @@
 static int setup_data(struct net_device *dev)
 {
 	struct fs_enet_private *fep = netdev_priv(dev);
-	const struct fs_platform_info *fpi = fep->fpi;
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+	struct fs_platform_info *fpi = fep->fpi;
+
 	fep->scc.idx = fs_get_scc_index(fpi->fs_no);
-	if ((unsigned int)fep->fcc.idx > 4)	/* max 4 SCCs */
+	if ((unsigned int)fep->fcc.idx >= 4) /* max 4 SCCs */
 		return -EINVAL;
  
+	fpi->cp_command = fep->fcc.idx << 6;
+#endif
+
 	do_pd_setup(fep);
  
 	fep->scc.hthi = 0;
@@ -154,7 +175,7 @@
  
 	fep->ev_napi_rx = SCC_NAPI_RX_EVENT_MSK;
 	fep->ev_rx = SCC_RX_EVENT;
-	fep->ev_tx = SCC_TX_EVENT;
+	fep->ev_tx = SCC_TX_EVENT | SCCE_ENET_TXE;
 	fep->ev_err = SCC_ERR_EVENT_MSK;
  
 	return 0;
@@ -13,11 +13,6 @@
  */
  
 #include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/ptrace.h>
-#include <linux/errno.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
@@ -25,86 +20,77 @@
 #include <linux/delay.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/spinlock.h>
 #include <linux/mii.h>
 #include <linux/ethtool.h>
 #include <linux/bitops.h>
 #include <linux/platform_device.h>
  
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-#include <asm/uaccess.h>
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <linux/of_platform.h>
+#endif
  
 #include "fs_enet.h"
  
-static int bitbang_prep_bit(u8 **datp, u8 *mskp,
-		struct fs_mii_bit *mii_bit)
-{
-	void *dat;
-	int adv;
-	u8 msk;
+struct bb_info {
+	__be32 __iomem *dir;
+	__be32 __iomem *dat;
+	u32 mdio_msk;
+	u32 mdc_msk;
+	int delay;
+};
  
-	dat = (void*) mii_bit->offset;
-
-	adv = mii_bit->bit >> 3;
-	dat = (char *)dat + adv;
-
-	msk = 1 << (7 - (mii_bit->bit & 7));
-
-	*datp = dat;
-	*mskp = msk;
-
-	return 0;
-}
-
-static inline void bb_set(u8 *p, u8 m)
+/* FIXME: If any other users of GPIO crop up, then these will have to
+ * have some sort of global synchronization to avoid races with other
+ * pins on the same port.  The ideal solution would probably be to
+ * bind the ports to a GPIO driver, and have this be a client of it.
+ */
+static inline void bb_set(u32 __iomem *p, u32 m)
 {
-	out_8(p, in_8(p) | m);
+	out_be32(p, in_be32(p) | m);
 }
  
-static inline void bb_clr(u8 *p, u8 m)
+static inline void bb_clr(u32 __iomem *p, u32 m)
 {
-	out_8(p, in_8(p) & ~m);
+	out_be32(p, in_be32(p) & ~m);
 }
  
-static inline int bb_read(u8 *p, u8 m)
+static inline int bb_read(u32 __iomem *p, u32 m)
 {
-	return (in_8(p) & m) != 0;
+	return (in_be32(p) & m) != 0;
 }
  
 static inline void mdio_active(struct bb_info *bitbang)
 {
-	bb_set(bitbang->mdio_dir, bitbang->mdio_dir_msk);
+	bb_set(bitbang->dir, bitbang->mdio_msk);
 }
  
-static inline void mdio_tristate(struct bb_info *bitbang )
+static inline void mdio_tristate(struct bb_info *bitbang)
 {
-	bb_clr(bitbang->mdio_dir, bitbang->mdio_dir_msk);
+	bb_clr(bitbang->dir, bitbang->mdio_msk);
 }
  
-static inline int mdio_read(struct bb_info *bitbang )
+static inline int mdio_read(struct bb_info *bitbang)
 {
-	return bb_read(bitbang->mdio_dat, bitbang->mdio_dat_msk);
+	return bb_read(bitbang->dat, bitbang->mdio_msk);
 }
  
-static inline void mdio(struct bb_info *bitbang , int what)
+static inline void mdio(struct bb_info *bitbang, int what)
 {
 	if (what)
-		bb_set(bitbang->mdio_dat, bitbang->mdio_dat_msk);
+		bb_set(bitbang->dat, bitbang->mdio_msk);
 	else
-		bb_clr(bitbang->mdio_dat, bitbang->mdio_dat_msk);
+		bb_clr(bitbang->dat, bitbang->mdio_msk);
 }
  
-static inline void mdc(struct bb_info *bitbang , int what)
+static inline void mdc(struct bb_info *bitbang, int what)
 {
 	if (what)
-		bb_set(bitbang->mdc_dat, bitbang->mdc_msk);
+		bb_set(bitbang->dat, bitbang->mdc_msk);
 	else
-		bb_clr(bitbang->mdc_dat, bitbang->mdc_msk);
+		bb_clr(bitbang->dat, bitbang->mdc_msk);
 }
  
-static inline void mii_delay(struct bb_info *bitbang )
+static inline void mii_delay(struct bb_info *bitbang)
 {
 	udelay(bitbang->delay);
 }
  
  
  
  
  
@@ -280,29 +266,178 @@
 	return 0;
 }
  
-static int fs_mii_bitbang_init(struct bb_info *bitbang, struct fs_mii_bb_platform_info* fmpi)
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+static int __devinit fs_mii_bitbang_init(struct mii_bus *bus,
+                                         struct device_node *np)
 {
-	int r;
+	struct resource res;
+	const u32 *data;
+	int mdio_pin, mdc_pin, len;
+	struct bb_info *bitbang = bus->priv;
  
-	bitbang->delay = fmpi->delay;
+	int ret = of_address_to_resource(np, 0, &res);
+	if (ret)
+		return ret;
  
-	r = bitbang_prep_bit(&bitbang->mdio_dir,
-			 &bitbang->mdio_dir_msk,
-			 &fmpi->mdio_dir);
-	if (r != 0)
-		return r;
+	if (res.end - res.start < 13)
+		return -ENODEV;
  
-	r = bitbang_prep_bit(&bitbang->mdio_dat,
-			 &bitbang->mdio_dat_msk,
-			 &fmpi->mdio_dat);
-	if (r != 0)
-		return r;
+	/* This should really encode the pin number as well, but all
+	 * we get is an int, and the odds of multiple bitbang mdio buses
+	 * is low enough that it's not worth going too crazy.
+	 */
+	bus->id = res.start;
  
-	r = bitbang_prep_bit(&bitbang->mdc_dat,
-			 &bitbang->mdc_msk,
-			 &fmpi->mdc_dat);
-	if (r != 0)
-		return r;
+	data = of_get_property(np, "fsl,mdio-pin", &len);
+	if (!data || len != 4)
+		return -ENODEV;
+	mdio_pin = *data;
+
+	data = of_get_property(np, "fsl,mdc-pin", &len);
+	if (!data || len != 4)
+		return -ENODEV;
+	mdc_pin = *data;
+
+	bitbang->dir = ioremap(res.start, res.end - res.start + 1);
+	if (!bitbang->dir)
+		return -ENOMEM;
+
+	bitbang->dat = bitbang->dir + 4;
+	bitbang->mdio_msk = 1 << (31 - mdio_pin);
+	bitbang->mdc_msk = 1 << (31 - mdc_pin);
+	bitbang->delay = 1; /* 1 us between operations */
+
+	return 0;
+}
+
+static void __devinit add_phy(struct mii_bus *bus, struct device_node *np)
+{
+	const u32 *data;
+	int len, id, irq;
+
+	data = of_get_property(np, "reg", &len);
+	if (!data || len != 4)
+		return;
+
+	id = *data;
+	bus->phy_mask &= ~(1 << id);
+
+	irq = of_irq_to_resource(np, 0, NULL);
+	if (irq != NO_IRQ)
+		bus->irq[id] = irq;
+}
+
+static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+                                        const struct of_device_id *match)
+{
+	struct device_node *np = NULL;
+	struct mii_bus *new_bus;
+	struct bb_info *bitbang;
+	int ret = -ENOMEM;
+	int i;
+
+	new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL);
+	if (!new_bus)
+		goto out;
+
+	bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL);
+	if (!bitbang)
+		goto out_free_bus;
+
+	new_bus->priv = bitbang;
+	new_bus->name = "CPM2 Bitbanged MII",
+	new_bus->read = &fs_enet_mii_bb_read,
+	new_bus->write = &fs_enet_mii_bb_write,
+	new_bus->reset = &fs_enet_mii_bb_reset,
+
+	ret = fs_mii_bitbang_init(new_bus, ofdev->node);
+	if (ret)
+		goto out_free_bitbang;
+
+	new_bus->phy_mask = ~0;
+	new_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
+	if (!new_bus->irq)
+		goto out_unmap_regs;
+
+	for (i = 0; i < PHY_MAX_ADDR; i++)
+		new_bus->irq[i] = -1;
+
+	while ((np = of_get_next_child(ofdev->node, np)))
+		if (!strcmp(np->type, "ethernet-phy"))
+			add_phy(new_bus, np);
+
+	new_bus->dev = &ofdev->dev;
+	dev_set_drvdata(&ofdev->dev, new_bus);
+
+	ret = mdiobus_register(new_bus);
+	if (ret)
+		goto out_free_irqs;
+
+	return 0;
+
+out_free_irqs:
+	dev_set_drvdata(&ofdev->dev, NULL);
+	kfree(new_bus->irq);
+out_unmap_regs:
+	iounmap(bitbang->dir);
+out_free_bitbang:
+	kfree(bitbang);
+out_free_bus:
+	kfree(new_bus);
+out:
+	return ret;
+}
+
+static int fs_enet_mdio_remove(struct of_device *ofdev)
+{
+	struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
+	struct bb_info *bitbang = bus->priv;
+
+	mdiobus_unregister(bus);
+	dev_set_drvdata(&ofdev->dev, NULL);
+	kfree(bus->irq);
+	iounmap(bitbang->dir);
+	kfree(bitbang);
+	kfree(bus);
+
+	return 0;
+}
+
+static struct of_device_id fs_enet_mdio_bb_match[] = {
+	{
+		.compatible = "fsl,cpm2-mdio-bitbang",
+	},
+	{},
+};
+
+static struct of_platform_driver fs_enet_bb_mdio_driver = {
+	.name = "fsl-bb-mdio",
+	.match_table = fs_enet_mdio_bb_match,
+	.probe = fs_enet_mdio_probe,
+	.remove = fs_enet_mdio_remove,
+};
+
+int fs_enet_mdio_bb_init(void)
+{
+	return of_register_platform_driver(&fs_enet_bb_mdio_driver);
+}
+
+void fs_enet_mdio_bb_exit(void)
+{
+	of_unregister_platform_driver(&fs_enet_bb_mdio_driver);
+}
+
+module_init(fs_enet_mdio_bb_init);
+module_exit(fs_enet_mdio_bb_exit);
+#else
+static int __devinit fs_mii_bitbang_init(struct bb_info *bitbang,
+                                         struct fs_mii_bb_platform_info *fmpi)
+{
+	bitbang->dir = (u32 __iomem *)fmpi->mdio_dir.offset;
+	bitbang->dat = (u32 __iomem *)fmpi->mdio_dat.offset;
+	bitbang->mdio_msk = 1U << (31 - fmpi->mdio_dat.bit);
+	bitbang->mdc_msk = 1U << (31 - fmpi->mdc_dat.bit);
+	bitbang->delay = fmpi->delay;
  
 	return 0;
 }
@@ -36,6 +36,10 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#include <asm/of_platform.h>
+#endif
+
 #include "fs_enet.h"
 #include "fec.h"
  
@@ -47,6 +51,7 @@
  
 #define FEC_MII_LOOPS	10000
  
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
 static int match_has_phy (struct device *dev, void* data)
 {
 	struct platform_device* pdev = container_of(dev, struct platform_device, dev);
@@ -90,6 +95,7 @@
  
 	return 0;
 }
+#endif
  
 static int fs_enet_fec_mii_read(struct mii_bus *bus , int phy_id, int location)
 {
@@ -145,6 +151,141 @@
 	return 0;
 }
  
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+static void __devinit add_phy(struct mii_bus *bus, struct device_node *np)
+{
+	const u32 *data;
+	int len, id, irq;
+
+	data = of_get_property(np, "reg", &len);
+	if (!data || len != 4)
+		return;
+
+	id = *data;
+	bus->phy_mask &= ~(1 << id);
+
+	irq = of_irq_to_resource(np, 0, NULL);
+	if (irq != NO_IRQ)
+		bus->irq[id] = irq;
+}
+
+static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+                                        const struct of_device_id *match)
+{
+	struct device_node *np = NULL;
+	struct resource res;
+	struct mii_bus *new_bus;
+	struct fec_info *fec;
+	int ret = -ENOMEM, i;
+
+	new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL);
+	if (!new_bus)
+		goto out;
+
+	fec = kzalloc(sizeof(struct fec_info), GFP_KERNEL);
+	if (!fec)
+		goto out_mii;
+
+	new_bus->priv = fec;
+	new_bus->name = "FEC MII Bus";
+	new_bus->read = &fs_enet_fec_mii_read;
+	new_bus->write = &fs_enet_fec_mii_write;
+	new_bus->reset = &fs_enet_fec_mii_reset;
+
+	ret = of_address_to_resource(ofdev->node, 0, &res);
+	if (ret)
+		return ret;
+
+	new_bus->id = res.start;
+
+	fec->fecp = ioremap(res.start, res.end - res.start + 1);
+	if (!fec->fecp)
+		goto out_fec;
+
+	fec->mii_speed = ((ppc_proc_freq + 4999999) / 5000000) << 1;
+
+	setbits32(&fec->fecp->fec_r_cntrl, FEC_RCNTRL_MII_MODE);
+	setbits32(&fec->fecp->fec_ecntrl, FEC_ECNTRL_PINMUX |
+	                                  FEC_ECNTRL_ETHER_EN);
+	out_be32(&fec->fecp->fec_ievent, FEC_ENET_MII);
+	out_be32(&fec->fecp->fec_mii_speed, fec->mii_speed);
+
+	new_bus->phy_mask = ~0;
+	new_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
+	if (!new_bus->irq)
+		goto out_unmap_regs;
+
+	for (i = 0; i < PHY_MAX_ADDR; i++)
+		new_bus->irq[i] = -1;
+
+	while ((np = of_get_next_child(ofdev->node, np)))
+		if (!strcmp(np->type, "ethernet-phy"))
+			add_phy(new_bus, np);
+
+	new_bus->dev = &ofdev->dev;
+	dev_set_drvdata(&ofdev->dev, new_bus);
+
+	ret = mdiobus_register(new_bus);
+	if (ret)
+		goto out_free_irqs;
+
+	return 0;
+
+out_free_irqs:
+	dev_set_drvdata(&ofdev->dev, NULL);
+	kfree(new_bus->irq);
+out_unmap_regs:
+	iounmap(fec->fecp);
+out_fec:
+	kfree(fec);
+out_mii:
+	kfree(new_bus);
+out:
+	return ret;
+}
+
+static int fs_enet_mdio_remove(struct of_device *ofdev)
+{
+	struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
+	struct fec_info *fec = bus->priv;
+
+	mdiobus_unregister(bus);
+	dev_set_drvdata(&ofdev->dev, NULL);
+	kfree(bus->irq);
+	iounmap(fec->fecp);
+	kfree(fec);
+	kfree(bus);
+
+	return 0;
+}
+
+static struct of_device_id fs_enet_mdio_fec_match[] = {
+	{
+		.compatible = "fsl,pq1-fec-mdio",
+	},
+	{},
+};
+
+static struct of_platform_driver fs_enet_fec_mdio_driver = {
+	.name = "fsl-fec-mdio",
+	.match_table = fs_enet_mdio_fec_match,
+	.probe = fs_enet_mdio_probe,
+	.remove = fs_enet_mdio_remove,
+};
+
+static int fs_enet_mdio_fec_init(void)
+{
+	return of_register_platform_driver(&fs_enet_fec_mdio_driver);
+}
+
+static void fs_enet_mdio_fec_exit(void)
+{
+	of_unregister_platform_driver(&fs_enet_fec_mdio_driver);
+}
+
+module_init(fs_enet_mdio_fec_init);
+module_exit(fs_enet_mdio_fec_exit);
+#else
 static int __devinit fs_enet_fec_mdio_probe(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
@@ -235,4 +376,5 @@
 {
 	driver_unregister(&fs_enet_fec_mdio_driver);
 }
+#endif
@@ -120,6 +120,7 @@
  
 	u32 cp_page;		/* CPM page */
 	u32 cp_block;		/* CPM sblock */
+	u32 cp_command;		/* CPM page/sblock/mcn */
  
 	u32 clk_trx;		/* some stuff for pins & mux configuration*/
 	u32 clk_rx;
  
@@ -134,7 +135,11 @@
 	u32 device_flags;
  
 	int phy_addr;		/* the phy address (-1 no phy) */
+#ifdef CONFIG_PPC_CPM_NEW_BINDING
+	char bus_id[16];
+#else
 	const char*	bus_id;
+#endif
 	int phy_irq;		/* the phy irq (if it exists)  */
  
 	const struct fs_mii_bus_info *bus_info;
...	...	@@ -11,6 +11,7 @@
11	11	config FS_ENET_HAS_FCC
12	12	bool "Chip has an FCC usable for ethernet"
13	13	depends on FS_ENET && CPM2
	14	+ select MDIO_BITBANG
14	15	default y
15	16
16	17	config FS_ENET_HAS_FEC
...	...	@@ -42,12 +42,18 @@
42	42	#include <asm/irq.h>
43	43	#include <asm/uaccess.h>
44	44
	45	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	46	+#include <asm/of_platform.h>
	47	+#endif
	48	+
45	49	#include "fs_enet.h"
46	50
47	51	/*************************************************/
48	52
	53	+#ifndef CONFIG_PPC_CPM_NEW_BINDING
49	54	static char version[] __devinitdata =
50	55	DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
	56	+#endif
51	57
52	58	MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
53	59	MODULE_DESCRIPTION("Freescale Ethernet Driver");
...	...	@@ -948,6 +954,7 @@
948	954	extern int fs_mii_connect(struct net_device *dev);
949	955	extern void fs_mii_disconnect(struct net_device *dev);
950	956
	957	+#ifndef CONFIG_PPC_CPM_NEW_BINDING
951	958	static struct net_device fs_init_instance(struct device dev,
952	959	struct fs_platform_info *fpi)
953	960	{
...	...	@@ -1129,6 +1136,7 @@
1129	1136
1130	1137	return 0;
1131	1138	}
	1139	+#endif
1132	1140
1133	1141	/**************************************************************************************/
1134	1142
1135	1143
1136	1144
1137	1145
1138	1146
...	...	@@ -1137,35 +1145,250 @@
1137	1145
1138	1146	static int setup_immap(void)
1139	1147	{
1140		- phys_addr_t paddr = 0;
1141		- unsigned long size = 0;
1142		-
1143	1148	#ifdef CONFIG_CPM1
1144		- paddr = IMAP_ADDR;
1145		- size = 0x10000; /* map 64K */
	1149	+ fs_enet_immap = ioremap(IMAP_ADDR, 0x4000);
	1150	+ WARN_ON(!fs_enet_immap);
	1151	+#elif defined(CONFIG_CPM2)
	1152	+ fs_enet_immap = cpm2_immr;
1146	1153	#endif
1147	1154
1148		-#ifdef CONFIG_CPM2
1149		- paddr = CPM_MAP_ADDR;
1150		- size = 0x40000; /* map 256 K */
1151		-#endif
1152		- fs_enet_immap = ioremap(paddr, size);
1153		- if (fs_enet_immap == NULL)
1154		- return -EBADF; /* XXX ahem; maybe just BUG_ON? */
1155		-
1156	1155	return 0;
1157	1156	}
1158	1157
1159	1158	static void cleanup_immap(void)
1160	1159	{
1161		- if (fs_enet_immap != NULL) {
1162		- iounmap(fs_enet_immap);
1163		- fs_enet_immap = NULL;
1164		- }
	1160	+#if defined(CONFIG_CPM1)
	1161	+ iounmap(fs_enet_immap);
	1162	+#endif
1165	1163	}
1166	1164
1167	1165	/**************************************************************************************/
1168	1166
	1167	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	1168	+static int __devinit find_phy(struct device_node *np,
	1169	+ struct fs_platform_info *fpi)
	1170	+{
	1171	+ struct device_node phynode, mdionode;
	1172	+ struct resource res;
	1173	+ int ret = 0, len;
	1174	+
	1175	+ const u32 *data = of_get_property(np, "phy-handle", &len);
	1176	+ if (!data \|\| len != 4)
	1177	+ return -EINVAL;
	1178	+
	1179	+ phynode = of_find_node_by_phandle(*data);
	1180	+ if (!phynode)
	1181	+ return -EINVAL;
	1182	+
	1183	+ mdionode = of_get_parent(phynode);
	1184	+ if (!mdionode)
	1185	+ goto out_put_phy;
	1186	+
	1187	+ ret = of_address_to_resource(mdionode, 0, &res);
	1188	+ if (ret)
	1189	+ goto out_put_mdio;
	1190	+
	1191	+ data = of_get_property(phynode, "reg", &len);
	1192	+ if (!data \|\| len != 4)
	1193	+ goto out_put_mdio;
	1194	+
	1195	+ snprintf(fpi->bus_id, 16, PHY_ID_FMT, res.start, *data);
	1196	+
	1197	+out_put_mdio:
	1198	+ of_node_put(mdionode);
	1199	+out_put_phy:
	1200	+ of_node_put(phynode);
	1201	+ return ret;
	1202	+}
	1203	+
	1204	+#ifdef CONFIG_FS_ENET_HAS_FEC
	1205	+#define IS_FEC(match) ((match)->data == &fs_fec_ops)
	1206	+#else
	1207	+#define IS_FEC(match) 0
	1208	+#endif
	1209	+
	1210	+static int __devinit fs_enet_probe(struct of_device *ofdev,
	1211	+ const struct of_device_id *match)
	1212	+{
	1213	+ struct net_device *ndev;
	1214	+ struct fs_enet_private *fep;
	1215	+ struct fs_platform_info *fpi;
	1216	+ const u32 *data;
	1217	+ const u8 *mac_addr;
	1218	+ int privsize, len, ret = -ENODEV;
	1219	+
	1220	+ fpi = kzalloc(sizeof(*fpi), GFP_KERNEL);
	1221	+ if (!fpi)
	1222	+ return -ENOMEM;
	1223	+
	1224	+ if (!IS_FEC(match)) {
	1225	+ data = of_get_property(ofdev->node, "fsl,cpm-command", &len);
	1226	+ if (!data \|\| len != 4)
	1227	+ goto out_free_fpi;
	1228	+
	1229	+ fpi->cp_command = *data;
	1230	+ }
	1231	+
	1232	+ fpi->rx_ring = 32;
	1233	+ fpi->tx_ring = 32;
	1234	+ fpi->rx_copybreak = 240;
	1235	+ fpi->use_napi = 0;
	1236	+ fpi->napi_weight = 17;
	1237	+
	1238	+ ret = find_phy(ofdev->node, fpi);
	1239	+ if (ret)
	1240	+ goto out_free_fpi;
	1241	+
	1242	+ privsize = sizeof(*fep) +
	1243	+ sizeof(struct sk_buff *)
	1244	+ (fpi->rx_ring + fpi->tx_ring);
	1245	+
	1246	+ ndev = alloc_etherdev(privsize);
	1247	+ if (!ndev) {
	1248	+ ret = -ENOMEM;
	1249	+ goto out_free_fpi;
	1250	+ }
	1251	+
	1252	+ SET_MODULE_OWNER(ndev);
	1253	+ dev_set_drvdata(&ofdev->dev, ndev);
	1254	+
	1255	+ fep = netdev_priv(ndev);
	1256	+ fep->dev = &ofdev->dev;
	1257	+ fep->fpi = fpi;
	1258	+ fep->ops = match->data;
	1259	+
	1260	+ ret = fep->ops->setup_data(ndev);
	1261	+ if (ret)
	1262	+ goto out_free_dev;
	1263	+
	1264	+ fep->rx_skbuff = (struct sk_buff **)&fep[1];
	1265	+ fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
	1266	+
	1267	+ spin_lock_init(&fep->lock);
	1268	+ spin_lock_init(&fep->tx_lock);
	1269	+
	1270	+ mac_addr = of_get_mac_address(ofdev->node);
	1271	+ if (mac_addr)
	1272	+ memcpy(ndev->dev_addr, mac_addr, 6);
	1273	+
	1274	+ ret = fep->ops->allocate_bd(ndev);
	1275	+ if (ret)
	1276	+ goto out_cleanup_data;
	1277	+
	1278	+ fep->rx_bd_base = fep->ring_base;
	1279	+ fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
	1280	+
	1281	+ fep->tx_ring = fpi->tx_ring;
	1282	+ fep->rx_ring = fpi->rx_ring;
	1283	+
	1284	+ ndev->open = fs_enet_open;
	1285	+ ndev->hard_start_xmit = fs_enet_start_xmit;
	1286	+ ndev->tx_timeout = fs_timeout;
	1287	+ ndev->watchdog_timeo = 2 * HZ;
	1288	+ ndev->stop = fs_enet_close;
	1289	+ ndev->get_stats = fs_enet_get_stats;
	1290	+ ndev->set_multicast_list = fs_set_multicast_list;
	1291	+ if (fpi->use_napi) {
	1292	+ ndev->poll = fs_enet_rx_napi;
	1293	+ ndev->weight = fpi->napi_weight;
	1294	+ }
	1295	+ ndev->ethtool_ops = &fs_ethtool_ops;
	1296	+ ndev->do_ioctl = fs_ioctl;
	1297	+
	1298	+ init_timer(&fep->phy_timer_list);
	1299	+
	1300	+ netif_carrier_off(ndev);
	1301	+
	1302	+ ret = register_netdev(ndev);
	1303	+ if (ret)
	1304	+ goto out_free_bd;
	1305	+
	1306	+ printk(KERN_INFO "%s: fs_enet: %02x:%02x:%02x:%02x:%02x:%02x\n",
	1307	+ ndev->name,
	1308	+ ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
	1309	+ ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
	1310	+
	1311	+ return 0;
	1312	+
	1313	+out_free_bd:
	1314	+ fep->ops->free_bd(ndev);
	1315	+out_cleanup_data:
	1316	+ fep->ops->cleanup_data(ndev);
	1317	+out_free_dev:
	1318	+ free_netdev(ndev);
	1319	+ dev_set_drvdata(&ofdev->dev, NULL);
	1320	+out_free_fpi:
	1321	+ kfree(fpi);
	1322	+ return ret;
	1323	+}
	1324	+
	1325	+static int fs_enet_remove(struct of_device *ofdev)
	1326	+{
	1327	+ struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
	1328	+ struct fs_enet_private *fep = netdev_priv(ndev);
	1329	+
	1330	+ unregister_netdev(ndev);
	1331	+
	1332	+ fep->ops->free_bd(ndev);
	1333	+ fep->ops->cleanup_data(ndev);
	1334	+ dev_set_drvdata(fep->dev, NULL);
	1335	+
	1336	+ free_netdev(ndev);
	1337	+ return 0;
	1338	+}
	1339	+
	1340	+static struct of_device_id fs_enet_match[] = {
	1341	+#ifdef CONFIG_FS_ENET_HAS_SCC
	1342	+ {
	1343	+ .compatible = "fsl,cpm1-scc-enet",
	1344	+ .data = (void *)&fs_scc_ops,
	1345	+ },
	1346	+#endif
	1347	+#ifdef CONFIG_FS_ENET_HAS_FCC
	1348	+ {
	1349	+ .compatible = "fsl,cpm2-fcc-enet",
	1350	+ .data = (void *)&fs_fcc_ops,
	1351	+ },
	1352	+#endif
	1353	+#ifdef CONFIG_FS_ENET_HAS_FEC
	1354	+ {
	1355	+ .compatible = "fsl,pq1-fec-enet",
	1356	+ .data = (void *)&fs_fec_ops,
	1357	+ },
	1358	+#endif
	1359	+ {}
	1360	+};
	1361	+
	1362	+static struct of_platform_driver fs_enet_driver = {
	1363	+ .name = "fs_enet",
	1364	+ .match_table = fs_enet_match,
	1365	+ .probe = fs_enet_probe,
	1366	+ .remove = fs_enet_remove,
	1367	+};
	1368	+
	1369	+static int __init fs_init(void)
	1370	+{
	1371	+ int r = setup_immap();
	1372	+ if (r != 0)
	1373	+ return r;
	1374	+
	1375	+ r = of_register_platform_driver(&fs_enet_driver);
	1376	+ if (r != 0)
	1377	+ goto out;
	1378	+
	1379	+ return 0;
	1380	+
	1381	+out:
	1382	+ cleanup_immap();
	1383	+ return r;
	1384	+}
	1385	+
	1386	+static void __exit fs_cleanup(void)
	1387	+{
	1388	+ of_unregister_platform_driver(&fs_enet_driver);
	1389	+ cleanup_immap();
	1390	+}
	1391	+#else
1169	1392	static int __devinit fs_enet_probe(struct device *dev)
1170	1393	{
1171	1394	struct net_device *ndev;
...	...	@@ -1279,6 +1502,7 @@
1279	1502	driver_unregister(&fs_enet_scc_driver);
1280	1503	cleanup_immap();
1281	1504	}
	1505	+#endif
1282	1506
1283	1507	#ifdef CONFIG_NET_POLL_CONTROLLER
1284	1508	static void fs_enet_netpoll(struct net_device *dev)
...	...	@@ -24,19 +24,6 @@
24	24	#include <asm/cpm2.h>
25	25	#endif
26	26
27		-/* This is used to operate with pins.
28		- Note that the actual port size may
29		- be different; cpm(s) handle it OK */
30		-struct bb_info {
31		- u8 mdio_dat_msk;
32		- u8 mdio_dir_msk;
33		- u8 *mdio_dir;
34		- u8 *mdio_dat;
35		- u8 mdc_msk;
36		- u8 *mdc_dat;
37		- int delay;
38		-};
39		-
40	27	/* hw driver ops */
41	28	struct fs_ops {
42	29	int (setup_data)(struct net_device dev);
43	30
...	...	@@ -85,48 +72,12 @@
85	72	#define ENET_RX_ALIGN 16
86	73	#define ENET_RX_FRSIZE L1_CACHE_ALIGN(PKT_MAXBUF_SIZE + ENET_RX_ALIGN - 1)
87	74
88		-struct fs_enet_mii_bus {
89		- struct list_head list;
90		- spinlock_t mii_lock;
91		- const struct fs_mii_bus_info *bus_info;
92		- int refs;
93		- u32 usage_map;
94		-
95		- int (mii_read)(struct fs_enet_mii_bus bus,
96		- int phy_id, int location);
97		-
98		- void (mii_write)(struct fs_enet_mii_bus bus,
99		- int phy_id, int location, int value);
100		-
101		- union {
102		- struct {
103		- unsigned int mii_speed;
104		- void *fecp;
105		- } fec;
106		-
107		- struct {
108		- /* note that the actual port size may */
109		- /* be different; cpm(s) handle it OK */
110		- u8 mdio_msk;
111		- u8 *mdio_dir;
112		- u8 *mdio_dat;
113		- u8 mdc_msk;
114		- u8 *mdc_dir;
115		- u8 *mdc_dat;
116		- } bitbang;
117		-
118		- struct {
119		- u16 lpa;
120		- } fixed;
121		- };
122		-};
123		-
124	75	struct fs_enet_private {
125	76	struct napi_struct napi;
126	77	struct device dev; / pointer back to the device (must be initialized first) */
127	78	spinlock_t lock; /* during all ops except TX pckt processing */
128	79	spinlock_t tx_lock; /* during fs_start_xmit and fs_tx */
129		- const struct fs_platform_info *fpi;
	80	+ struct fs_platform_info *fpi;
130	81	const struct fs_ops *ops;
131	82	int rx_ring, tx_ring;
132	83	dma_addr_t ring_mem_addr;
...	...	@@ -145,7 +96,6 @@
145	96	u32 msg_enable;
146	97	struct mii_if_info mii_if;
147	98	unsigned int last_mii_status;
148		- struct fs_enet_mii_bus *mii_bus;
149	99	int interrupt;
150	100
151	101	struct phy_device *phydev;
152	102
153	103
...	...	@@ -187,9 +137,10 @@
187	137	};
188	138
189	139	/***************************************************************************/
	140	+#ifndef CONFIG_PPC_CPM_NEW_BINDING
190	141	int fs_enet_mdio_bb_init(void);
191		-int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
192	142	int fs_enet_mdio_fec_init(void);
	143	+#endif
193	144
194	145	void fs_init_bds(struct net_device *dev);
195	146	void fs_cleanup_bds(struct net_device *dev);
...	...	@@ -42,6 +42,10 @@
42	42	#include <asm/irq.h>
43	43	#include <asm/uaccess.h>
44	44
	45	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	46	+#include <asm/of_device.h>
	47	+#endif
	48	+
45	49	#include "fs_enet.h"
46	50
47	51	/*************************************************/
48	52
49	53
50	54
51	55
52	56
...	...	@@ -74,33 +78,64 @@
74	78
75	79	#define MAX_CR_CMD_LOOPS 10000
76	80
77		-static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 mcn, u32 op)
	81	+static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 op)
78	82	{
79	83	const struct fs_platform_info *fpi = fep->fpi;
80	84	cpm2_map_t *immap = fs_enet_immap;
81	85	cpm_cpm2_t *cpmp = &immap->im_cpm;
82		- u32 v;
83	86	int i;
84	87
85		- /* Currently I don't know what feature call will look like. But
86		- I guess there'd be something like do_cpm_cmd() which will require page & sblock */
87		- v = mk_cr_cmd(fpi->cp_page, fpi->cp_block, mcn, op);
88		- W32(cpmp, cp_cpcr, v \| CPM_CR_FLG);
	88	+ W32(cpmp, cp_cpcr, fpi->cp_command \| op \| CPM_CR_FLG);
89	89	for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
90	90	if ((R32(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
91		- break;
	91	+ return 0;
92	92
93		- if (i >= MAX_CR_CMD_LOOPS) {
94		- printk(KERN_ERR "%s(): Not able to issue CPM command\n",
95		- __FUNCTION__);
96		- return 1;
97		- }
98		-
99		- return 0;
	93	+ printk(KERN_ERR "%s(): Not able to issue CPM command\n",
	94	+ __FUNCTION__);
	95	+ return 1;
100	96	}
101	97
102	98	static int do_pd_setup(struct fs_enet_private *fep)
103	99	{
	100	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	101	+ struct of_device *ofdev = to_of_device(fep->dev);
	102	+ struct fs_platform_info *fpi = fep->fpi;
	103	+ int ret = -EINVAL;
	104	+
	105	+ fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
	106	+ if (fep->interrupt == NO_IRQ)
	107	+ goto out;
	108	+
	109	+ fep->fcc.fccp = of_iomap(ofdev->node, 0);
	110	+ if (!fep->fcc.fccp)
	111	+ goto out;
	112	+
	113	+ fep->fcc.ep = of_iomap(ofdev->node, 1);
	114	+ if (!fep->fcc.ep)
	115	+ goto out_fccp;
	116	+
	117	+ fep->fcc.fcccp = of_iomap(ofdev->node, 2);
	118	+ if (!fep->fcc.fcccp)
	119	+ goto out_ep;
	120	+
	121	+ fep->fcc.mem = (void *)cpm_dpalloc(128, 8);
	122	+ fpi->dpram_offset = (u32)cpm2_immr;
	123	+ if (IS_ERR_VALUE(fpi->dpram_offset)) {
	124	+ ret = fpi->dpram_offset;
	125	+ goto out_fcccp;
	126	+ }
	127	+
	128	+ return 0;
	129	+
	130	+out_fcccp:
	131	+ iounmap(fep->fcc.fcccp);
	132	+out_ep:
	133	+ iounmap(fep->fcc.ep);
	134	+out_fccp:
	135	+ iounmap(fep->fcc.fccp);
	136	+out:
	137	+ return ret;
	138	+#else
104	139	struct platform_device *pdev = to_platform_device(fep->dev);
105	140	struct resource *r;
106	141
...	...	@@ -138,6 +173,7 @@
138	173	return -EINVAL;
139	174
140	175	return 0;
	176	+#endif
141	177	}
142	178
143	179	#define FCC_NAPI_RX_EVENT_MSK (FCC_ENET_RXF \| FCC_ENET_RXB)
144	180
145	181
...	...	@@ -148,11 +184,17 @@
148	184	static int setup_data(struct net_device *dev)
149	185	{
150	186	struct fs_enet_private *fep = netdev_priv(dev);
151		- const struct fs_platform_info *fpi = fep->fpi;
	187	+#ifndef CONFIG_PPC_CPM_NEW_BINDING
	188	+ struct fs_platform_info *fpi = fep->fpi;
152	189
	190	+ fpi->cp_command = (fpi->cp_page << 26) \|
	191	+ (fpi->cp_block << 21) \|
	192	+ (12 << 6);
	193	+
153	194	fep->fcc.idx = fs_get_fcc_index(fpi->fs_no);
154	195	if ((unsigned int)fep->fcc.idx >= 3) /* max 3 FCCs */
155	196	return -EINVAL;
	197	+#endif
156	198
157	199	if (do_pd_setup(fep) != 0)
158	200	return -EINVAL;
...	...	@@ -226,7 +268,7 @@
226	268	W16(ep, fen_taddrh, taddrh);
227	269	W16(ep, fen_taddrm, taddrm);
228	270	W16(ep, fen_taddrl, taddrl);
229		- fcc_cr_cmd(fep, 0x0C, CPM_CR_SET_GADDR);
	271	+ fcc_cr_cmd(fep, CPM_CR_SET_GADDR);
230	272	}
231	273
232	274	static void set_multicast_finish(struct net_device *dev)
...	...	@@ -281,7 +323,7 @@
281	323
282	324	/* clear everything (slow & steady does it) */
283	325	for (i = 0; i < sizeof(*ep); i++)
284		- out_8((char *)ep + i, 0);
	326	+ out_8((u8 __iomem *)ep + i, 0);
285	327
286	328	/* get physical address */
287	329	rx_bd_base_phys = fep->ring_mem_addr;
...	...	@@ -397,7 +439,7 @@
397	439	S8(fcccp, fcc_gfemr, 0x20);
398	440	}
399	441
400		- fcc_cr_cmd(fep, 0x0c, CPM_CR_INIT_TRX);
	442	+ fcc_cr_cmd(fep, CPM_CR_INIT_TRX);
401	443
402	444	/* clear events */
403	445	W16(fccp, fcc_fcce, 0xffff);
404	446
405	447
406	448
407	449
...	...	@@ -515,23 +557,22 @@
515	557	{
516	558	struct fs_enet_private *fep = netdev_priv(dev);
517	559
518		- if (*sizep < sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t))
	560	+ if (*sizep < sizeof(fcc_t) + sizeof(fcc_enet_t) + 1)
519	561	return -EINVAL;
520	562
521	563	memcpy_fromio(p, fep->fcc.fccp, sizeof(fcc_t));
522	564	p = (char *)p + sizeof(fcc_t);
523	565
524		- memcpy_fromio(p, fep->fcc.fcccp, sizeof(fcc_c_t));
525		- p = (char *)p + sizeof(fcc_c_t);
526		-
527	566	memcpy_fromio(p, fep->fcc.ep, sizeof(fcc_enet_t));
	567	+ p = (char *)p + sizeof(fcc_enet_t);
528	568
	569	+ memcpy_fromio(p, fep->fcc.fcccp, 1);
529	570	return 0;
530	571	}
531	572
532	573	int get_regs_len(struct net_device *dev)
533	574	{
534		- return sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t);
	575	+ return sizeof(fcc_t) + sizeof(fcc_enet_t) + 1;
535	576	}
536	577
537	578	/* Some transmit errors cause the transmitter to shut
...	...	@@ -551,7 +592,7 @@
551	592	udelay(10);
552	593	S32(fccp, fcc_gfmr, FCC_GFMR_ENT);
553	594
554		- fcc_cr_cmd(fep, 0x0C, CPM_CR_RESTART_TX);
	595	+ fcc_cr_cmd(fep, CPM_CR_RESTART_TX);
555	596	}
556	597
557	598	/*************************************************************************/
...	...	@@ -43,6 +43,10 @@
43	43	#include <asm/commproc.h>
44	44	#endif
45	45
	46	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	47	+#include <asm/of_device.h>
	48	+#endif
	49	+
46	50	#include "fs_enet.h"
47	51	#include "fec.h"
48	52
...	...	@@ -95,6 +99,19 @@
95	99
96	100	static int do_pd_setup(struct fs_enet_private *fep)
97	101	{
	102	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	103	+ struct of_device *ofdev = to_of_device(fep->dev);
	104	+
	105	+ fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
	106	+ if (fep->interrupt == NO_IRQ)
	107	+ return -EINVAL;
	108	+
	109	+ fep->fec.fecp = of_iomap(ofdev->node, 0);
	110	+ if (!fep->fcc.fccp)
	111	+ return -EINVAL;
	112	+
	113	+ return 0;
	114	+#else
98	115	struct platform_device *pdev = to_platform_device(fep->dev);
99	116	struct resource *r;
100	117
...	...	@@ -110,7 +127,7 @@
110	127	return -EINVAL;
111	128
112	129	return 0;
113		-
	130	+#endif
114	131	}
115	132
116	133	#define FEC_NAPI_RX_EVENT_MSK (FEC_ENET_RXF \| FEC_ENET_RXB)
...	...	@@ -13,11 +13,6 @@
13	13	*/
14	14
15	15	#include <linux/module.h>
16		-#include <linux/types.h>
17		-#include <linux/kernel.h>
18		-#include <linux/string.h>
19		-#include <linux/ptrace.h>
20		-#include <linux/errno.h>
21	16	#include <linux/ioport.h>
22	17	#include <linux/slab.h>
23	18	#include <linux/interrupt.h>
24	19
25	20
26	21
27	22
28	23
29	24
30	25
31	26
32	27
33	28
34	29
35	30
36	31
37	32
38	33
39	34
40	35
41	36
42	37
43	38
...	...	@@ -25,86 +20,77 @@
25	20	#include <linux/delay.h>
26	21	#include <linux/netdevice.h>
27	22	#include <linux/etherdevice.h>
28		-#include <linux/skbuff.h>
29		-#include <linux/spinlock.h>
30	23	#include <linux/mii.h>
31	24	#include <linux/ethtool.h>
32	25	#include <linux/bitops.h>
33	26	#include <linux/platform_device.h>
34	27
35		-#include <asm/pgtable.h>
36		-#include <asm/irq.h>
37		-#include <asm/uaccess.h>
	28	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	29	+#include <linux/of_platform.h>
	30	+#endif
38	31
39	32	#include "fs_enet.h"
40	33
41		-static int bitbang_prep_bit(u8 *datp, u8 mskp,
42		- struct fs_mii_bit *mii_bit)
43		-{
44		- void *dat;
45		- int adv;
46		- u8 msk;
	34	+struct bb_info {
	35	+ __be32 __iomem *dir;
	36	+ __be32 __iomem *dat;
	37	+ u32 mdio_msk;
	38	+ u32 mdc_msk;
	39	+ int delay;
	40	+};
47	41
48		- dat = (void*) mii_bit->offset;
49		-
50		- adv = mii_bit->bit >> 3;
51		- dat = (char *)dat + adv;
52		-
53		- msk = 1 << (7 - (mii_bit->bit & 7));
54		-
55		- *datp = dat;
56		- *mskp = msk;
57		-
58		- return 0;
59		-}
60		-
61		-static inline void bb_set(u8 *p, u8 m)
	42	+/* FIXME: If any other users of GPIO crop up, then these will have to
	43	+ * have some sort of global synchronization to avoid races with other
	44	+ * pins on the same port. The ideal solution would probably be to
	45	+ * bind the ports to a GPIO driver, and have this be a client of it.
	46	+ */
	47	+static inline void bb_set(u32 __iomem *p, u32 m)
62	48	{
63		- out_8(p, in_8(p) \| m);
	49	+ out_be32(p, in_be32(p) \| m);
64	50	}
65	51
66		-static inline void bb_clr(u8 *p, u8 m)
	52	+static inline void bb_clr(u32 __iomem *p, u32 m)
67	53	{
68		- out_8(p, in_8(p) & ~m);
	54	+ out_be32(p, in_be32(p) & ~m);
69	55	}
70	56
71		-static inline int bb_read(u8 *p, u8 m)
	57	+static inline int bb_read(u32 __iomem *p, u32 m)
72	58	{
73		- return (in_8(p) & m) != 0;
	59	+ return (in_be32(p) & m) != 0;
74	60	}
75	61
76	62	static inline void mdio_active(struct bb_info *bitbang)
77	63	{
78		- bb_set(bitbang->mdio_dir, bitbang->mdio_dir_msk);
	64	+ bb_set(bitbang->dir, bitbang->mdio_msk);
79	65	}
80	66
81		-static inline void mdio_tristate(struct bb_info *bitbang )
	67	+static inline void mdio_tristate(struct bb_info *bitbang)
82	68	{
83		- bb_clr(bitbang->mdio_dir, bitbang->mdio_dir_msk);
	69	+ bb_clr(bitbang->dir, bitbang->mdio_msk);
84	70	}
85	71
86		-static inline int mdio_read(struct bb_info *bitbang )
	72	+static inline int mdio_read(struct bb_info *bitbang)
87	73	{
88		- return bb_read(bitbang->mdio_dat, bitbang->mdio_dat_msk);
	74	+ return bb_read(bitbang->dat, bitbang->mdio_msk);
89	75	}
90	76
91		-static inline void mdio(struct bb_info *bitbang , int what)
	77	+static inline void mdio(struct bb_info *bitbang, int what)
92	78	{
93	79	if (what)
94		- bb_set(bitbang->mdio_dat, bitbang->mdio_dat_msk);
	80	+ bb_set(bitbang->dat, bitbang->mdio_msk);
95	81	else
96		- bb_clr(bitbang->mdio_dat, bitbang->mdio_dat_msk);
	82	+ bb_clr(bitbang->dat, bitbang->mdio_msk);
97	83	}
98	84
99		-static inline void mdc(struct bb_info *bitbang , int what)
	85	+static inline void mdc(struct bb_info *bitbang, int what)
100	86	{
101	87	if (what)
102		- bb_set(bitbang->mdc_dat, bitbang->mdc_msk);
	88	+ bb_set(bitbang->dat, bitbang->mdc_msk);
103	89	else
104		- bb_clr(bitbang->mdc_dat, bitbang->mdc_msk);
	90	+ bb_clr(bitbang->dat, bitbang->mdc_msk);
105	91	}
106	92
107		-static inline void mii_delay(struct bb_info *bitbang )
	93	+static inline void mii_delay(struct bb_info *bitbang)
108	94	{
109	95	udelay(bitbang->delay);
110	96	}
111	97
112	98
113	99
114	100
115	101
...	...	@@ -280,29 +266,178 @@
280	266	return 0;
281	267	}
282	268
283		-static int fs_mii_bitbang_init(struct bb_info bitbang, struct fs_mii_bb_platform_info fmpi)
	269	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	270	+static int __devinit fs_mii_bitbang_init(struct mii_bus *bus,
	271	+ struct device_node *np)
284	272	{
285		- int r;
	273	+ struct resource res;
	274	+ const u32 *data;
	275	+ int mdio_pin, mdc_pin, len;
	276	+ struct bb_info *bitbang = bus->priv;
286	277
287		- bitbang->delay = fmpi->delay;
	278	+ int ret = of_address_to_resource(np, 0, &res);
	279	+ if (ret)
	280	+ return ret;
288	281
289		- r = bitbang_prep_bit(&bitbang->mdio_dir,
290		- &bitbang->mdio_dir_msk,
291		- &fmpi->mdio_dir);
292		- if (r != 0)
293		- return r;
	282	+ if (res.end - res.start < 13)
	283	+ return -ENODEV;
294	284
295		- r = bitbang_prep_bit(&bitbang->mdio_dat,
296		- &bitbang->mdio_dat_msk,
297		- &fmpi->mdio_dat);
298		- if (r != 0)
299		- return r;
	285	+ /* This should really encode the pin number as well, but all
	286	+ * we get is an int, and the odds of multiple bitbang mdio buses
	287	+ * is low enough that it's not worth going too crazy.
	288	+ */
	289	+ bus->id = res.start;
300	290
301		- r = bitbang_prep_bit(&bitbang->mdc_dat,
302		- &bitbang->mdc_msk,
303		- &fmpi->mdc_dat);
304		- if (r != 0)
305		- return r;
	291	+ data = of_get_property(np, "fsl,mdio-pin", &len);
	292	+ if (!data \|\| len != 4)
	293	+ return -ENODEV;
	294	+ mdio_pin = *data;
	295	+
	296	+ data = of_get_property(np, "fsl,mdc-pin", &len);
	297	+ if (!data \|\| len != 4)
	298	+ return -ENODEV;
	299	+ mdc_pin = *data;
	300	+
	301	+ bitbang->dir = ioremap(res.start, res.end - res.start + 1);
	302	+ if (!bitbang->dir)
	303	+ return -ENOMEM;
	304	+
	305	+ bitbang->dat = bitbang->dir + 4;
	306	+ bitbang->mdio_msk = 1 << (31 - mdio_pin);
	307	+ bitbang->mdc_msk = 1 << (31 - mdc_pin);
	308	+ bitbang->delay = 1; /* 1 us between operations */
	309	+
	310	+ return 0;
	311	+}
	312	+
	313	+static void __devinit add_phy(struct mii_bus bus, struct device_node np)
	314	+{
	315	+ const u32 *data;
	316	+ int len, id, irq;
	317	+
	318	+ data = of_get_property(np, "reg", &len);
	319	+ if (!data \|\| len != 4)
	320	+ return;
	321	+
	322	+ id = *data;
	323	+ bus->phy_mask &= ~(1 << id);
	324	+
	325	+ irq = of_irq_to_resource(np, 0, NULL);
	326	+ if (irq != NO_IRQ)
	327	+ bus->irq[id] = irq;
	328	+}
	329	+
	330	+static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
	331	+ const struct of_device_id *match)
	332	+{
	333	+ struct device_node *np = NULL;
	334	+ struct mii_bus *new_bus;
	335	+ struct bb_info *bitbang;
	336	+ int ret = -ENOMEM;
	337	+ int i;
	338	+
	339	+ new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL);
	340	+ if (!new_bus)
	341	+ goto out;
	342	+
	343	+ bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL);
	344	+ if (!bitbang)
	345	+ goto out_free_bus;
	346	+
	347	+ new_bus->priv = bitbang;
	348	+ new_bus->name = "CPM2 Bitbanged MII",
	349	+ new_bus->read = &fs_enet_mii_bb_read,
	350	+ new_bus->write = &fs_enet_mii_bb_write,
	351	+ new_bus->reset = &fs_enet_mii_bb_reset,
	352	+
	353	+ ret = fs_mii_bitbang_init(new_bus, ofdev->node);
	354	+ if (ret)
	355	+ goto out_free_bitbang;
	356	+
	357	+ new_bus->phy_mask = ~0;
	358	+ new_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
	359	+ if (!new_bus->irq)
	360	+ goto out_unmap_regs;
	361	+
	362	+ for (i = 0; i < PHY_MAX_ADDR; i++)
	363	+ new_bus->irq[i] = -1;
	364	+
	365	+ while ((np = of_get_next_child(ofdev->node, np)))
	366	+ if (!strcmp(np->type, "ethernet-phy"))
	367	+ add_phy(new_bus, np);
	368	+
	369	+ new_bus->dev = &ofdev->dev;
	370	+ dev_set_drvdata(&ofdev->dev, new_bus);
	371	+
	372	+ ret = mdiobus_register(new_bus);
	373	+ if (ret)
	374	+ goto out_free_irqs;
	375	+
	376	+ return 0;
	377	+
	378	+out_free_irqs:
	379	+ dev_set_drvdata(&ofdev->dev, NULL);
	380	+ kfree(new_bus->irq);
	381	+out_unmap_regs:
	382	+ iounmap(bitbang->dir);
	383	+out_free_bitbang:
	384	+ kfree(bitbang);
	385	+out_free_bus:
	386	+ kfree(new_bus);
	387	+out:
	388	+ return ret;
	389	+}
	390	+
	391	+static int fs_enet_mdio_remove(struct of_device *ofdev)
	392	+{
	393	+ struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
	394	+ struct bb_info *bitbang = bus->priv;
	395	+
	396	+ mdiobus_unregister(bus);
	397	+ dev_set_drvdata(&ofdev->dev, NULL);
	398	+ kfree(bus->irq);
	399	+ iounmap(bitbang->dir);
	400	+ kfree(bitbang);
	401	+ kfree(bus);
	402	+
	403	+ return 0;
	404	+}
	405	+
	406	+static struct of_device_id fs_enet_mdio_bb_match[] = {
	407	+ {
	408	+ .compatible = "fsl,cpm2-mdio-bitbang",
	409	+ },
	410	+ {},
	411	+};
	412	+
	413	+static struct of_platform_driver fs_enet_bb_mdio_driver = {
	414	+ .name = "fsl-bb-mdio",
	415	+ .match_table = fs_enet_mdio_bb_match,
	416	+ .probe = fs_enet_mdio_probe,
	417	+ .remove = fs_enet_mdio_remove,
	418	+};
	419	+
	420	+int fs_enet_mdio_bb_init(void)
	421	+{
	422	+ return of_register_platform_driver(&fs_enet_bb_mdio_driver);
	423	+}
	424	+
	425	+void fs_enet_mdio_bb_exit(void)
	426	+{
	427	+ of_unregister_platform_driver(&fs_enet_bb_mdio_driver);
	428	+}
	429	+
	430	+module_init(fs_enet_mdio_bb_init);
	431	+module_exit(fs_enet_mdio_bb_exit);
	432	+#else
	433	+static int __devinit fs_mii_bitbang_init(struct bb_info *bitbang,
	434	+ struct fs_mii_bb_platform_info *fmpi)
	435	+{
	436	+ bitbang->dir = (u32 __iomem *)fmpi->mdio_dir.offset;
	437	+ bitbang->dat = (u32 __iomem *)fmpi->mdio_dat.offset;
	438	+ bitbang->mdio_msk = 1U << (31 - fmpi->mdio_dat.bit);
	439	+ bitbang->mdc_msk = 1U << (31 - fmpi->mdc_dat.bit);
	440	+ bitbang->delay = fmpi->delay;
306	441
307	442	return 0;
308	443	}
...	...	@@ -36,6 +36,10 @@
36	36	#include <asm/irq.h>
37	37	#include <asm/uaccess.h>
38	38
	39	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	40	+#include <asm/of_platform.h>
	41	+#endif
	42	+
39	43	#include "fs_enet.h"
40	44	#include "fec.h"
41	45
...	...	@@ -47,6 +51,7 @@
47	51
48	52	#define FEC_MII_LOOPS 10000
49	53
	54	+#ifndef CONFIG_PPC_CPM_NEW_BINDING
50	55	static int match_has_phy (struct device dev, void data)
51	56	{
52	57	struct platform_device* pdev = container_of(dev, struct platform_device, dev);
...	...	@@ -90,6 +95,7 @@
90	95
91	96	return 0;
92	97	}
	98	+#endif
93	99
94	100	static int fs_enet_fec_mii_read(struct mii_bus *bus , int phy_id, int location)
95	101	{
...	...	@@ -145,6 +151,141 @@
145	151	return 0;
146	152	}
147	153
	154	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	155	+static void __devinit add_phy(struct mii_bus bus, struct device_node np)
	156	+{
	157	+ const u32 *data;
	158	+ int len, id, irq;
	159	+
	160	+ data = of_get_property(np, "reg", &len);
	161	+ if (!data \|\| len != 4)
	162	+ return;
	163	+
	164	+ id = *data;
	165	+ bus->phy_mask &= ~(1 << id);
	166	+
	167	+ irq = of_irq_to_resource(np, 0, NULL);
	168	+ if (irq != NO_IRQ)
	169	+ bus->irq[id] = irq;
	170	+}
	171	+
	172	+static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
	173	+ const struct of_device_id *match)
	174	+{
	175	+ struct device_node *np = NULL;
	176	+ struct resource res;
	177	+ struct mii_bus *new_bus;
	178	+ struct fec_info *fec;
	179	+ int ret = -ENOMEM, i;
	180	+
	181	+ new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL);
	182	+ if (!new_bus)
	183	+ goto out;
	184	+
	185	+ fec = kzalloc(sizeof(struct fec_info), GFP_KERNEL);
	186	+ if (!fec)
	187	+ goto out_mii;
	188	+
	189	+ new_bus->priv = fec;
	190	+ new_bus->name = "FEC MII Bus";
	191	+ new_bus->read = &fs_enet_fec_mii_read;
	192	+ new_bus->write = &fs_enet_fec_mii_write;
	193	+ new_bus->reset = &fs_enet_fec_mii_reset;
	194	+
	195	+ ret = of_address_to_resource(ofdev->node, 0, &res);
	196	+ if (ret)
	197	+ return ret;
	198	+
	199	+ new_bus->id = res.start;
	200	+
	201	+ fec->fecp = ioremap(res.start, res.end - res.start + 1);
	202	+ if (!fec->fecp)
	203	+ goto out_fec;
	204	+
	205	+ fec->mii_speed = ((ppc_proc_freq + 4999999) / 5000000) << 1;
	206	+
	207	+ setbits32(&fec->fecp->fec_r_cntrl, FEC_RCNTRL_MII_MODE);
	208	+ setbits32(&fec->fecp->fec_ecntrl, FEC_ECNTRL_PINMUX \|
	209	+ FEC_ECNTRL_ETHER_EN);
	210	+ out_be32(&fec->fecp->fec_ievent, FEC_ENET_MII);
	211	+ out_be32(&fec->fecp->fec_mii_speed, fec->mii_speed);
	212	+
	213	+ new_bus->phy_mask = ~0;
	214	+ new_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
	215	+ if (!new_bus->irq)
	216	+ goto out_unmap_regs;
	217	+
	218	+ for (i = 0; i < PHY_MAX_ADDR; i++)
	219	+ new_bus->irq[i] = -1;
	220	+
	221	+ while ((np = of_get_next_child(ofdev->node, np)))
	222	+ if (!strcmp(np->type, "ethernet-phy"))
	223	+ add_phy(new_bus, np);
	224	+
	225	+ new_bus->dev = &ofdev->dev;
	226	+ dev_set_drvdata(&ofdev->dev, new_bus);
	227	+
	228	+ ret = mdiobus_register(new_bus);
	229	+ if (ret)
	230	+ goto out_free_irqs;
	231	+
	232	+ return 0;
	233	+
	234	+out_free_irqs:
	235	+ dev_set_drvdata(&ofdev->dev, NULL);
	236	+ kfree(new_bus->irq);
	237	+out_unmap_regs:
	238	+ iounmap(fec->fecp);
	239	+out_fec:
	240	+ kfree(fec);
	241	+out_mii:
	242	+ kfree(new_bus);
	243	+out:
	244	+ return ret;
	245	+}
	246	+
	247	+static int fs_enet_mdio_remove(struct of_device *ofdev)
	248	+{
	249	+ struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
	250	+ struct fec_info *fec = bus->priv;
	251	+
	252	+ mdiobus_unregister(bus);
	253	+ dev_set_drvdata(&ofdev->dev, NULL);
	254	+ kfree(bus->irq);
	255	+ iounmap(fec->fecp);
	256	+ kfree(fec);
	257	+ kfree(bus);
	258	+
	259	+ return 0;
	260	+}
	261	+
	262	+static struct of_device_id fs_enet_mdio_fec_match[] = {
	263	+ {
	264	+ .compatible = "fsl,pq1-fec-mdio",
	265	+ },
	266	+ {},
	267	+};
	268	+
	269	+static struct of_platform_driver fs_enet_fec_mdio_driver = {
	270	+ .name = "fsl-fec-mdio",
	271	+ .match_table = fs_enet_mdio_fec_match,
	272	+ .probe = fs_enet_mdio_probe,
	273	+ .remove = fs_enet_mdio_remove,
	274	+};
	275	+
	276	+static int fs_enet_mdio_fec_init(void)
	277	+{
	278	+ return of_register_platform_driver(&fs_enet_fec_mdio_driver);
	279	+}
	280	+
	281	+static void fs_enet_mdio_fec_exit(void)
	282	+{
	283	+ of_unregister_platform_driver(&fs_enet_fec_mdio_driver);
	284	+}
	285	+
	286	+module_init(fs_enet_mdio_fec_init);
	287	+module_exit(fs_enet_mdio_fec_exit);
	288	+#else
148	289	static int __devinit fs_enet_fec_mdio_probe(struct device *dev)
149	290	{
150	291	struct platform_device *pdev = to_platform_device(dev);
...	...	@@ -235,4 +376,5 @@
235	376	{
236	377	driver_unregister(&fs_enet_fec_mdio_driver);
237	378	}
	379	+#endif
...	...	@@ -120,6 +120,7 @@
120	120
121	121	u32 cp_page; /* CPM page */
122	122	u32 cp_block; /* CPM sblock */
	123	+ u32 cp_command; /* CPM page/sblock/mcn */
123	124
124	125	u32 clk_trx; /* some stuff for pins & mux configuration*/
125	126	u32 clk_rx;
126	127
...	...	@@ -134,7 +135,11 @@
134	135	u32 device_flags;
135	136
136	137	int phy_addr; /* the phy address (-1 no phy) */
	138	+#ifdef CONFIG_PPC_CPM_NEW_BINDING
	139	+ char bus_id[16];
	140	+#else
137	141	const char* bus_id;
	142	+#endif
138	143	int phy_irq; /* the phy irq (if it exists) */
139	144
140	145	const struct fs_mii_bus_info *bus_info;