/** * cvm_oct_phy_setup_device - setup the PHY * * @dev: Device to setup * * Returns Zero on success, negative on failure */ int cvm_oct_phy_setup_device(struct net_device *dev) { struct octeon_ethernet *priv = netdev_priv(dev); int phy_addr = cvmx_helper_board_get_mii_address(priv->port); if (phy_addr != -1) { char phy_id[20]; if (phy_addr & 0x100) snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, "1", phy_addr & 0xff); else snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, "0", phy_addr); priv->phydev = phy_connect(dev, phy_id, cvm_oct_adjust_link, 0, PHY_INTERFACE_MODE_GMII); if (IS_ERR(priv->phydev)) { priv->phydev = NULL; return -1; } priv->last_link = 0; phy_start_aneg(priv->phydev); } return 0; }
static int fs_init_phy(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); struct phy_device *phydev; u32 flags = fep->fpi->board_flags & FS_ENET_BRD_PHY_ANEG ? PHY_HAS_MAGICANEG : 0; fep->oldlink = 0; fep->oldspeed = 0; fep->oldduplex = -1; if(fep->fpi->bus_id) phydev = phy_connect(dev, fep->fpi->bus_id, &fs_adjust_link, flags); else { printk("No phy bus ID specified in BSP code\n"); return -EINVAL; } if (IS_ERR(phydev)) { printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); return PTR_ERR(phydev); } fep->phydev = phydev; return 0; }
static int zynq_phy_init(struct udevice *dev) { int ret; struct zynq_gem_priv *priv = dev_get_priv(dev); struct zynq_gem_regs *regs = priv->iobase; const u32 supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full; /* Enable only MDIO bus */ writel(ZYNQ_GEM_NWCTRL_MDEN_MASK, ®s->nwctrl); if (priv->interface != PHY_INTERFACE_MODE_SGMII) { ret = phy_detection(dev); if (ret) { printf("GEM PHY init failed\n"); return ret; } } priv->phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface); if (!priv->phydev) return -ENODEV; priv->phydev->supported = supported | ADVERTISED_Pause | ADVERTISED_Asym_Pause; priv->phydev->advertising = priv->phydev->supported; phy_config(priv->phydev); return 0; }
/* PHY init function */ static int sh_eth_phy_init(struct net_device *ndev) { struct sh_eth_private *mdp = netdev_priv(ndev); char phy_id[BUS_ID_SIZE]; struct phy_device *phydev = NULL; snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, mdp->mii_bus->id , mdp->phy_id); mdp->link = PHY_DOWN; mdp->speed = 0; mdp->duplex = -1; /* Try connect to PHY */ phydev = phy_connect(ndev, phy_id, &sh_eth_adjust_link, 0, PHY_INTERFACE_MODE_MII); if (IS_ERR(phydev)) { dev_err(&ndev->dev, "phy_connect failed\n"); return PTR_ERR(phydev); } dev_info(&ndev->dev, "attached phy %i to driver %s\n", phydev->addr, phydev->drv->name); mdp->phydev = phydev; return 0; }
static int mvneta_start(struct udevice *dev) { struct mvneta_port *pp = dev_get_priv(dev); struct phy_device *phydev; mvneta_port_power_up(pp, pp->phy_interface); if (!pp->init || pp->link == 0) { /* Set phy address of the port */ mvreg_write(pp, MVNETA_PHY_ADDR, pp->phyaddr); phydev = phy_connect(pp->bus, pp->phyaddr, dev, pp->phy_interface); pp->phydev = phydev; phy_config(phydev); phy_startup(phydev); if (!phydev->link) { printf("%s: No link.\n", phydev->dev->name); return -1; } /* Full init on first call */ mvneta_init(dev); pp->init = 1; } else { /* Upon all following calls, this is enough */ mvneta_port_up(pp); mvneta_port_enable(pp); } return 0; }
static int mii_probe(struct net_device *dev, int phy_mode) { struct bfin_mac_local *lp = netdev_priv(dev); struct phy_device *phydev; unsigned short sysctl; u32 sclk, mdc_div; /* Enable PHY output early */ if (!(bfin_read_VR_CTL() & CLKBUFOE)) bfin_write_VR_CTL(bfin_read_VR_CTL() | CLKBUFOE); sclk = get_sclk(); mdc_div = ((sclk / MDC_CLK) / 2) - 1; sysctl = bfin_read_EMAC_SYSCTL(); sysctl = (sysctl & ~MDCDIV) | SET_MDCDIV(mdc_div); bfin_write_EMAC_SYSCTL(sysctl); phydev = phy_find_first(lp->mii_bus); if (!phydev) { netdev_err(dev, "no phy device found\n"); return -ENODEV; } if (phy_mode != PHY_INTERFACE_MODE_RMII && phy_mode != PHY_INTERFACE_MODE_MII) { netdev_err(dev, "invalid phy interface mode\n"); return -EINVAL; } phydev = phy_connect(dev, phydev_name(phydev), &bfin_mac_adjust_link, phy_mode); if (IS_ERR(phydev)) { netdev_err(dev, "could not attach PHY\n"); return PTR_ERR(phydev); } /* mask with MAC supported features */ phydev->supported &= (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_Autoneg | SUPPORTED_Pause | SUPPORTED_Asym_Pause | SUPPORTED_MII | SUPPORTED_TP); phydev->advertising = phydev->supported; lp->old_link = 0; lp->old_speed = 0; lp->old_duplex = -1; lp->phydev = phydev; phy_attached_print(phydev, "mdc_clk=%dHz(mdc_div=%d)@sclk=%dMHz)\n", MDC_CLK, mdc_div, sclk / 1000000); return 0; }
static int octeon_mgmt_init_phy(struct net_device *netdev) { struct octeon_mgmt *p = netdev_priv(netdev); char phy_id[20]; if (octeon_is_simulation()) { /* No PHYs in the simulator. */ netif_carrier_on(netdev); return 0; } snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, "0", p->port); p->phydev = phy_connect(netdev, phy_id, octeon_mgmt_adjust_link, 0, PHY_INTERFACE_MODE_MII); if (IS_ERR(p->phydev)) { p->phydev = NULL; return -1; } phy_start_aneg(p->phydev); return 0; }
static int bcm_sf2_eth_init(struct eth_device *dev) { struct eth_info *eth = (struct eth_info *)(dev->priv); struct eth_dma *dma = &(eth->dma); struct phy_device *phydev; int rc = 0; int i; rc = eth->mac_init(dev); if (rc) { error("%s: Couldn't cofigure MAC!\n", __func__); return rc; } /* disable DMA */ dma->disable_dma(dma, MAC_DMA_RX); dma->disable_dma(dma, MAC_DMA_TX); eth->port_num = 0; debug("Connecting PHY 0...\n"); phydev = phy_connect(miiphy_get_dev_by_name(dev->name), 0, dev, eth->phy_interface); if (phydev != NULL) { eth->port[0] = phydev; eth->port_num += 1; } else { debug("No PHY found for port 0\n"); } for (i = 0; i < eth->port_num; i++) phy_config(eth->port[i]); return rc; }
/* * This function initializes the EMAC hardware. */ int keystone2_emac_initialize(struct eth_priv_t *eth_priv) { int res; struct eth_device *dev; struct phy_device *phy_dev; dev = malloc(sizeof(struct eth_device)); if (dev == NULL) return -1; memset(dev, 0, sizeof(struct eth_device)); strcpy(dev->name, eth_priv->int_name); dev->priv = eth_priv; keystone2_eth_read_mac_addr(dev); dev->iobase = 0; dev->init = keystone2_eth_open; dev->halt = keystone2_eth_close; dev->send = keystone2_eth_send_packet; dev->recv = keystone2_eth_rcv_packet; #ifdef CONFIG_MCAST_TFTP dev->mcast = keystone2_eth_bcast_addr; #endif eth_register(dev); /* Register MDIO bus if it's not registered yet */ if (!mdio_bus) { mdio_bus = mdio_alloc(); mdio_bus->read = keystone2_mdio_read; mdio_bus->write = keystone2_mdio_write; mdio_bus->reset = keystone2_mdio_reset; mdio_bus->priv = (void *)EMAC_MDIO_BASE_ADDR; sprintf(mdio_bus->name, "ethernet-mdio"); res = mdio_register(mdio_bus); if (res) return res; } #ifndef CONFIG_SOC_K2G keystone2_net_serdes_setup(); #endif /* Create phy device and bind it with driver */ #ifdef CONFIG_KSNET_MDIO_PHY_CONFIG_ENABLE phy_dev = phy_connect(mdio_bus, eth_priv->phy_addr, dev, eth_priv->phy_if); phy_config(phy_dev); #else phy_dev = phy_find_by_mask(mdio_bus, 1 << eth_priv->phy_addr, eth_priv->phy_if); phy_dev->dev = dev; #endif eth_priv->phy_dev = phy_dev; return 0; }
static int pic32_phy_init(struct pic32eth_dev *priv, struct udevice *dev) { struct mii_dev *mii; mii = miiphy_get_dev_by_name(PIC32_MDIO_NAME); /* find & connect PHY */ priv->phydev = phy_connect(mii, priv->phy_addr, dev, priv->phyif); if (!priv->phydev) { printf("%s: %s: Error, PHY connect\n", __FILE__, __func__); return 0; } /* Wait for phy to complete reset */ mdelay(10); /* configure supported modes */ priv->phydev->supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_Autoneg; priv->phydev->advertising = ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | ADVERTISED_Autoneg; priv->phydev->autoneg = AUTONEG_ENABLE; return 0; }
void ls2085a_handle_phy_interface_sgmii(int dpmac_id) { int lane, slot; struct mii_dev *bus; struct ccsr_gur __iomem *gur = (void *)CONFIG_SYS_FSL_GUTS_ADDR; int serdes1_prtcl = (in_le32(&gur->rcwsr[28]) & FSL_CHASSIS3_RCWSR28_SRDS1_PRTCL_MASK) >> FSL_CHASSIS3_RCWSR28_SRDS1_PRTCL_SHIFT; int serdes2_prtcl = (in_le32(&gur->rcwsr[28]) & FSL_CHASSIS3_RCWSR28_SRDS2_PRTCL_MASK) >> FSL_CHASSIS3_RCWSR28_SRDS2_PRTCL_SHIFT; switch (serdes1_prtcl) { } switch (serdes2_prtcl) { case 0x07: case 0x08: case 0x49: lane = serdes_get_first_lane(FSL_SRDS_2, SGMII9 + (dpmac_id - 9)); slot = lane_to_slot_fsm2[lane]; switch (++slot) { case 1: break; case 3: break; case 4: /* Slot housing a SGMII riser card? */ wriop_set_phy_address(dpmac_id, riser_phy_addr[dpmac_id - 9]); dpmac_info[dpmac_id].board_mux = EMI1_SLOT4; bus = mii_dev_for_muxval(EMI1_SLOT4); wriop_set_mdio(dpmac_id, bus); dpmac_info[dpmac_id].phydev = phy_connect( dpmac_info[dpmac_id].bus, dpmac_info[dpmac_id].phy_addr, NULL, dpmac_info[dpmac_id].enet_if); phy_config(dpmac_info[dpmac_id].phydev); break; case 5: break; case 6: /* Slot housing a SGMII riser card? */ wriop_set_phy_address(dpmac_id, riser_phy_addr[dpmac_id - 13]); dpmac_info[dpmac_id].board_mux = EMI1_SLOT6; bus = mii_dev_for_muxval(EMI1_SLOT6); wriop_set_mdio(dpmac_id, bus); break; } break; default: printf("qds: WRIOP: Unsupported SerDes Protocol 0x%02x\n", serdes2_prtcl); break; } }
/* Discover which PHY is attached to the device, and configure it * properly. If the PHY is not recognized, then return 0 * (failure). Otherwise, return 1 */ static int init_phy(struct eth_device *dev) { struct tsec_private *priv = (struct tsec_private *)dev->priv; struct phy_device *phydev; tsec_t *regs = priv->regs; u32 supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full); if (priv->flags & TSEC_GIGABIT) supported |= SUPPORTED_1000baseT_Full; /* Assign a Physical address to the TBI */ out_be32(®s->tbipa, CONFIG_SYS_TBIPA_VALUE); priv->interface = tsec_get_interface(priv); if (priv->interface == PHY_INTERFACE_MODE_SGMII) tsec_configure_serdes(priv); phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface); phydev->supported &= supported; phydev->advertising = phydev->supported; priv->phydev = phydev; phy_config(phydev); return 1; }
struct phy_device *of_phy_connect_fixed_link(struct net_device *dev, void (*hndlr)(struct net_device *), phy_interface_t iface) { struct device_node *net_np; char bus_id[MII_BUS_ID_SIZE + 3]; struct phy_device *phy; const __be32 *phy_id; int sz; if (!dev->dev.parent) return NULL; net_np = dev->dev.parent->of_node; if (!net_np) return NULL; phy_id = of_get_property(net_np, "fixed-link", &sz); if (!phy_id || sz < sizeof(*phy_id)) return NULL; sprintf(bus_id, PHY_ID_FMT, "fixed-0", be32_to_cpu(phy_id[0])); phy = phy_connect(dev, bus_id, hndlr, 0, iface); return IS_ERR(phy) ? NULL : phy; }
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 ramips_phy_connect_multi(struct raeth_priv *re) { struct net_device *netdev = re->netdev; struct ramips_eth_platform_data *pdata; struct phy_device *phydev = NULL; int phy_addr; int ret = 0; pdata = re->parent->platform_data; for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) { if (!(pdata->phy_mask & (1 << phy_addr))) continue; if (re->mii_bus->phy_map[phy_addr] == NULL) continue; RADEBUG("%s: PHY found at %s, uid=%08x\n", netdev->name, dev_name(&re->mii_bus->phy_map[phy_addr]->dev), re->mii_bus->phy_map[phy_addr]->phy_id); if (phydev == NULL) phydev = re->mii_bus->phy_map[phy_addr]; } if (!phydev) { netdev_err(netdev, "no PHY found with phy_mask=%08x\n", pdata->phy_mask); return -ENODEV; } re->phy_dev = phy_connect(netdev, dev_name(&phydev->dev), ramips_phy_link_adjust, 0, pdata->phy_if_mode); if (IS_ERR(re->phy_dev)) { netdev_err(netdev, "could not connect to PHY at %s\n", dev_name(&phydev->dev)); return PTR_ERR(re->phy_dev); } phydev->supported &= PHY_GBIT_FEATURES; phydev->advertising = phydev->supported; RADEBUG("%s: connected to PHY at %s [uid=%08x, driver=%s]\n", netdev->name, dev_name(&phydev->dev), phydev->phy_id, phydev->drv->name); re->link = 0; re->speed = 0; re->duplex = -1; re->rx_fc = 0; re->tx_fc = 0; return ret; }
static void fec_eth_phy_config(struct eth_device *dev) { #ifdef CONFIG_PHYLIB struct fec_priv *fec = (struct fec_priv *)dev->priv; struct phy_device *phydev; phydev = phy_connect(fec->bus, fec->phy_id, dev, PHY_INTERFACE_MODE_RGMII); if (phydev) { fec->phydev = phydev; phy_config(phydev); } #endif }
static int sh_eth_phy_config(struct sh_eth_dev *eth) { int port = eth->port, ret = 0; struct sh_eth_info *port_info = ð->port_info[port]; struct eth_device *dev = port_info->dev; struct phy_device *phydev; phydev = phy_connect(miiphy_get_dev_by_name(dev->name), port_info->phy_addr, dev, PHY_INTERFACE_MODE_MII); port_info->phydev = phydev; phy_config(phydev); return ret; }
static int bcma_phy_connect(struct bgmac *bgmac) { struct phy_device *phy_dev; char bus_id[MII_BUS_ID_SIZE + 3]; /* Connect to the PHY */ snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, bgmac->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)) { dev_err(bgmac->dev, "PHY connection failed\n"); return PTR_ERR(phy_dev); } return 0; }
static int init_phy(struct eth_device *dev) { struct fm_eth *fm_eth = dev->priv; #ifdef CONFIG_PHYLIB struct phy_device *phydev = NULL; u32 supported; #endif if (fm_eth->type == FM_ETH_1G_E) dtsec_init_phy(dev); #ifdef CONFIG_PHYLIB if (fm_eth->bus) { phydev = phy_connect(fm_eth->bus, fm_eth->phyaddr, dev, fm_eth->enet_if); if (!phydev) { printf("Failed to connect\n"); return -1; } } else { return 0; } if (fm_eth->type == FM_ETH_1G_E) { supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_1000baseT_Full); } else { supported = SUPPORTED_10000baseT_Full; if (tgec_is_fibre(dev)) phydev->port = PORT_FIBRE; } phydev->supported &= supported; phydev->advertising = phydev->supported; fm_eth->phydev = phydev; phy_config(phydev); #endif return 0; }
static inline int s6gmac_phy_start(struct net_device *dev) { struct s6gmac *pd = netdev_priv(dev); int i = 0; struct phy_device *p = NULL; while ((i < PHY_MAX_ADDR) && (!(p = pd->mii.bus->phy_map[i]))) i++; p = phy_connect(dev, dev_name(&p->dev), &s6gmac_adjust_link, 0, PHY_INTERFACE_MODE_RGMII); if (IS_ERR(p)) { printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); return PTR_ERR(p); } p->supported &= PHY_GBIT_FEATURES; p->advertising = p->supported; pd->phydev = p; return 0; }
static int tc_mii_probe(struct net_device *dev) { struct tc35815_local *lp = netdev_priv(dev); struct phy_device *phydev; u32 dropmask; phydev = phy_find_first(lp->mii_bus); if (!phydev) { printk(KERN_ERR "%s: no PHY found\n", dev->name); return -ENODEV; } /* attach the mac to the phy */ phydev = phy_connect(dev, phydev_name(phydev), &tc_handle_link_change, lp->chiptype == TC35815_TX4939 ? PHY_INTERFACE_MODE_RMII : PHY_INTERFACE_MODE_MII); if (IS_ERR(phydev)) { printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); return PTR_ERR(phydev); } phy_attached_info(phydev); /* mask with MAC supported features */ phydev->supported &= PHY_BASIC_FEATURES; dropmask = 0; if (options.speed == 10) dropmask |= SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full; else if (options.speed == 100) dropmask |= SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full; if (options.duplex == 1) dropmask |= SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Full; else if (options.duplex == 2) dropmask |= SUPPORTED_10baseT_Half | SUPPORTED_100baseT_Half; phydev->supported &= ~dropmask; phydev->advertising = phydev->supported; lp->link = 0; lp->speed = 0; lp->duplex = -1; return 0; }
/* * Discover which PHY is attached to the device, and configure it * properly. If the PHY is not recognized, then return 0 * (failure). Otherwise, return 1 */ static int ll_temac_phy_init(struct eth_device *dev) { struct ll_temac *ll_temac = dev->priv; struct phy_device *phydev; unsigned int supported = PHY_GBIT_FEATURES; /* interface - look at driver/net/tsec.c */ phydev = phy_connect(ll_temac->bus, ll_temac->phyaddr, dev, PHY_INTERFACE_MODE_NONE); phydev->supported &= supported; phydev->advertising = phydev->supported; ll_temac->phydev = phydev; phy_config(phydev); return 1; }
static int axiemac_phy_init(struct udevice *dev) { u16 phyreg; u32 i, ret; struct axidma_priv *priv = dev_get_priv(dev); struct axi_regs *regs = priv->iobase; struct phy_device *phydev; u32 supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full; /* Set default MDIO divisor */ writel(XAE_MDIO_DIV_DFT | XAE_MDIO_MC_MDIOEN_MASK, ®s->mdio_mc); if (priv->phyaddr == -1) { /* Detect the PHY address */ for (i = 31; i >= 0; i--) { ret = phyread(priv, i, PHY_DETECT_REG, &phyreg); if (!ret && (phyreg != 0xFFFF) && ((phyreg & PHY_DETECT_MASK) == PHY_DETECT_MASK)) { /* Found a valid PHY address */ priv->phyaddr = i; debug("axiemac: Found valid phy address, %x\n", i); break; } } } /* Interface - look at tsec */ phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface); phydev->supported &= supported; phydev->advertising = phydev->supported; priv->phydev = phydev; phy_config(phydev); return 0; }
static int yatse_init_phy(struct net_device *ndev){ struct yatse_private *priv = netdev_priv(ndev); char phy_id[MII_BUS_ID_SIZE]; char mii_id[MII_BUS_ID_SIZE]; snprintf(mii_id, MII_BUS_ID_SIZE, "%x", priv->config->mii_id); snprintf(phy_id, MII_BUS_ID_SIZE, PHY_ID_FMT, mii_id, priv->phy_addr); priv->phydev = phy_connect(ndev, phy_id, &yatse_adjust_link, 0, priv->config->interface); if(IS_ERR(priv->phydev)){ printk(KERN_ERR "%s:%d: phy_connect() failed\n", __FILE__, __LINE__); return PTR_ERR(priv->phydev); } priv->phydev->supported &= priv->config->supported_modes; priv->phydev->advertising = priv->phydev->supported; return 0; }
/** * stmmac_init_phy - PHY initialization * @dev: net device structure * Description: it initializes the driver's PHY state, and attaches the PHY * to the mac driver. * Return value: * 0 on success */ static int stmmac_init_phy(struct net_device *dev) { struct stmmac_priv *priv = netdev_priv(dev); struct phy_device *phydev; char phy_id[MII_BUS_ID_SIZE + 3]; char bus_id[MII_BUS_ID_SIZE]; priv->oldlink = 0; priv->speed = 0; priv->oldduplex = -1; snprintf(bus_id, MII_BUS_ID_SIZE, "%x", priv->plat->bus_id); snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id, priv->plat->phy_addr); pr_debug("stmmac_init_phy: trying to attach to %s\n", phy_id); phydev = phy_connect(dev, phy_id, &stmmac_adjust_link, 0, priv->plat->interface); if (IS_ERR(phydev)) { pr_err("%s: Could not attach to PHY\n", dev->name); return PTR_ERR(phydev); } /* * Broken HW is sometimes missing the pull-up resistor on the * MDIO line, which results in reads to non-existent devices returning * 0 rather than 0xffff. Catch this here and treat 0 as a non-existent * device as well. * Note: phydev->phy_id is the result of reading the UID PHY registers. */ if (phydev->phy_id == 0) { phy_disconnect(phydev); return -ENODEV; } pr_debug("stmmac_init_phy: %s: attached to PHY (UID 0x%x)" " Link = %d\n", dev->name, phydev->phy_id, phydev->link); priv->phydev = phydev; return 0; }
static int init_phy(struct eth_device *dev) { struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv; struct phy_device *phydev = NULL; struct mii_dev *bus; bus = wriop_get_mdio(priv->dpmac_id); if (bus == NULL) return 0; phydev = phy_connect(bus, wriop_get_phy_address(priv->dpmac_id), dev, wriop_get_enet_if(priv->dpmac_id)); if (!phydev) { printf("Failed to connect\n"); return -1; } priv->phydev = phydev; return phy_config(phydev); }
static int ftgmac100_phy_init(struct udevice *dev) { struct ftgmac100_data *priv = dev_get_priv(dev); struct phy_device *phydev; int ret; phydev = phy_connect(priv->bus, priv->phy_addr, dev, priv->phy_mode); if (!phydev) return -ENODEV; phydev->supported &= PHY_GBIT_FEATURES; if (priv->max_speed) { ret = phy_set_supported(phydev, priv->max_speed); if (ret) return ret; } phydev->advertising = phydev->supported; priv->phydev = phydev; phy_config(phydev); return 0; }
static int lpc_mii_probe(struct net_device *ndev) { struct netdata_local *pldat = netdev_priv(ndev); struct phy_device *phydev = phy_find_first(pldat->mii_bus); if (!phydev) { netdev_err(ndev, "no PHY found\n"); return -ENODEV; } /* Attach to the PHY */ if (lpc_phy_interface_mode(&pldat->pdev->dev) == PHY_INTERFACE_MODE_MII) netdev_info(ndev, "using MII interface\n"); else netdev_info(ndev, "using RMII interface\n"); phydev = phy_connect(ndev, dev_name(&phydev->dev), &lpc_handle_link_change, lpc_phy_interface_mode(&pldat->pdev->dev)); if (IS_ERR(phydev)) { netdev_err(ndev, "Could not attach to PHY\n"); return PTR_ERR(phydev); } /* mask with MAC supported features */ phydev->supported &= PHY_BASIC_FEATURES; phydev->advertising = phydev->supported; pldat->link = 0; pldat->speed = 0; pldat->duplex = -1; pldat->phy_dev = phydev; netdev_info(ndev, "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n", phydev->drv->name, dev_name(&phydev->dev), phydev->irq); return 0; }
static int pci_eth_mii_probe(struct net_device *dev) { struct pci_eth_private *priv = netdev_priv(dev); struct phy_device *phydev = NULL; phydev = phy_find_first(priv->mii_bus); if (!phydev) { dev_err(&priv->pdev->dev, "no PHY found\n"); return -ENODEV; } phydev = phy_connect(dev, phydev_name(phydev), &pci_eth_adjust_link, PHY_INTERFACE_MODE_MII); if (IS_ERR(phydev)) { dev_err(&priv->pdev->dev, "could not attach to PHY\n"); return PTR_ERR(phydev); } /* mask with MAC supported features */ phydev->supported &= (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | SUPPORTED_Autoneg | SUPPORTED_MII | SUPPORTED_TP); phydev->advertising = phydev->supported; priv->phydev = phydev; priv->old_link = 0; priv->old_duplex = -1; phy_attached_info(phydev); return 0; }
static int fs_init_phy(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); struct phy_device *phydev; fep->oldlink = 0; fep->oldspeed = 0; fep->oldduplex = -1; if(fep->fpi->bus_id) phydev = phy_connect(dev, fep->fpi->bus_id, &fs_adjust_link, 0, PHY_INTERFACE_MODE_MII); else { printk("No phy bus ID specified in BSP code\n"); return -EINVAL; } if (IS_ERR(phydev)) { printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); return PTR_ERR(phydev); } fep->phydev = phydev; return 0; }