static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c) { struct mii_bus *i2c_mii; int ret; if (!i2c_check_functionality(i2c, I2C_FUNC_I2C)) return -EINVAL; sfp->i2c = i2c; sfp->read = sfp_i2c_read; i2c_mii = mdio_i2c_alloc(sfp->dev, i2c); if (IS_ERR(i2c_mii)) return PTR_ERR(i2c_mii); i2c_mii->name = "SFP I2C Bus"; i2c_mii->phy_mask = ~0; ret = mdiobus_register(i2c_mii); if (ret < 0) { mdiobus_free(i2c_mii); return ret; } sfp->i2c_mii = i2c_mii; return 0; }
static int netx_eth_probe(struct device_d *dev) { struct eth_device *edev; struct netx_eth_priv *priv; struct netx_eth_platform_data *pdata; debug("netx_eth_probe()\n"); pdata = dev->platform_data; edev = xzalloc(sizeof(struct eth_device) + sizeof(struct netx_eth_priv)); edev->priv = (struct netx_priv *)(edev + 1); priv = edev->priv; priv->xcno = pdata->xcno; edev->init = netx_eth_init_dev; edev->open = netx_eth_open; edev->send = netx_eth_send; edev->recv = netx_eth_rx; edev->halt = netx_eth_halt; edev->get_ethaddr = netx_eth_get_ethaddr; edev->set_ethaddr = netx_eth_set_ethaddr; edev->parent = dev; priv->miibus.read = netx_miibus_read; priv->miibus.write = netx_miibus_write; priv->miibus.parent = dev; netx_eth_init_phy(); mdiobus_register(&priv->miibus); eth_register(edev); return 0; }
static int __devinit ep8248e_mdio_probe(struct of_device *ofdev, const struct of_device_id *match) { struct mii_bus *bus; struct resource res; struct device_node *node; int ret, i; node = of_get_parent(ofdev->node); of_node_put(node); if (node != ep8248e_bcsr_node) return -ENODEV; ret = of_address_to_resource(ofdev->node, 0, &res); if (ret) return ret; bus = alloc_mdio_bitbang(&ep8248e_mdio_ctrl); if (!bus) return -ENOMEM; bus->phy_mask = 0; bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL); for (i = 0; i < PHY_MAX_ADDR; i++) bus->irq[i] = -1; bus->name = "ep8248e-mdio-bitbang"; bus->dev = &ofdev->dev; snprintf(bus->id, MII_BUS_ID_SIZE, "%x", res.start); return mdiobus_register(bus); }
static int __devinit mdio_gpio_probe(struct platform_device *pdev) { struct mdio_gpio_platform_data *pdata; struct mii_bus *new_bus; int ret; if (pdev->dev.of_node) pdata = mdio_gpio_of_get_data(pdev); else pdata = pdev->dev.platform_data; if (!pdata) return -ENODEV; new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, pdev->id); if (!new_bus) return -ENODEV; if (pdev->dev.of_node) ret = of_mdiobus_register(new_bus, pdev->dev.of_node); else ret = mdiobus_register(new_bus); if (ret) mdio_gpio_bus_deinit(&pdev->dev); return ret; }
/* use phylib infrastructure */ static int ax88172a_init_mdio(struct usbnet *dev) { struct ax88172a_private *priv = dev->driver_priv; int ret; priv->mdio = mdiobus_alloc(); if (!priv->mdio) { netdev_err(dev->net, "Could not allocate MDIO bus\n"); return -ENOMEM; } priv->mdio->priv = (void *)dev; priv->mdio->read = &asix_mdio_bus_read; priv->mdio->write = &asix_mdio_bus_write; priv->mdio->name = "Asix MDIO Bus"; /* mii bus name is usb-<usb bus number>-<usb device number> */ snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "usb-%03d:%03d", dev->udev->bus->busnum, dev->udev->devnum); ret = mdiobus_register(priv->mdio); if (ret) { netdev_err(dev->net, "Could not register MDIO bus\n"); goto mfree; } netdev_info(dev->net, "registered mdio bus %s\n", priv->mdio->id); return 0; mfree: mdiobus_free(priv->mdio); return ret; }
static int __devinit fs_enet_mdio_probe(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct fs_mii_bb_platform_info *pdata; struct mii_bus *new_bus; struct bb_info *bitbang; int err = 0; if (NULL == dev) return -EINVAL; bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL); if (NULL == bitbang) return -ENOMEM; bitbang->ctrl.ops = &bb_ops; new_bus = alloc_mdio_bitbang(&bitbang->ctrl); if (NULL == new_bus) return -ENOMEM; new_bus->name = "BB MII Bus", snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id); new_bus->phy_mask = ~0x9; pdata = (struct fs_mii_bb_platform_info *)pdev->dev.platform_data; if (NULL == pdata) { printk(KERN_ERR "gfar mdio %d: Missing platform data!\n", pdev->id); return -ENODEV; } /*set up workspace*/ fs_mii_bitbang_init(bitbang, pdata); new_bus->priv = bitbang; new_bus->irq = pdata->irq; new_bus->dev = dev; dev_set_drvdata(dev, new_bus); err = mdiobus_register(new_bus); if (0 != err) { printk (KERN_ERR "%s: Cannot register as MDIO bus\n", new_bus->name); goto bus_register_fail; } return 0; bus_register_fail: free_mdio_bitbang(new_bus); kfree(bitbang); return err; }
struct mii_bus *bcma_mdio_mii_register(struct bgmac *bgmac) { struct bcma_device *core = bgmac->bcma.core; struct mii_bus *mii_bus; int err; mii_bus = mdiobus_alloc(); if (!mii_bus) { err = -ENOMEM; goto err; } mii_bus->name = "bcma_mdio mii bus"; sprintf(mii_bus->id, "%s-%d-%d", "bcma_mdio", core->bus->num, core->core_unit); mii_bus->priv = bgmac; mii_bus->read = bcma_mdio_mii_read; mii_bus->write = bcma_mdio_mii_write; mii_bus->reset = bcma_mdio_phy_reset; mii_bus->parent = &core->dev; mii_bus->phy_mask = ~(1 << bgmac->phyaddr); err = mdiobus_register(mii_bus); if (err) { dev_err(&core->dev, "Registration of mii bus failed\n"); goto err_free_bus; } return mii_bus; err_free_bus: mdiobus_free(mii_bus); err: return ERR_PTR(err); }
static int ixp4xx_mdio_register(void) { int err; if (!(mdio_bus = mdiobus_alloc())) return -ENOMEM; if (cpu_is_ixp43x()) { /* IXP43x lacks NPE-B and uses NPE-C for MII PHY access */ if (!(ixp4xx_read_feature_bits() & IXP4XX_FEATURE_NPEC_ETH)) return -ENOSYS; mdio_regs = (struct eth_regs __iomem *)IXP4XX_EthC_BASE_VIRT; } else { /* All MII PHY accesses use NPE-B Ethernet registers */ if (!(ixp4xx_read_feature_bits() & IXP4XX_FEATURE_NPEB_ETH0)) return -ENOSYS; mdio_regs = (struct eth_regs __iomem *)IXP4XX_EthB_BASE_VIRT; } __raw_writel(DEFAULT_CORE_CNTRL, &mdio_regs->core_control); spin_lock_init(&mdio_lock); mdio_bus->name = "IXP4xx MII Bus"; mdio_bus->read = &ixp4xx_mdio_read; mdio_bus->write = &ixp4xx_mdio_write; strcpy(mdio_bus->id, "0"); if ((err = mdiobus_register(mdio_bus))) mdiobus_free(mdio_bus); return err; }
static int rtl8366_smi_mii_init(struct rtl8366_smi *smi) { int ret; int i; smi->mii_bus = mdiobus_alloc(); if (smi->mii_bus == NULL) { ret = -ENOMEM; goto err; } smi->mii_bus->priv = (void *) smi; smi->mii_bus->name = dev_name(smi->parent); smi->mii_bus->read = smi->ops->mii_read; smi->mii_bus->write = smi->ops->mii_write; snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s", dev_name(smi->parent)); smi->mii_bus->parent = smi->parent; smi->mii_bus->phy_mask = ~(0x1f); smi->mii_bus->irq = smi->mii_irq; for (i = 0; i < PHY_MAX_ADDR; i++) smi->mii_irq[i] = PHY_POLL; ret = mdiobus_register(smi->mii_bus); if (ret) goto err_free; return 0; err_free: mdiobus_free(smi->mii_bus); err: return ret; }
static int mdio_gpio_probe(struct platform_device *pdev) { struct mdio_gpio_platform_data *pdata; struct mii_bus *new_bus; int ret, bus_id; if (pdev->dev.of_node) { pdata = mdio_gpio_of_get_data(pdev); bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio"); } else { pdata = dev_get_platdata(&pdev->dev); bus_id = pdev->id; } if (!pdata) return -ENODEV; new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, bus_id); if (!new_bus) return -ENODEV; if (pdev->dev.of_node) ret = of_mdiobus_register(new_bus, pdev->dev.of_node); else ret = mdiobus_register(new_bus); if (ret) mdio_gpio_bus_deinit(&pdev->dev); return ret; }
static int ramips_mdio_init(struct raeth_priv *re) { int err; int i; re->mii_bus = mdiobus_alloc(); if (re->mii_bus == NULL) return -ENOMEM; re->mii_bus->name = "ramips_mdio"; re->mii_bus->read = ramips_mdio_read; re->mii_bus->write = ramips_mdio_write; re->mii_bus->reset = ramips_mdio_reset; re->mii_bus->irq = re->mii_irq; re->mii_bus->priv = re; re->mii_bus->parent = re->parent; snprintf(re->mii_bus->id, MII_BUS_ID_SIZE, "%s", "ramips_mdio"); re->mii_bus->phy_mask = 0; for (i = 0; i < PHY_MAX_ADDR; i++) re->mii_irq[i] = PHY_POLL; err = mdiobus_register(re->mii_bus); if (err) goto err_free_bus; return 0; err_free_bus: kfree(re->mii_bus); return err; }
static int smsc95xx_bind(struct usbnet *dev) { struct smsc95xx_priv *pdata = NULL; int ret; printf(SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n"); ret = usbnet_get_endpoints(dev); if (ret < 0) { netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret); return ret; } dev->data[0] = (unsigned long)malloc(sizeof(struct smsc95xx_priv)); pdata = (struct smsc95xx_priv *)(dev->data[0]); if (!pdata) { netdev_warn(dev->net, "Unable to allocate struct smsc95xx_priv\n"); return -ENOMEM; } pdata->use_tx_csum = DEFAULT_TX_CSUM_ENABLE; pdata->use_rx_csum = DEFAULT_RX_CSUM_ENABLE; /* Init all registers */ ret = smsc95xx_reset(dev); dev->edev.get_ethaddr = smsc95xx_get_ethaddr; dev->edev.set_ethaddr = smsc95xx_set_ethaddr; mdiobus_register(&dev->miibus); return 0; }
static int tc_mii_init(struct net_device *dev) { struct tc35815_local *lp = netdev_priv(dev); int err; lp->mii_bus = mdiobus_alloc(); if (lp->mii_bus == NULL) { err = -ENOMEM; goto err_out; } lp->mii_bus->name = "tc35815_mii_bus"; lp->mii_bus->read = tc_mdio_read; lp->mii_bus->write = tc_mdio_write; snprintf(lp->mii_bus->id, MII_BUS_ID_SIZE, "%x", (lp->pci_dev->bus->number << 8) | lp->pci_dev->devfn); lp->mii_bus->priv = dev; lp->mii_bus->parent = &lp->pci_dev->dev; err = mdiobus_register(lp->mii_bus); if (err) goto err_out_free_mii_bus; err = tc_mii_probe(dev); if (err) goto err_out_unregister_bus; return 0; err_out_unregister_bus: mdiobus_unregister(lp->mii_bus); err_out_free_mii_bus: mdiobus_free(lp->mii_bus); err_out: return err; }
static int bgmac_mii_register(struct bgmac *bgmac) { struct mii_bus *mii_bus; struct phy_device *phy_dev; char bus_id[MII_BUS_ID_SIZE + 3]; int i, err = 0; mii_bus = mdiobus_alloc(); if (!mii_bus) return -ENOMEM; mii_bus->name = "bgmac mii bus"; sprintf(mii_bus->id, "%s-%d-%d", "bgmac", bgmac->core->bus->num, bgmac->core->core_unit); mii_bus->priv = bgmac; mii_bus->read = bgmac_mii_read; mii_bus->write = bgmac_mii_write; mii_bus->parent = &bgmac->core->dev; mii_bus->phy_mask = ~(1 << bgmac->phyaddr); mii_bus->irq = kmalloc_array(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL); if (!mii_bus->irq) { err = -ENOMEM; goto err_free_bus; } for (i = 0; i < PHY_MAX_ADDR; i++) mii_bus->irq[i] = PHY_POLL; err = mdiobus_register(mii_bus); if (err) { bgmac_err(bgmac, "Registration of mii bus failed\n"); goto err_free_irq; } bgmac->mii_bus = mii_bus; /* Connect to the PHY */ snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, mii_bus->id, bgmac->phyaddr); phy_dev = phy_connect(bgmac->net_dev, bus_id, &bgmac_adjust_link, PHY_INTERFACE_MODE_MII); if (IS_ERR(phy_dev)) { bgmac_err(bgmac, "PHY connecton failed\n"); err = PTR_ERR(phy_dev); goto err_unregister_bus; } bgmac->phy_dev = phy_dev; return err; err_unregister_bus: mdiobus_unregister(mii_bus); err_free_irq: kfree(mii_bus->irq); err_free_bus: mdiobus_free(mii_bus); return err; }
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; bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL); if (!bitbang) goto out; bitbang->ctrl.ops = &bb_ops; new_bus = alloc_mdio_bitbang(&bitbang->ctrl); if (!new_bus) goto out_free_priv; new_bus->name = "CPM2 Bitbanged MII", ret = fs_mii_bitbang_init(new_bus, ofdev->node); if (ret) goto out_free_bus; 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->parent = &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_bus: free_mdio_bitbang(new_bus); out_free_priv: kfree(bitbang); out: return ret; }
/** * stmmac_mdio_register * @ndev: net device structure * Description: it registers the MII bus */ int stmmac_mdio_register(struct net_device *ndev) { int err = 0; struct mii_bus *new_bus; struct stmmac_priv *priv = netdev_priv(ndev); int addr, found; new_bus = mdiobus_alloc(); if (new_bus == NULL) return -ENOMEM; /* Assign IRQ to phy at address phy_addr */ if (priv->phy_addr != -1) new_bus->irq[priv->phy_addr] = priv->phy_irq; new_bus->name = "STMMAC MII Bus"; new_bus->read = &stmmac_mdio_read; new_bus->write = &stmmac_mdio_write; new_bus->reset = &stmmac_mdio_reset; snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", priv->plat->bus_id); new_bus->priv = ndev; new_bus->phy_mask = priv->phy_mask; new_bus->parent = priv->device; err = mdiobus_register(new_bus); if (err != 0) { pr_err("%s: Cannot register as MDIO bus\n", new_bus->name); goto bus_register_fail; } priv->mii = new_bus; found = 0; for (addr = 0; addr < 32; addr++) { struct phy_device *phydev = mdiobus_get_phy(new_bus, addr); if (phydev) { if (priv->phy_addr == -1) { priv->phy_addr = addr; phydev->irq = priv->phy_irq; new_bus->irq[addr] = priv->phy_irq; } if (addr == priv->phy_addr) { pr_info("%s: PHY ID %08x at %d IRQ %d (%s)%s\n", ndev->name, phydev->phy_id, addr, phydev->irq, phydev_name(phydev), (addr == priv->phy_addr) ? " active" : ""); } found = 1; } } if (!found) pr_warning("%s: No PHY found\n", ndev->name); return 0; bus_register_fail: kfree(new_bus); return err; }
static int bcm_sf2_mdio_register(struct dsa_switch *ds) { struct bcm_sf2_priv *priv = ds_to_priv(ds); struct device_node *dn; static int index; int err; /* Find our integrated MDIO bus node */ dn = of_find_compatible_node(NULL, NULL, "brcm,unimac-mdio"); priv->master_mii_bus = of_mdio_find_bus(dn); if (!priv->master_mii_bus) return -EPROBE_DEFER; get_device(&priv->master_mii_bus->dev); priv->master_mii_dn = dn; priv->slave_mii_bus = devm_mdiobus_alloc(ds->dev); if (!priv->slave_mii_bus) return -ENOMEM; priv->slave_mii_bus->priv = priv; priv->slave_mii_bus->name = "sf2 slave mii"; priv->slave_mii_bus->read = bcm_sf2_sw_mdio_read; priv->slave_mii_bus->write = bcm_sf2_sw_mdio_write; snprintf(priv->slave_mii_bus->id, MII_BUS_ID_SIZE, "sf2-%d", index++); priv->slave_mii_bus->dev.of_node = dn; /* Include the pseudo-PHY address to divert reads towards our * workaround. This is only required for 7445D0, since 7445E0 * disconnects the internal switch pseudo-PHY such that we can use the * regular SWITCH_MDIO master controller instead. * * Here we flag the pseudo PHY as needing special treatment and would * otherwise make all other PHY read/writes go to the master MDIO bus * controller that comes with this switch backed by the "mdio-unimac" * driver. */ if (of_machine_is_compatible("brcm,bcm7445d0")) priv->indir_phy_mask |= (1 << BRCM_PSEUDO_PHY_ADDR); else priv->indir_phy_mask = 0; ds->phys_mii_mask = priv->indir_phy_mask; ds->slave_mii_bus = priv->slave_mii_bus; priv->slave_mii_bus->parent = ds->dev->parent; priv->slave_mii_bus->phy_mask = ~priv->indir_phy_mask; if (dn) err = of_mdiobus_register(priv->slave_mii_bus, dn); else err = mdiobus_register(priv->slave_mii_bus); if (err) of_node_put(dn); return err; }
/* * Initialize device structure. Returns success if * initialization succeeded. */ static int gfar_probe(struct device_d *dev) { struct gfar_info_struct *gfar_info = dev->platform_data; struct eth_device *edev; struct gfar_private *priv; size_t size; char *p; priv = xzalloc(sizeof(struct gfar_private)); if (NULL == priv) return -ENODEV; edev = &priv->edev; priv->regs = dev_request_mem_region(dev, 0); priv->phyregs = dev_request_mem_region(dev, 1); priv->phyregs_sgmii = dev_request_mem_region(dev, 2); priv->phyaddr = gfar_info->phyaddr; priv->tbicr = gfar_info->tbicr; priv->tbiana = gfar_info->tbiana; /* * Allocate descriptors 64-bit aligned. Descriptors * are 8 bytes in size. */ size = ((TX_BUF_CNT * sizeof(struct txbd8)) + (RX_BUF_CNT * sizeof(struct rxbd8))) + BUF_ALIGN; p = (char *)xmemalign(BUF_ALIGN, size); priv->txbd = (struct txbd8 *)p; priv->rxbd = (struct rxbd8 *)(p + (TX_BUF_CNT * sizeof(struct txbd8))); edev->priv = priv; edev->init = gfar_init; edev->open = gfar_open; edev->halt = gfar_halt; edev->send = gfar_send; edev->recv = gfar_recv; edev->get_ethaddr = gfar_get_ethaddr; edev->set_ethaddr = gfar_set_ethaddr; edev->parent = dev; setbits_be32(priv->regs + GFAR_MACCFG1_OFFSET, GFAR_MACCFG1_SOFT_RESET); udelay(2); clrbits_be32(priv->regs + GFAR_MACCFG1_OFFSET, GFAR_MACCFG1_SOFT_RESET); priv->miibus.read = gfar_miiphy_read; priv->miibus.write = gfar_miiphy_write; priv->miibus.priv = priv; priv->miibus.parent = dev; gfar_init_phy(edev); mdiobus_register(&priv->miibus); return eth_register(edev); }
static int lpc_mii_init(struct netdata_local *pldat) { int err = -ENXIO, i; pldat->mii_bus = mdiobus_alloc(); if (!pldat->mii_bus) { err = -ENOMEM; goto err_out; } /* Setup MII mode */ if (lpc_phy_interface_mode(&pldat->pdev->dev) == PHY_INTERFACE_MODE_MII) writel(LPC_COMMAND_PASSRUNTFRAME, LPC_ENET_COMMAND(pldat->net_base)); else { writel((LPC_COMMAND_PASSRUNTFRAME | LPC_COMMAND_RMII), LPC_ENET_COMMAND(pldat->net_base)); writel(LPC_SUPP_RESET_RMII, LPC_ENET_SUPP(pldat->net_base)); } pldat->mii_bus->name = "lpc_mii_bus"; pldat->mii_bus->read = &lpc_mdio_read; pldat->mii_bus->write = &lpc_mdio_write; pldat->mii_bus->reset = &lpc_mdio_reset; snprintf(pldat->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x", pldat->pdev->name, pldat->pdev->id); pldat->mii_bus->priv = pldat; pldat->mii_bus->parent = &pldat->pdev->dev; pldat->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL); if (!pldat->mii_bus->irq) { err = -ENOMEM; goto err_out_1; } for (i = 0; i < PHY_MAX_ADDR; i++) pldat->mii_bus->irq[i] = PHY_POLL; platform_set_drvdata(pldat->pdev, pldat->mii_bus); if (mdiobus_register(pldat->mii_bus)) goto err_out_free_mdio_irq; if (lpc_mii_probe(pldat->ndev) != 0) goto err_out_unregister_bus; return 0; err_out_unregister_bus: mdiobus_unregister(pldat->mii_bus); err_out_free_mdio_irq: kfree(pldat->mii_bus->irq); err_out_1: mdiobus_free(pldat->mii_bus); err_out: return err; }
static int __init octeon_mdiobus_probe(struct platform_device *pdev) { struct octeon_mdiobus *bus; union cvmx_smix_en smi_en; int i; int err = -ENOENT; bus = devm_kzalloc(&pdev->dev, sizeof(*bus), GFP_KERNEL); if (!bus) return -ENOMEM; /* The platform_device id is our unit number. */ bus->unit = pdev->id; bus->mii_bus = mdiobus_alloc(); if (!bus->mii_bus) goto err; smi_en.u64 = 0; smi_en.s.en = 1; cvmx_write_csr(CVMX_SMIX_EN(bus->unit), smi_en.u64); /* * Standard Octeon evaluation boards don't support phy * interrupts, we need to poll. */ for (i = 0; i < PHY_MAX_ADDR; i++) bus->phy_irq[i] = PHY_POLL; bus->mii_bus->priv = bus; bus->mii_bus->irq = bus->phy_irq; bus->mii_bus->name = "mdio-octeon"; snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%x", bus->unit); bus->mii_bus->parent = &pdev->dev; bus->mii_bus->read = octeon_mdiobus_read; bus->mii_bus->write = octeon_mdiobus_write; dev_set_drvdata(&pdev->dev, bus); err = mdiobus_register(bus->mii_bus); if (err) goto err_register; dev_info(&pdev->dev, "Version " DRV_VERSION "\n"); return 0; err_register: mdiobus_free(bus->mii_bus); err: devm_kfree(&pdev->dev, bus); smi_en.u64 = 0; cvmx_write_csr(CVMX_SMIX_EN(bus->unit), smi_en.u64); return err; }
static int __devinit fs_enet_fec_mdio_probe(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct fs_mii_fec_platform_info *pdata; struct mii_bus *new_bus; struct fec_info *fec; int err = 0; if (NULL == dev) return -EINVAL; new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL); if (NULL == new_bus) return -ENOMEM; fec = kzalloc(sizeof(struct fec_info), GFP_KERNEL); if (NULL == fec) return -ENOMEM; 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, snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id); pdata = (struct fs_mii_fec_platform_info *)pdev->dev.platform_data; if (NULL == pdata) { printk(KERN_ERR "fs_enet FEC mdio %d: Missing platform data!\n", pdev->id); return -ENODEV; } /*set up workspace*/ fs_mii_fec_init(fec, pdata); new_bus->priv = fec; new_bus->irq = pdata->irq; new_bus->dev = dev; dev_set_drvdata(dev, new_bus); err = mdiobus_register(new_bus); if (0 != err) { printk (KERN_ERR "%s: Cannot register as MDIO bus\n", new_bus->name); goto bus_register_fail; } return 0; bus_register_fail: kfree(new_bus); return err; }
static int mdio_mux_iproc_probe(struct platform_device *pdev) { struct iproc_mdiomux_desc *md; struct mii_bus *bus; struct resource *res; int rc; md = devm_kzalloc(&pdev->dev, sizeof(*md), GFP_KERNEL); if (!md) return -ENOMEM; md->dev = &pdev->dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); md->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(md->base)) { dev_err(&pdev->dev, "failed to ioremap register\n"); return PTR_ERR(md->base); } md->mii_bus = mdiobus_alloc(); if (!md->mii_bus) { dev_err(&pdev->dev, "mdiomux bus alloc failed\n"); return -ENOMEM; } bus = md->mii_bus; bus->priv = md; bus->name = "iProc MDIO mux bus"; snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id); bus->parent = &pdev->dev; bus->read = iproc_mdiomux_read; bus->write = iproc_mdiomux_write; bus->phy_mask = ~0; bus->dev.of_node = pdev->dev.of_node; rc = mdiobus_register(bus); if (rc) { dev_err(&pdev->dev, "mdiomux registration failed\n"); goto out; } platform_set_drvdata(pdev, md); rc = mdio_mux_init(md->dev, mdio_mux_iproc_switch_fn, &md->mux_handle, md, md->mii_bus); if (rc) { dev_info(md->dev, "mdiomux initialization failed\n"); goto out; } dev_info(md->dev, "iProc mdiomux registered\n"); return 0; out: mdiobus_free(bus); return rc; }
static int __devinit bfin_mii_bus_probe(struct platform_device *pdev) { struct mii_bus *miibus; int rc, i; /* * We are setting up a network card, * so set the GPIO pins to Ethernet mode */ rc = peripheral_request_list(pin_req, DRV_NAME); if (rc) { dev_err(&pdev->dev, "Requesting peripherals failed!\n"); return rc; } rc = -ENOMEM; miibus = mdiobus_alloc(); if (miibus == NULL) goto out_err_alloc; miibus->read = bfin_mdiobus_read; miibus->write = bfin_mdiobus_write; miibus->reset = bfin_mdiobus_reset; miibus->parent = &pdev->dev; miibus->name = "bfin_mii_bus"; snprintf(miibus->id, MII_BUS_ID_SIZE, "0"); miibus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL); if (miibus->irq == NULL) goto out_err_alloc; for (i = 0; i < PHY_MAX_ADDR; ++i) miibus->irq[i] = PHY_POLL; rc = mdiobus_register(miibus); if (rc) { dev_err(&pdev->dev, "Cannot register MDIO bus!\n"); goto out_err_mdiobus_register; } platform_set_drvdata(pdev, miibus); return 0; out_err_mdiobus_register: mdiobus_free(miibus); out_err_alloc: peripheral_free_list(pin_req); return rc; }
/** * @brief Initialize and register MDIO bus * @param[in] pointer to nss_gmac_dev * @return 0 on Success */ int32_t nss_gmac_init_mdiobus(struct nss_gmac_dev *gmacdev) { struct mii_bus *miibus = NULL; struct phy_device *phydev = NULL; miibus = mdiobus_alloc(); if (miibus == NULL) return -ENOMEM; miibus->name = "nss gmac mdio bus"; snprintf(miibus->id, MII_BUS_ID_SIZE, "mdiobus%x", gmacdev->macid); miibus->priv = (void *)gmacdev; miibus->read = nss_gmac_mdiobus_read; miibus->write = nss_gmac_mdiobus_write; miibus->reset = nss_gmac_mdiobus_reset; mutex_init(&(miibus->mdio_lock)); miibus->parent = &(gmacdev->pdev->dev); phy_irq[gmacdev->phy_base] = PHY_POLL; miibus->irq = phy_irq; miibus->phy_mask = ~((uint32_t)(1 << gmacdev->phy_base)); if (mdiobus_register(miibus) != 0) { mdiobus_free(miibus); netdev_dbg(gmacdev->netdev, "%s: mdiobus_reg failed\n", __func__); return -EIO; } phydev = miibus->phy_map[gmacdev->phy_base]; if (!phydev) { netdev_dbg(gmacdev->netdev, "%s: No phy device\n", __func__); mdiobus_unregister(miibus); mdiobus_free(miibus); return -ENODEV; } phydev->interface = gmacdev->phy_mii_type; gmacdev->miibus = miibus; return 0; }
static int mvebu_mdio_probe(struct device_d *dev) { struct mdio_priv *priv; priv = xzalloc(sizeof(*priv)); dev->priv = priv; priv->regs = dev_get_mem_region(dev, 0); if (!priv->regs) return -ENOMEM; priv->clk = clk_get(dev, NULL); if (!IS_ERR(priv->clk)) clk_enable(priv->clk); priv->miibus.dev.device_node = dev->device_node; priv->miibus.priv = priv; priv->miibus.parent = dev; priv->miibus.read = mvebu_mdio_read; priv->miibus.write = mvebu_mdio_write; return mdiobus_register(&priv->miibus); }
static int gfar_tbiphy_probe(struct device_d *dev) { struct gfar_phy *phy; int ret; phy = xzalloc(sizeof(*phy)); phy->dev = dev; phy->regs = dev_get_mem_region(dev, 0); if (IS_ERR(phy->regs)) return PTR_ERR(phy->regs); phy->miibus.read = gfar_miiphy_read; phy->miibus.write = gfar_miiphy_write; phy->miibus.priv = phy; phy->miibus.parent = dev; dev->priv = phy; ret = mdiobus_register(&phy->miibus); if (ret) return ret; return 0; }
static int yatse_mdio_register(struct yatse_private *priv){ struct mii_bus *mdio; struct yatse_mdio_priv *mdio_priv; int ret; int i; mdio = mdiobus_alloc(); if(!mdio) return -ENOMEM; mdio->name = "yatse MII bus"; mdio->read = &yatse_mdio_read; mdio->write = &yatse_mdio_write; snprintf(mdio->id, MII_BUS_ID_SIZE, "%u", priv->config->mii_id); mdio->priv = kmalloc(sizeof(*mdio_priv), GFP_KERNEL); if(!mdio->priv) return -ENOMEM; mdio_priv = mdio->priv; mdio_priv->mac = priv->mac; spin_lock_init(&mdio_priv->lock); for(i = 0;i < 32;i++){ mdio_priv->irqs[i] = priv->phy_irq; } mdio->irq = (void *)&mdio_priv->irqs; ret = mdiobus_register(mdio); if(ret){ printk(KERN_ERR "%s:%d: mdiobus_register() failed\n", __FILE__, __LINE__); mdiobus_free(mdio); return ret; } return yatse_detect_phys(priv, mdio); }
/** * gmac_mdio_register * @ndev: net device structure * Description: it registers the MII bus */ int gmac_mdio_register(struct net_device *ndev) { int err = 0; struct mii_bus *new_bus; int *irqlist; struct gmac_priv *priv = netdev_priv(ndev); struct gmac_mdio_bus_data *mdio_bus_data = priv->plat->mdio_bus_data; int addr, found; if (!mdio_bus_data) return 0; new_bus = mdiobus_alloc(); if (new_bus == NULL) return -ENOMEM; if (mdio_bus_data->irqs) irqlist = mdio_bus_data->irqs; else irqlist = priv->mii_irq; new_bus->name = "sunxi_gmac"; new_bus->read = &gmac_mdio_read; new_bus->write = &gmac_mdio_write; new_bus->reset = &gmac_mdio_reset; snprintf(new_bus->id, MII_BUS_ID_SIZE, "%s-%x", new_bus->name, mdio_bus_data->bus_id); new_bus->priv = ndev; new_bus->irq = irqlist; new_bus->phy_mask = mdio_bus_data->phy_mask; new_bus->parent = priv->device; err = mdiobus_register(new_bus); if (err != 0) { printk(KERN_ERR "%s: Cannot register as MDIO bus\n", new_bus->name); goto bus_register_fail; } priv->mii = new_bus; found = 0; for (addr = 0; addr < PHY_MAX_ADDR; addr++) { struct phy_device *phydev = new_bus->phy_map[addr]; if (phydev) { int act = 0; char irq_num[4]; char *irq_str; /* * If an IRQ was provided to be assigned after * the bus probe, do it here. */ if ((mdio_bus_data->irqs == NULL) && (mdio_bus_data->probed_phy_irq > 0)) { irqlist[addr] = mdio_bus_data->probed_phy_irq; phydev->irq = mdio_bus_data->probed_phy_irq; } /* * If we're going to bind the MAC to this PHY bus, * and no PHY number was provided to the MAC, * use the one probed here. */ if ((priv->plat->bus_id == mdio_bus_data->bus_id) && (priv->plat->phy_addr == -1)) priv->plat->phy_addr = addr; act = (priv->plat->bus_id == mdio_bus_data->bus_id) && (priv->plat->phy_addr == addr); switch (phydev->irq) { case PHY_POLL: irq_str = "POLL"; break; case PHY_IGNORE_INTERRUPT: irq_str = "IGNORE"; break; default: sprintf(irq_num, "%d", phydev->irq); irq_str = irq_num; break; } //pr_info("%s: PHY ID %08x at %d IRQ %s (%s)%s\n", // ndev->name, phydev->phy_id, addr, // irq_str, dev_name(&phydev->dev), // act ? " active" : ""); found = 1; } } if (!found){ printk(KERN_WARNING "%s: No PHY found\n", ndev->name); err = -ENXIO; goto out_err; } return 0; out_err: mdiobus_unregister(new_bus); bus_register_fail: mdiobus_free(new_bus); priv->mii = NULL; return err; }
static int __devinit s6gmac_probe(struct platform_device *pdev) { struct net_device *dev; struct s6gmac *pd; int res; unsigned long i; struct mii_bus *mb; dev = alloc_etherdev(sizeof(*pd)); if (!dev) { printk(KERN_ERR DRV_PRMT "etherdev alloc failed, aborting.\n"); return -ENOMEM; } dev->open = s6gmac_open; dev->stop = s6gmac_stop; dev->hard_start_xmit = s6gmac_tx; dev->tx_timeout = s6gmac_tx_timeout; dev->watchdog_timeo = HZ; dev->get_stats = s6gmac_stats; dev->irq = platform_get_irq(pdev, 0); pd = netdev_priv(dev); memset(pd, 0, sizeof(*pd)); spin_lock_init(&pd->lock); pd->reg = platform_get_resource(pdev, IORESOURCE_MEM, 0)->start; i = platform_get_resource(pdev, IORESOURCE_DMA, 0)->start; pd->tx_dma = DMA_MASK_DMAC(i); pd->tx_chan = DMA_INDEX_CHNL(i); i = platform_get_resource(pdev, IORESOURCE_DMA, 1)->start; pd->rx_dma = DMA_MASK_DMAC(i); pd->rx_chan = DMA_INDEX_CHNL(i); pd->io = platform_get_resource(pdev, IORESOURCE_IO, 0)->start; res = request_irq(dev->irq, s6gmac_interrupt, 0, dev->name, dev); if (res) { printk(KERN_ERR DRV_PRMT "irq request failed: %d\n", dev->irq); goto errirq; } res = register_netdev(dev); if (res) { printk(KERN_ERR DRV_PRMT "error registering device %s\n", dev->name); goto errdev; } mb = mdiobus_alloc(); if (!mb) { printk(KERN_ERR DRV_PRMT "error allocating mii bus\n"); goto errmii; } mb->name = "s6gmac_mii"; mb->read = s6mii_read; mb->write = s6mii_write; mb->reset = s6mii_reset; mb->priv = pd; snprintf(mb->id, MII_BUS_ID_SIZE, "0"); mb->phy_mask = ~(1 << 0); mb->irq = &pd->mii.irq[0]; for (i = 0; i < PHY_MAX_ADDR; i++) { int n = platform_get_irq(pdev, i + 1); if (n < 0) n = PHY_POLL; pd->mii.irq[i] = n; } mdiobus_register(mb); pd->mii.bus = mb; res = s6gmac_phy_start(dev); if (res) return res; platform_set_drvdata(pdev, dev); return 0; errmii: unregister_netdev(dev); errdev: free_irq(dev->irq, dev); errirq: free_netdev(dev); return res; }
static int uec_mdio_probe(struct of_device *ofdev, const struct of_device_id *match) { struct device *device = &ofdev->dev; struct device_node *np = ofdev->node, *tempnp = NULL; struct device_node *child = NULL; struct ucc_mii_mng __iomem *regs; struct mii_bus *new_bus; struct resource res; int k, err = 0; new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL); if (NULL == new_bus) return -ENOMEM; new_bus->name = "UCC Ethernet Controller MII Bus"; new_bus->read = &uec_mdio_read; new_bus->write = &uec_mdio_write; new_bus->reset = &uec_mdio_reset; memset(&res, 0, sizeof(res)); err = of_address_to_resource(np, 0, &res); if (err) goto reg_map_fail; new_bus->id = res.start; new_bus->irq = kmalloc(32 * sizeof(int), GFP_KERNEL); if (NULL == new_bus->irq) { err = -ENOMEM; goto reg_map_fail; } for (k = 0; k < 32; k++) new_bus->irq[k] = PHY_POLL; while ((child = of_get_next_child(np, child)) != NULL) { int irq = irq_of_parse_and_map(child, 0); if (irq != NO_IRQ) { const u32 *id = of_get_property(child, "reg", NULL); new_bus->irq[*id] = irq; } } /* Set the base address */ regs = ioremap(res.start, sizeof(struct ucc_mii_mng)); if (NULL == regs) { err = -ENOMEM; goto ioremap_fail; } new_bus->priv = (void __force *)regs; new_bus->dev = device; dev_set_drvdata(device, new_bus); /* Read MII management master from device tree */ while ((tempnp = of_find_compatible_node(tempnp, "network", "ucc_geth")) != NULL) { struct resource tempres; err = of_address_to_resource(tempnp, 0, &tempres); if (err) goto bus_register_fail; /* if our mdio regs fall within this UCC regs range */ if ((res.start >= tempres.start) && (res.end <= tempres.end)) { /* set this UCC to be the MII master */ const u32 *id = of_get_property(tempnp, "device-id", NULL); if (id == NULL) goto bus_register_fail; ucc_set_qe_mux_mii_mng(*id - 1); /* assign the TBI an address which won't * conflict with the PHYs */ out_be32(®s->utbipar, UTBIPAR_INIT_TBIPA); break; } } err = mdiobus_register(new_bus); if (0 != err) { printk(KERN_ERR "%s: Cannot register as MDIO bus\n", new_bus->name); goto bus_register_fail; } return 0; bus_register_fail: iounmap(regs); ioremap_fail: kfree(new_bus->irq); reg_map_fail: kfree(new_bus); return err; }