int lsi_80227_init(struct net_device *dev, int phy_addr)
{
if (au1000_debug > 4)
printk("lsi_80227_init\n");
/* restart auto-negotiation */
mdio_write(dev, phy_addr, MII_CONTROL,
MII_CNTL_F100 | MII_CNTL_AUTO | MII_CNTL_RST_AUTO); // | MII_CNTL_FDX);
mdelay(1);
/* set up LEDs to correct display */
mdio_write(dev, phy_addr, 17, 0xffc0);
if (au1000_debug > 4)
dump_mii(dev, phy_addr);
return 0;
}
int lsi_80227_init(struct net_device *dev, int phy_addr)
{
if (au1000_debug > 4)
printk("lsi_80227_init\n");
/* restart auto-negotiation */
mdio_write(dev, phy_addr, 0, 0x3200);
mdelay(1);
/* set up LEDs to correct display */
mdio_write(dev, phy_addr, 17, 0xffc0);
if (au1000_debug > 4)
dump_mii(dev, phy_addr);
return 0;
}
static void robo_write32(__u8 page, __u8 reg, __u32 val32)
{
/* write data */
mdio_write(ROBO_PHY_ADDR, REG_MII_DATA0, val32 & 65535);
mdio_write(ROBO_PHY_ADDR, REG_MII_DATA0 + 1, val32 >> 16);
robo_reg(page, reg, REG_MII_ADDR_WRITE);
}
uint16
sis900_resetPHY(struct sis_info *info)
{
uint16 status = mdio_status(info);
mdio_write(info, MII_CONTROL, MII_CONTROL_RESET);
return status;
}
static int do_one_xcvr(int skfd, char *ifname, int maybe)
{
struct mii_data *mii = (struct mii_data *)&ifr.ifr_data;
/* Get the vitals from the interface. */
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if (ioctl(skfd, SIOCGMIIPHY, &ifr) < 0) {
if (!maybe || (errno != ENODEV))
fprintf(stderr, "SIOCGMIIPHY on '%s' failed: %s\n",
ifname, strerror(errno));
return 1;
}
if (override_phy >= 0) {
printf("using the specified MII index %d.\n", override_phy);
mii->phy_id = override_phy;
}
if (opt_reset) {
printf("resetting the transceiver...\n");
mdio_write(skfd, MII_BMCR, MII_BMCR_RESET);
}
if (nway_advertise) {
mdio_write(skfd, MII_ANAR, nway_advertise | 1);
opt_restart = 1;
}
if (opt_restart) {
printf("restarting autonegotiation...\n");
mdio_write(skfd, MII_BMCR, 0x0000);
mdio_write(skfd, MII_BMCR, MII_BMCR_AN_ENA|MII_BMCR_RESTART);
}
if (fixed_speed) {
int bmcr = 0;
if (fixed_speed & (MII_AN_100BASETX_FD|MII_AN_100BASETX_HD))
bmcr |= MII_BMCR_100MBIT;
if (fixed_speed & (MII_AN_100BASETX_FD|MII_AN_10BASET_FD))
bmcr |= MII_BMCR_DUPLEX;
mdio_write(skfd, MII_BMCR, bmcr);
}
if (!opt_restart && !opt_reset && !fixed_speed && !nway_advertise)
show_basic_mii(skfd, mii->phy_id);
return 0;
}
static void robo_write(robo_t *robo, u8 page, u8 reg, u16 *val, int count)
{
int i;
for (i = 0; i < count; i++)
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0 + i, val[i]);
robo_reg(robo, page, reg, REG_MII_ADDR_WRITE);
}
static int led_init(struct cphy *cphy)
{
/* Setup the LED registers so we can turn on/off.
* Writing these bits maps control to another
* register. mmd(0x1) addr(0x7)
*/
mdio_write(cphy, 0x3, 0x8304, 0xdddd);
return 0;
}
static int mdiobus_write(struct mii_bus *bus, int phy_addr, int regnum,
u16 value)
{
struct net_device *const dev = bus->priv;
enable_mac(dev, 0); /* make sure the MAC associated with this
* mii_bus is enabled */
mdio_write(dev, phy_addr, regnum, value);
return 0;
}
static void rtl8169_write_gmii_reg_bit(void *ioaddr, int reg, int bitnum,
int bitval)
{
int val;
val = mdio_read(ioaddr, reg);
val = (bitval == 1) ?
val | (bitval << bitnum) : val & ~(0x0001 << bitnum);
mdio_write(ioaddr, reg, val & 0xffff);
}
static int ael1002_power_down(struct cphy *phy, int enable)
{
int err;
err = mdio_write(phy, MDIO_DEV_PMA_PMD, AEL100X_TX_DISABLE, !!enable);
if (!err)
err = t3_mdio_change_bits(phy, MDIO_DEV_PMA_PMD, MII_BMCR,
BMCR_PDOWN, enable ? BMCR_PDOWN : 0);
return err;
}
static int tn1010_advertise(struct cphy *phy, unsigned int advert)
{
int err, val;
if (!(advert & ADVERTISED_1000baseT_Full))
return -EINVAL; /* PHY can't disable 1000BASE-T */
val = ADVERTISE_CSMA | ADVERTISE_ENPAGE | ADVERTISE_NPAGE;
if (advert & ADVERTISED_Pause)
val |= ADVERTISE_PAUSE_CAP;
if (advert & ADVERTISED_Asym_Pause)
val |= ADVERTISE_PAUSE_ASYM;
err = mdio_write(phy, MDIO_DEV_ANEG, ANEG_ADVER, val);
if (err)
return err;
val = (advert & ADVERTISED_10000baseT_Full) ? ADVERTISE_10000FULL : 0;
return mdio_write(phy, MDIO_DEV_ANEG, ANEG_10G_CTRL, val |
ADVERTISE_LOOP_TIMING);
}
static void robo_write16(robo_t *robo, u8 page, u8 reg, u16 val16)
{
#ifdef BCM5301X
robo_write(robo, page, reg, &val16, 1);
#else
/* write data */
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0, val16);
robo_reg(robo, page, reg, REG_MII_ADDR_WRITE);
#endif
}
int t3_mv88e1xxx_phy_prep(pinfo_t *pinfo, int phy_addr,
const struct mdio_ops *mdio_ops)
{
struct cphy *phy = &pinfo->phy;
int err;
cphy_init(phy, pinfo->adapter, pinfo, phy_addr, &mv88e1xxx_ops, mdio_ops,
SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Full |
SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg | SUPPORTED_MII |
SUPPORTED_TP | SUPPORTED_IRQ, "10/100/1000BASE-T");
/* Configure copper PHY transmitter as class A to reduce EMI. */
err = mdio_write(phy, 0, MV88E1XXX_EXTENDED_ADDR, 0xb);
if (!err)
err = mdio_write(phy, 0, MV88E1XXX_EXTENDED_DATA, 0x8004);
if (!err)
err = mv88e1xxx_downshift_set(phy, 1); /* Enable downshift */
return err;
}
static int _robo_reg(robo_t *robo, u8 page, u8 reg, u8 op)
{
int i = 3;
/* set page number */
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_PAGE,
(page << 8) | REG_MII_PAGE_ENABLE);
/* set register address */
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_ADDR,
(reg << 8) | op);
/* check if operation completed */
while (i--) {
if ((mdio_read(robo, ROBO_PHY_ADDR, REG_MII_ADDR) & 3) == 0)
return 0;
}
return -1;
}
static void robo_write32(robo_t *robo, u8 page, u8 reg, u32 val32)
{
#ifdef BCM5301X
robo_write(robo, page, reg, (u16 *) &val32, 2);
#else
/* write data */
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0, (u16 )(val32 & 0xFFFF));
mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0 + 1, (u16 )(val32 >> 16));
robo_reg(robo, page, reg, REG_MII_ADDR_WRITE);
#endif
}
static void set_misc_reg(struct net_device *dev)
{
unsigned int nic_base = dev->base_addr;
pcnet_dev_t *info = PRIV(dev);
u_char tmp;
if (info->flags & HAS_MISC_REG) {
tmp = inb_p(nic_base + PCNET_MISC) & ~3;
if (dev->if_port == 2)
tmp |= 1;
if (info->flags & USE_BIG_BUF)
tmp |= 2;
if (info->flags & HAS_IBM_MISC)
tmp |= 8;
outb_p(tmp, nic_base + PCNET_MISC);
}
if (info->flags & IS_DL10022) {
if (info->flags & HAS_MII) {
/* Advertise 100F, 100H, 10F, 10H */
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 4, 0x01e1);
/* Restart MII autonegotiation */
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
info->mii_reset = jiffies;
} else {
outb(full_duplex ? 4 : 0, nic_base + DLINK_DIAG);
}
} else if (info->flags & IS_DL10019) {
/* Advertise 100F, 100H, 10F, 10H */
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 4, 0x01e1);
/* Restart MII autonegotiation */
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
}
}
static void
sis900_setAutoNegotiationCapabilities(struct sis_info *info)
{
uint16 status = mdio_status(info);
uint16 capabilities = MII_NWAY_CSMA_CD
| (status & MII_STATUS_CAN_TX_FDX ? MII_NWAY_TX_FDX : 0)
| (status & MII_STATUS_CAN_TX ? MII_NWAY_TX : 0)
| (status & MII_STATUS_CAN_T_FDX ? MII_NWAY_T_FDX : 0)
| (status & MII_STATUS_CAN_T ? MII_NWAY_T : 0);
TRACE((DEVICE_NAME ": write capabilities %d\n", capabilities));
mdio_write(info, MII_AUTONEG_ADV, capabilities);
}
static int mv88x201x_interrupt_disable(struct cphy *cphy)
{
u32 elmer;
/* Disable PHY LASI interrupts. */
mdio_write(cphy, 0x1, 0x9002, 0x0);
/* Disable Marvell interrupts through Elmer0. */
t1_tpi_read(cphy->adapter, A_ELMER0_INT_ENABLE, &elmer);
elmer &= ~ELMER0_GP_BIT6;
t1_tpi_write(cphy->adapter, A_ELMER0_INT_ENABLE, elmer);
return 0;
}
static int robo_reg(__u8 page, __u8 reg, __u8 op)
{
int i = 3;
/* set page number */
mdio_write(ROBO_PHY_ADDR, REG_MII_PAGE,
(page << 8) | REG_MII_PAGE_ENABLE);
/* set register address */
mdio_write(ROBO_PHY_ADDR, REG_MII_ADDR,
(reg << 8) | op);
/* check if operation completed */
while (i--) {
if ((mdio_read(ROBO_PHY_ADDR, REG_MII_ADDR) & 3) == 0)
return 0;
}
printk("[%s:%d] timeout in robo_reg!\n", __FILE__, __LINE__);
return 0;
}
int bcm_5201_init(struct net_device *dev, int phy_addr)
{
s16 data;
/* Stop auto-negotiation */
data = mdio_read(dev, phy_addr, MII_CONTROL);
mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO);
/* Set advertisement to 10/100 and Half/Full duplex
* (full capabilities) */
data = mdio_read(dev, phy_addr, MII_ANADV);
data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T;
mdio_write(dev, phy_addr, MII_ANADV, data);
/* Restart auto-negotiation */
data = mdio_read(dev, phy_addr, MII_CONTROL);
data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO;
mdio_write(dev, phy_addr, MII_CONTROL, data);
if (au1000_debug > 4)
dump_mii(dev, phy_addr);
return 0;
}
void
sis900_selectPHY(struct sis_info *info)
{
uint16 status;
// ToDo: need to be changed, select PHY in relation to the link mode
info->currentPHY = info->firstPHY;
info->phy = info->currentPHY->address;
status = mdio_read(info, MII_CONTROL);
status &= ~MII_CONTROL_ISOLATE;
mdio_write(info, MII_CONTROL, status);
}
int t3_vsc8211_phy_prep(pinfo_t *pinfo, int phy_addr,
const struct mdio_ops *mdio_ops)
{
struct cphy *phy = &pinfo->phy;
int err;
unsigned int val;
cphy_init(&pinfo->phy, pinfo->adapter, pinfo, phy_addr, &vsc8211_ops, mdio_ops,
SUPPORTED_10baseT_Full | SUPPORTED_100baseT_Full |
SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg | SUPPORTED_MII |
SUPPORTED_TP | SUPPORTED_IRQ, "10/100/1000BASE-T");
msleep(20); /* PHY needs ~10ms to start responding to MDIO */
err = mdio_read(phy, 0, VSC8211_EXT_CTRL, &val);
if (err)
return err;
if (val & VSC_CTRL_MEDIA_MODE_HI) {
/* copper interface, just need to configure the LEDs */
return mdio_write(phy, 0, VSC8211_LED_CTRL, 0x100);
}
phy->caps = SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg |
SUPPORTED_MII | SUPPORTED_FIBRE | SUPPORTED_IRQ;
phy->desc = "1000BASE-X";
phy->ops = &vsc8211_fiber_ops;
if ((err = mdio_write(phy, 0, VSC8211_EXT_PAGE_AXS, 1)) != 0 ||
(err = mdio_write(phy, 0, VSC8211_SIGDET_CTRL, 1)) != 0 ||
(err = mdio_write(phy, 0, VSC8211_EXT_PAGE_AXS, 0)) != 0 ||
(err = mdio_write(phy, 0, VSC8211_EXT_CTRL,
val | VSC_CTRL_CLAUSE37_VIEW)) != 0 ||
(err = vsc8211_reset(phy, 0)) != 0)
return err;
udelay(5); /* delay after reset before next SMI */
return 0;
}
static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct mii_ioctl_data *data = if_mii(rq);
struct am_net_private *np = netdev_priv(dev);
char addr[MAX_ADDR_LEN];
if (debug > 0)
printk("Ethernet Driver ioctl (%x) \n", cmd);
switch (cmd) {
case SIOCGMIIPHY: /* Get address of MII PHY in use. */
data->phy_id =
((struct am_net_private *)netdev_priv(dev))->phys[0] & 0x1f;
/* Fall Through */
case SIOCGMIIREG: /* Read MII PHY register. */
spin_lock_irq(&np->lock);
data->val_out =
mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
spin_unlock_irq(&np->lock);
return 0;
case SIOCSMIIREG: /* Write MII PHY register. */
if (!capable(CAP_NET_ADMIN))
return -EPERM;
spin_lock_irq(&np->lock);
mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f,data->val_in);
spin_unlock_irq(&np->lock);
return 0;
case SIOCSIFHWADDR:
if (copy_from_user(&addr,
(void __user *)rq->ifr_hwaddr.sa_data,
MAX_ADDR_LEN)) {
return -EFAULT;
}
if (debug > 0)
printk("set mac addr to %02x:%02x:%02x:%02x:%02x:%02x\n",
addr[0], addr[1], addr[2], addr[3], addr[4],
addr[5]);
spin_lock_irq(&np->lock);
memcpy(dev->dev_addr, &addr, MAX_ADDR_LEN);
write_mac_addr(dev, addr);
spin_unlock_irq(&np->lock);
default:
if (debug > 0)
printk("Ethernet Driver unknow ioctl (%x) \n", cmd);
return -EOPNOTSUPP;
}
return 0;
}
static int set_phy_regs(struct cphy *phy, const struct reg_val *rv)
{
int err;
for (err = 0; rv->mmd_addr && !err; rv++) {
if (rv->clear_bits == 0xffff)
err = mdio_write(phy, rv->mmd_addr, rv->reg_addr,
rv->set_bits);
else
err = t3_mdio_change_bits(phy, rv->mmd_addr,
rv->reg_addr, rv->clear_bits,
rv->set_bits);
}
return err;
}
static int mv88x201x_interrupt_enable(struct cphy *cphy)
{
/* Enable PHY LASI interrupts. */
(void) mdio_write(cphy, 0x1, 0x9002, 0x1);
/* Enable Marvell interrupts through Elmer0. */
if (t1_is_asic(cphy->adapter)) {
u32 elmer;
(void) t1_tpi_read(cphy->adapter, A_ELMER0_INT_ENABLE, &elmer);
elmer |= ELMER0_GP_BIT6;
(void) t1_tpi_write(cphy->adapter, A_ELMER0_INT_ENABLE, elmer);
}
return 0;
}
static int ftmac110_mdio_write(
const char *devname, uint8_t addr, uint8_t reg, uint16_t value)
{
int ret = 0;
struct eth_device *dev;
dev = eth_get_dev_by_name(devname);
if (dev == NULL) {
printf("%s: no such device\n", devname);
ret = -1;
} else {
mdio_write(dev, addr, reg, value);
}
return ret;
}
void set_link(SetLink_Type mode)
{
u32 val=0;
if( mode == CNTL_AUTONEGO)
{
val = CNTL_AUTONEGO;
}
else
{
val = (mode & (CNTL_SPEED|CNTL_DUPLEX));
}
mdio_write(PHYREG_CONTROL, val);
}
static void
sis900_autoNegotiate(struct sis_info *info)
{
uint16 status = mdio_status(info);
if ((status & MII_STATUS_LINK) == 0)
{
TRACE((DEVICE_NAME ": media link off\n"));
info->autoNegotiationComplete = true;
return;
}
TRACE((DEVICE_NAME ": auto negotiation started...\n"));
// reset auto negotiation
mdio_write(info, MII_CONTROL, MII_CONTROL_AUTO | MII_CONTROL_RESET_AUTONEG);
info->autoNegotiationComplete = false;
}
void set_link(SetLink_Type mode)
{
uint32_t val=0;
assert_param(IS_SETLINK_TYPE(mode));
if( mode == CNTL_AUTONEGO)
{
val = CNTL_AUTONEGO;
}
else
{
val = (mode & (CNTL_SPEED|CNTL_DUPLEX));
}
mdio_write(GPIOB, PHYREG_CONTROL, val);
}
int bcm_5201_reset(struct net_device *dev, int phy_addr)
{
s16 mii_control, timeout;
mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
mdelay(1);
for (timeout = 100; timeout > 0; --timeout) {
mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
if ((mii_control & MII_CNTL_RESET) == 0)
break;
mdelay(1);
}
if (mii_control & MII_CNTL_RESET) {
printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
return -1;
}
return 0;
}
