| /* |
| * miidev.c - generic phy abstraction |
| * |
| * Copyright (c) 2007 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix |
| * |
| * See file CREDITS for list of people who contributed to this |
| * project. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 |
| * as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <common.h> |
| #include <driver.h> |
| #include <init.h> |
| #include <miidev.h> |
| #include <clock.h> |
| #include <net.h> |
| #include <malloc.h> |
| |
| #define DEBUG_PORT_ADDRESS 29 |
| #define DEBUG_PORT_DATA 30 |
| |
| static inline int phy_debug_read(struct mii_device *mdev, unsigned int phy_addr, unsigned int reg_addr) |
| { |
| mdev->write(mdev, phy_addr, DEBUG_PORT_ADDRESS, reg_addr); |
| return (unsigned int) mdev->read(mdev, phy_addr, DEBUG_PORT_DATA); |
| } |
| |
| static inline void phy_debug_write(struct mii_device *mdev, unsigned int phy_addr, unsigned int reg_addr, unsigned int reg_val) |
| { |
| mdev->write(mdev, phy_addr, DEBUG_PORT_ADDRESS, reg_addr); |
| mdev->write(mdev, phy_addr, DEBUG_PORT_DATA, reg_val); |
| } |
| |
| |
| void miidev_enable_rgmii_rx_delay(struct mii_device *mdev) |
| { |
| uint16_t val; |
| //enable RxClk delay |
| val = phy_debug_read(mdev, mdev->address, 0x0); |
| val |= 0x8000; |
| phy_debug_write(mdev, mdev->address, 0x0, val); |
| } |
| |
| void miidev_enable_rgmii_tx_delay(struct mii_device *mdev) |
| { |
| uint16_t val; |
| //enable TxClk delay |
| val = phy_debug_read(mdev, mdev->address, 0x5); |
| val |= 0x100; |
| phy_debug_write(mdev, mdev->address, 0x5, val); |
| } |
| |
| |
| int miidev_restart_aneg(struct mii_device *mdev) |
| { |
| uint16_t status, btcr; |
| int timeout; |
| |
| printf("%s for PHY%d\n", __func__, mdev->address); |
| |
| /* |
| * Reset PHY, then delay 300ns |
| */ |
| mii_write(mdev, mdev->address, MII_BMCR, BMCR_RESET); |
| |
| if (mdev->flags & MIIDEV_FORCE_LINK) |
| return 0; |
| |
| udelay(1000); |
| |
| if (mdev->flags & MIIDEV_FORCE_10) { |
| printf("Forcing 10 Mbps ethernet link... "); |
| status = mii_read(mdev, mdev->address, MII_BMSR); |
| mii_write(mdev, mdev->address, MII_BMCR, BMCR_FULLDPLX | BMCR_CTST); |
| |
| timeout = 20; |
| do { /* wait for link status to go down */ |
| udelay(10000); |
| if ((timeout--) == 0) { |
| debug("hmmm, should not have waited..."); |
| break; |
| } |
| status = mii_read(mdev, mdev->address, MII_BMSR); |
| } while (status & BMSR_LSTATUS); |
| |
| } else { /* MII100 */ |
| /* |
| * Set the auto-negotiation advertisement register bits |
| */ |
| status = mii_read(mdev, mdev->address, MII_ADVERTISE); |
| status |= ADVERTISE_ALL; |
| mii_write(mdev, mdev->address, MII_ADVERTISE, status); |
| |
| if (miidev_supports_1000base_t(mdev)) { |
| btcr = mii_read(mdev, mdev->address, MII_CTRL1000); |
| btcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF; |
| mii_write(mdev, mdev->address, MII_CTRL1000, btcr); |
| } |
| |
| mii_write(mdev, mdev->address, MII_BMCR, BMCR_ANENABLE | BMCR_ANRESTART); |
| } |
| |
| return 0; |
| } |
| |
| int miidev_wait_aneg(struct mii_device *mdev) |
| { |
| uint64_t start; |
| int status; |
| |
| if (mdev->flags & MIIDEV_FORCE_LINK) |
| return 0; |
| |
| /* |
| * Wait for AN completion |
| */ |
| start = get_time_ns(); |
| do { |
| if (is_timeout(start, 5 * SECOND)) { |
| printf("%s: Autonegotiation timeout\n", mdev->cdev.name); |
| return -1; |
| } |
| |
| status = mii_read(mdev, mdev->address, MII_BMSR); |
| if (status < 0) { |
| printf("%s: Autonegotiation failed. status: 0x%04x\n", mdev->cdev.name, status); |
| return -1; |
| } |
| /* At times, we read 0xFFFF from MII_BMSR which is clearly not |
| * a valid value for this register. Some of the bits are |
| * "always 0" according to the data sheet for QCA8337. Repeat |
| * the read operation in this case. */ |
| } while (!(status & BMSR_ANEGCOMPLETE) || status == 0xFFFF); |
| |
| return 0; |
| } |
| |
| int miidev_print_status(struct mii_device *mdev) |
| { |
| int bmsr, bmcr, lpa; |
| char *duplex; |
| int speed; |
| |
| if (mdev->flags & MIIDEV_FORCE_LINK) { |
| printf("Forcing link present...\n"); |
| return 0; |
| } |
| |
| bmsr = mii_read(mdev, mdev->address, MII_BMSR); |
| if (bmsr < 0) |
| goto err_out; |
| bmcr = mii_read(mdev, mdev->address, MII_BMCR); |
| if (bmcr < 0) |
| goto err_out; |
| lpa = mii_read(mdev, mdev->address, MII_LPA); |
| if (lpa < 0) |
| goto err_out; |
| |
| printf("%s: Link is %s", mdev->cdev.name, |
| bmsr & BMSR_LSTATUS ? "up" : "down"); |
| |
| if (bmcr & BMCR_ANENABLE) { |
| duplex = lpa & LPA_DUPLEX ? "Full" : "Half"; |
| speed = lpa & LPA_100 ? 100 : 10; |
| } else { |
| duplex = bmcr & BMCR_FULLDPLX ? "Full" : "Half"; |
| speed = bmcr & BMCR_SPEED100 ? 100 : 10; |
| } |
| |
| printf(" - %d/%s\n", speed, duplex); |
| |
| return 0; |
| err_out: |
| printf("%s: failed to read\n", mdev->cdev.name); |
| return -1; |
| } |
| |
| int miidev_supports_1000base_t(struct mii_device *mdev) |
| { |
| unsigned short reg; |
| |
| reg = mii_read(mdev, mdev->address, MII_BMSR); |
| if (reg < 0) { |
| printf("PHY bmsr read failed, assuming no 1000bT support\n"); |
| return (0); |
| } |
| |
| if (reg & BMSR_ESTATEN) { |
| reg = mii_read(mdev, mdev->address, MII_ESTATUS); |
| if (reg < 0) { |
| printf("PHY exsr read failed, assuming no 1000bT support\n"); |
| return (0); |
| } |
| |
| if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF)) |
| return (1); |
| } |
| |
| return (0); |
| } |
| |
| int miidev_speed_duplex(struct mii_device *mdev, int *speed, int *duplex) |
| { |
| unsigned short bmcr, btcr, btsr, anlpar, anar; |
| |
| /* Check Basic Management Control Register first. */ |
| bmcr = mii_read(mdev, mdev->address, MII_BMCR); |
| if (bmcr < 0) { |
| printf("PHY bmcr read failed\n"); |
| return -1; |
| } |
| |
| /* Check if auto-negotiation is on. */ |
| if (bmcr & BMCR_ANENABLE) { |
| if (miidev_wait_aneg(mdev)) { |
| printf("PHY auto-negotiation error\n"); |
| return -1; |
| } |
| |
| if (miidev_supports_1000base_t(mdev)) { |
| btcr = mii_read(mdev, mdev->address, MII_CTRL1000); |
| if (btcr < 0) { |
| printf("PHY btcr read failed\n"); |
| return -1; |
| } |
| |
| btsr = mii_read(mdev, mdev->address, MII_STAT1000); |
| if (btsr < 0) { |
| printf("PHY btsr read failed\n"); |
| return -1; |
| } |
| |
| if ((btcr & ADVERTISE_1000FULL) && (btsr & LPA_1000FULL)) { |
| *speed = MII_SPEED_1000M; |
| *duplex = MII_DUPLEX_FULL; |
| return 0; |
| } |
| |
| if ((btcr & ADVERTISE_1000HALF) && (btsr & LPA_1000HALF)) { |
| *speed = MII_SPEED_1000M; |
| *duplex = MII_DUPLEX_HALF; |
| return 0; |
| } |
| } |
| |
| /* Get link partner abilities results. */ |
| anlpar = mii_read(mdev, mdev->address, MII_LPA); |
| if (anlpar < 0) { |
| printf("PHY anlpar read failed\n"); |
| return -1; |
| } |
| |
| /* Get advertised abilities. */ |
| anar = mii_read(mdev, mdev->address, MII_ADVERTISE); |
| if (anar < 0) { |
| printf("PHY anar register read failed\n"); |
| return -1; |
| } |
| |
| if ((anlpar & anar & ADVERTISE_100FULL)) { |
| *speed = MII_SPEED_100M; |
| *duplex = MII_DUPLEX_FULL; |
| } else if ((anlpar & anar & ADVERTISE_100HALF)) { |
| *speed = MII_SPEED_100M; |
| *duplex = MII_DUPLEX_HALF; |
| } else if ((anlpar & anar & ADVERTISE_10FULL)) { |
| *speed = MII_SPEED_10M; |
| *duplex = MII_DUPLEX_FULL; |
| } else { |
| *speed = MII_SPEED_10M; |
| *duplex = MII_DUPLEX_HALF; |
| } |
| |
| return 0; |
| } |
| |
| /* Get speed from basic control settings. */ |
| if ((bmcr & BMCR_SPEEDMASK) == BMCR_SPEED1000) |
| *speed = MII_SPEED_1000M; |
| else if ((bmcr & BMCR_SPEEDMASK) == BMCR_SPEED100) |
| *speed = MII_SPEED_100M; |
| else |
| *speed = MII_SPEED_10M; |
| |
| if (bmcr & BMCR_FULLDPLX) |
| *duplex = MII_DUPLEX_FULL; |
| else |
| *duplex = MII_DUPLEX_HALF; |
| |
| return 0; |
| } |
| |
| void miidev_print_speed_duplex(struct mii_device *mdev, int speed, int duplex) |
| { |
| char *speed_str, *duplex_str; |
| |
| switch (speed) { |
| case MII_SPEED_10M: |
| speed_str = "10"; |
| break; |
| case MII_SPEED_100M: |
| speed_str = "100"; |
| break; |
| case MII_SPEED_1000M: |
| speed_str = "1000"; |
| break; |
| case MII_SPEED_1000M_PCS: |
| speed_str = "1000_PCS"; |
| break; |
| default: |
| speed_str ="UNKNOWN"; |
| } |
| |
| if (duplex == MII_DUPLEX_FULL) |
| duplex_str = "FULL"; |
| else |
| duplex_str = "HALF"; |
| |
| printf ("%s: Link is %s/%s\n", mdev->cdev.name, speed_str, duplex_str); |
| } |
| |
| static ssize_t miidev_read(struct cdev *cdev, void *_buf, size_t count, ulong offset, ulong flags) |
| { |
| int i = count; |
| uint16_t *buf = _buf; |
| struct mii_device *mdev = cdev->priv; |
| |
| while (i > 1) { |
| *buf = mii_read(mdev, mdev->address, offset); |
| buf++; |
| i -= 2; |
| offset++; |
| } |
| |
| return count; |
| } |
| |
| static ssize_t miidev_write(struct cdev *cdev, const void *_buf, size_t count, ulong offset, ulong flags) |
| { |
| int i = count; |
| const uint16_t *buf = _buf; |
| struct mii_device *mdev = cdev->priv; |
| |
| while (i > 1) { |
| mii_write(mdev, mdev->address, offset, *buf); |
| buf++; |
| i -= 2; |
| offset++; |
| } |
| |
| return count; |
| } |
| |
| static struct file_operations miidev_ops = { |
| .read = miidev_read, |
| .write = miidev_write, |
| .lseek = dev_lseek_default, |
| }; |
| |
| static int miidev_probe(struct device_d *dev) |
| { |
| struct mii_device *mdev = dev->priv; |
| |
| mdev->cdev.name = asprintf("phy%d", dev->id); |
| mdev->cdev.size = 64; |
| mdev->cdev.ops = &miidev_ops; |
| mdev->cdev.priv = mdev; |
| mdev->cdev.dev = dev; |
| devfs_create(&mdev->cdev); |
| return 0; |
| } |
| |
| static void miidev_remove(struct device_d *dev) |
| { |
| struct mii_device *mdev = dev->priv; |
| |
| free(mdev->cdev.name); |
| devfs_remove(&mdev->cdev); |
| } |
| |
| static struct driver_d miidev_drv = { |
| .name = "miidev", |
| .probe = miidev_probe, |
| .remove = miidev_remove, |
| }; |
| |
| int mii_register(struct mii_device *mdev) |
| { |
| mdev->dev.priv = mdev; |
| mdev->dev.id = -1; |
| strcpy(mdev->dev.name, "miidev"); |
| |
| return register_device(&mdev->dev); |
| } |
| |
| void mii_unregister(struct mii_device *mdev) |
| { |
| unregister_device(&mdev->dev); |
| } |
| |
| static int miidev_init(void) |
| { |
| register_driver(&miidev_drv); |
| return 0; |
| } |
| |
| device_initcall(miidev_init); |
| |
