mirror of
https://github.com/u-boot/u-boot.git
synced 2024-11-23 20:24:26 +08:00
f915c9316c
This reverts commit 5c45a22b92
.
It causes a lot of "incompatible pointer type" warnings for a large
number of Ethernet drivers, which are not really worth fixing
especially as this patch was only supposed to help the old,
deprecated miiphy API. Instead of adding more efforts to a lost case
we rather revert it.
Signed-off-by: Wolfgang Denk <wd@denx.de>
601 lines
14 KiB
C
601 lines
14 KiB
C
/*
|
|
* (C) Copyright 2001
|
|
* Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
|
|
*
|
|
* 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 as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
/*
|
|
* This provides a bit-banged interface to the ethernet MII management
|
|
* channel.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <miiphy.h>
|
|
#include <phy.h>
|
|
|
|
#include <asm/types.h>
|
|
#include <linux/list.h>
|
|
#include <malloc.h>
|
|
#include <net.h>
|
|
|
|
/* local debug macro */
|
|
#undef MII_DEBUG
|
|
|
|
#undef debug
|
|
#ifdef MII_DEBUG
|
|
#define debug(fmt, args...) printf(fmt, ##args)
|
|
#else
|
|
#define debug(fmt, args...)
|
|
#endif /* MII_DEBUG */
|
|
|
|
static struct list_head mii_devs;
|
|
static struct mii_dev *current_mii;
|
|
|
|
/*
|
|
* Lookup the mii_dev struct by the registered device name.
|
|
*/
|
|
struct mii_dev *miiphy_get_dev_by_name(const char *devname)
|
|
{
|
|
struct list_head *entry;
|
|
struct mii_dev *dev;
|
|
|
|
if (!devname) {
|
|
printf("NULL device name!\n");
|
|
return NULL;
|
|
}
|
|
|
|
list_for_each(entry, &mii_devs) {
|
|
dev = list_entry(entry, struct mii_dev, link);
|
|
if (strcmp(dev->name, devname) == 0)
|
|
return dev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Initialize global data. Need to be called before any other miiphy routine.
|
|
*/
|
|
void miiphy_init(void)
|
|
{
|
|
INIT_LIST_HEAD(&mii_devs);
|
|
current_mii = NULL;
|
|
}
|
|
|
|
static int legacy_miiphy_read(struct mii_dev *bus, int addr, int devad, int reg)
|
|
{
|
|
unsigned short val;
|
|
int ret;
|
|
struct legacy_mii_dev *ldev = bus->priv;
|
|
|
|
ret = ldev->read(bus->name, addr, reg, &val);
|
|
|
|
return ret ? -1 : (int)val;
|
|
}
|
|
|
|
static int legacy_miiphy_write(struct mii_dev *bus, int addr, int devad,
|
|
int reg, u16 val)
|
|
{
|
|
struct legacy_mii_dev *ldev = bus->priv;
|
|
|
|
return ldev->write(bus->name, addr, reg, val);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Register read and write MII access routines for the device <name>.
|
|
* This API is now deprecated. Please use mdio_alloc and mdio_register, instead.
|
|
*/
|
|
void miiphy_register(const char *name,
|
|
int (*read)(const char *devname, unsigned char addr,
|
|
unsigned char reg, unsigned short *value),
|
|
int (*write)(const char *devname, unsigned char addr,
|
|
unsigned char reg, unsigned short value))
|
|
{
|
|
struct mii_dev *new_dev;
|
|
struct legacy_mii_dev *ldev;
|
|
|
|
BUG_ON(strlen(name) >= MDIO_NAME_LEN);
|
|
|
|
/* check if we have unique name */
|
|
new_dev = miiphy_get_dev_by_name(name);
|
|
if (new_dev) {
|
|
printf("miiphy_register: non unique device name '%s'\n", name);
|
|
return;
|
|
}
|
|
|
|
/* allocate memory */
|
|
new_dev = mdio_alloc();
|
|
ldev = malloc(sizeof(*ldev));
|
|
|
|
if (new_dev == NULL || ldev == NULL) {
|
|
printf("miiphy_register: cannot allocate memory for '%s'\n",
|
|
name);
|
|
return;
|
|
}
|
|
|
|
/* initalize mii_dev struct fields */
|
|
new_dev->read = legacy_miiphy_read;
|
|
new_dev->write = legacy_miiphy_write;
|
|
strncpy(new_dev->name, name, MDIO_NAME_LEN);
|
|
new_dev->name[MDIO_NAME_LEN - 1] = 0;
|
|
ldev->read = read;
|
|
ldev->write = write;
|
|
new_dev->priv = ldev;
|
|
|
|
debug("miiphy_register: added '%s', read=0x%08lx, write=0x%08lx\n",
|
|
new_dev->name, ldev->read, ldev->write);
|
|
|
|
/* add it to the list */
|
|
list_add_tail(&new_dev->link, &mii_devs);
|
|
|
|
if (!current_mii)
|
|
current_mii = new_dev;
|
|
}
|
|
|
|
struct mii_dev *mdio_alloc(void)
|
|
{
|
|
struct mii_dev *bus;
|
|
|
|
bus = malloc(sizeof(*bus));
|
|
if (!bus)
|
|
return bus;
|
|
|
|
memset(bus, 0, sizeof(*bus));
|
|
|
|
/* initalize mii_dev struct fields */
|
|
INIT_LIST_HEAD(&bus->link);
|
|
|
|
return bus;
|
|
}
|
|
|
|
int mdio_register(struct mii_dev *bus)
|
|
{
|
|
if (!bus || !bus->name || !bus->read || !bus->write)
|
|
return -1;
|
|
|
|
/* check if we have unique name */
|
|
if (miiphy_get_dev_by_name(bus->name)) {
|
|
printf("mdio_register: non unique device name '%s'\n",
|
|
bus->name);
|
|
return -1;
|
|
}
|
|
|
|
/* add it to the list */
|
|
list_add_tail(&bus->link, &mii_devs);
|
|
|
|
if (!current_mii)
|
|
current_mii = bus;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void mdio_list_devices(void)
|
|
{
|
|
struct list_head *entry;
|
|
|
|
list_for_each(entry, &mii_devs) {
|
|
int i;
|
|
struct mii_dev *bus = list_entry(entry, struct mii_dev, link);
|
|
|
|
printf("%s:\n", bus->name);
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
|
struct phy_device *phydev = bus->phymap[i];
|
|
|
|
if (phydev) {
|
|
printf("%d - %s", i, phydev->drv->name);
|
|
|
|
if (phydev->dev)
|
|
printf(" <--> %s\n", phydev->dev->name);
|
|
else
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int miiphy_set_current_dev(const char *devname)
|
|
{
|
|
struct mii_dev *dev;
|
|
|
|
dev = miiphy_get_dev_by_name(devname);
|
|
if (dev) {
|
|
current_mii = dev;
|
|
return 0;
|
|
}
|
|
|
|
printf("No such device: %s\n", devname);
|
|
|
|
return 1;
|
|
}
|
|
|
|
struct mii_dev *mdio_get_current_dev(void)
|
|
{
|
|
return current_mii;
|
|
}
|
|
|
|
struct phy_device *mdio_phydev_for_ethname(const char *ethname)
|
|
{
|
|
struct list_head *entry;
|
|
struct mii_dev *bus;
|
|
|
|
list_for_each(entry, &mii_devs) {
|
|
int i;
|
|
bus = list_entry(entry, struct mii_dev, link);
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
|
if (!bus->phymap[i] || !bus->phymap[i]->dev)
|
|
continue;
|
|
|
|
if (strcmp(bus->phymap[i]->dev->name, ethname) == 0)
|
|
return bus->phymap[i];
|
|
}
|
|
}
|
|
|
|
printf("%s is not a known ethernet\n", ethname);
|
|
return NULL;
|
|
}
|
|
|
|
const char *miiphy_get_current_dev(void)
|
|
{
|
|
if (current_mii)
|
|
return current_mii->name;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct mii_dev *miiphy_get_active_dev(const char *devname)
|
|
{
|
|
/* If the current mii is the one we want, return it */
|
|
if (current_mii)
|
|
if (strcmp(current_mii->name, devname) == 0)
|
|
return current_mii;
|
|
|
|
/* Otherwise, set the active one to the one we want */
|
|
if (miiphy_set_current_dev(devname))
|
|
return NULL;
|
|
else
|
|
return current_mii;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Read to variable <value> from the PHY attached to device <devname>,
|
|
* use PHY address <addr> and register <reg>.
|
|
*
|
|
* This API is deprecated. Use phy_read on a phy_device found via phy_connect
|
|
*
|
|
* Returns:
|
|
* 0 on success
|
|
*/
|
|
int miiphy_read(const char *devname, unsigned char addr, unsigned char reg,
|
|
unsigned short *value)
|
|
{
|
|
struct mii_dev *bus;
|
|
int ret;
|
|
|
|
bus = miiphy_get_active_dev(devname);
|
|
if (!bus)
|
|
return 1;
|
|
|
|
ret = bus->read(bus, addr, MDIO_DEVAD_NONE, reg);
|
|
if (ret < 0)
|
|
return 1;
|
|
|
|
*value = (unsigned short)ret;
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Write <value> to the PHY attached to device <devname>,
|
|
* use PHY address <addr> and register <reg>.
|
|
*
|
|
* This API is deprecated. Use phy_write on a phy_device found by phy_connect
|
|
*
|
|
* Returns:
|
|
* 0 on success
|
|
*/
|
|
int miiphy_write(const char *devname, unsigned char addr, unsigned char reg,
|
|
unsigned short value)
|
|
{
|
|
struct mii_dev *bus;
|
|
|
|
bus = miiphy_get_active_dev(devname);
|
|
if (bus)
|
|
return bus->write(bus, addr, MDIO_DEVAD_NONE, reg, value);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Print out list of registered MII capable devices.
|
|
*/
|
|
void miiphy_listdev(void)
|
|
{
|
|
struct list_head *entry;
|
|
struct mii_dev *dev;
|
|
|
|
puts("MII devices: ");
|
|
list_for_each(entry, &mii_devs) {
|
|
dev = list_entry(entry, struct mii_dev, link);
|
|
printf("'%s' ", dev->name);
|
|
}
|
|
puts("\n");
|
|
|
|
if (current_mii)
|
|
printf("Current device: '%s'\n", current_mii->name);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Read the OUI, manufacture's model number, and revision number.
|
|
*
|
|
* OUI: 22 bits (unsigned int)
|
|
* Model: 6 bits (unsigned char)
|
|
* Revision: 4 bits (unsigned char)
|
|
*
|
|
* This API is deprecated.
|
|
*
|
|
* Returns:
|
|
* 0 on success
|
|
*/
|
|
int miiphy_info(const char *devname, unsigned char addr, unsigned int *oui,
|
|
unsigned char *model, unsigned char *rev)
|
|
{
|
|
unsigned int reg = 0;
|
|
unsigned short tmp;
|
|
|
|
if (miiphy_read(devname, addr, MII_PHYSID2, &tmp) != 0) {
|
|
debug("PHY ID register 2 read failed\n");
|
|
return -1;
|
|
}
|
|
reg = tmp;
|
|
|
|
debug("MII_PHYSID2 @ 0x%x = 0x%04x\n", addr, reg);
|
|
|
|
if (reg == 0xFFFF) {
|
|
/* No physical device present at this address */
|
|
return -1;
|
|
}
|
|
|
|
if (miiphy_read(devname, addr, MII_PHYSID1, &tmp) != 0) {
|
|
debug("PHY ID register 1 read failed\n");
|
|
return -1;
|
|
}
|
|
reg |= tmp << 16;
|
|
debug("PHY_PHYIDR[1,2] @ 0x%x = 0x%08x\n", addr, reg);
|
|
|
|
*oui = (reg >> 10);
|
|
*model = (unsigned char)((reg >> 4) & 0x0000003F);
|
|
*rev = (unsigned char)(reg & 0x0000000F);
|
|
return 0;
|
|
}
|
|
|
|
#ifndef CONFIG_PHYLIB
|
|
/*****************************************************************************
|
|
*
|
|
* Reset the PHY.
|
|
*
|
|
* This API is deprecated. Use PHYLIB.
|
|
*
|
|
* Returns:
|
|
* 0 on success
|
|
*/
|
|
int miiphy_reset(const char *devname, unsigned char addr)
|
|
{
|
|
unsigned short reg;
|
|
int timeout = 500;
|
|
|
|
if (miiphy_read(devname, addr, MII_BMCR, ®) != 0) {
|
|
debug("PHY status read failed\n");
|
|
return -1;
|
|
}
|
|
if (miiphy_write(devname, addr, MII_BMCR, reg | BMCR_RESET) != 0) {
|
|
debug("PHY reset failed\n");
|
|
return -1;
|
|
}
|
|
#ifdef CONFIG_PHY_RESET_DELAY
|
|
udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */
|
|
#endif
|
|
/*
|
|
* Poll the control register for the reset bit to go to 0 (it is
|
|
* auto-clearing). This should happen within 0.5 seconds per the
|
|
* IEEE spec.
|
|
*/
|
|
reg = 0x8000;
|
|
while (((reg & 0x8000) != 0) && timeout--) {
|
|
if (miiphy_read(devname, addr, MII_BMCR, ®) != 0) {
|
|
debug("PHY status read failed\n");
|
|
return -1;
|
|
}
|
|
udelay(1000);
|
|
}
|
|
if ((reg & 0x8000) == 0) {
|
|
return 0;
|
|
} else {
|
|
puts("PHY reset timed out\n");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* !PHYLIB */
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Determine the ethernet speed (10/100/1000). Return 10 on error.
|
|
*/
|
|
int miiphy_speed(const char *devname, unsigned char addr)
|
|
{
|
|
u16 bmcr, anlpar;
|
|
|
|
#if defined(CONFIG_PHY_GIGE)
|
|
u16 btsr;
|
|
|
|
/*
|
|
* Check for 1000BASE-X. If it is supported, then assume that the speed
|
|
* is 1000.
|
|
*/
|
|
if (miiphy_is_1000base_x(devname, addr))
|
|
return _1000BASET;
|
|
|
|
/*
|
|
* No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
|
|
*/
|
|
/* Check for 1000BASE-T. */
|
|
if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
|
|
printf("PHY 1000BT status");
|
|
goto miiphy_read_failed;
|
|
}
|
|
if (btsr != 0xFFFF &&
|
|
(btsr & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD)))
|
|
return _1000BASET;
|
|
#endif /* CONFIG_PHY_GIGE */
|
|
|
|
/* Check Basic Management Control Register first. */
|
|
if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
|
|
printf("PHY speed");
|
|
goto miiphy_read_failed;
|
|
}
|
|
/* Check if auto-negotiation is on. */
|
|
if (bmcr & BMCR_ANENABLE) {
|
|
/* Get auto-negotiation results. */
|
|
if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
|
|
printf("PHY AN speed");
|
|
goto miiphy_read_failed;
|
|
}
|
|
return (anlpar & LPA_100) ? _100BASET : _10BASET;
|
|
}
|
|
/* Get speed from basic control settings. */
|
|
return (bmcr & BMCR_SPEED100) ? _100BASET : _10BASET;
|
|
|
|
miiphy_read_failed:
|
|
printf(" read failed, assuming 10BASE-T\n");
|
|
return _10BASET;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Determine full/half duplex. Return half on error.
|
|
*/
|
|
int miiphy_duplex(const char *devname, unsigned char addr)
|
|
{
|
|
u16 bmcr, anlpar;
|
|
|
|
#if defined(CONFIG_PHY_GIGE)
|
|
u16 btsr;
|
|
|
|
/* Check for 1000BASE-X. */
|
|
if (miiphy_is_1000base_x(devname, addr)) {
|
|
/* 1000BASE-X */
|
|
if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
|
|
printf("1000BASE-X PHY AN duplex");
|
|
goto miiphy_read_failed;
|
|
}
|
|
}
|
|
/*
|
|
* No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
|
|
*/
|
|
/* Check for 1000BASE-T. */
|
|
if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
|
|
printf("PHY 1000BT status");
|
|
goto miiphy_read_failed;
|
|
}
|
|
if (btsr != 0xFFFF) {
|
|
if (btsr & PHY_1000BTSR_1000FD) {
|
|
return FULL;
|
|
} else if (btsr & PHY_1000BTSR_1000HD) {
|
|
return HALF;
|
|
}
|
|
}
|
|
#endif /* CONFIG_PHY_GIGE */
|
|
|
|
/* Check Basic Management Control Register first. */
|
|
if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
|
|
puts("PHY duplex");
|
|
goto miiphy_read_failed;
|
|
}
|
|
/* Check if auto-negotiation is on. */
|
|
if (bmcr & BMCR_ANENABLE) {
|
|
/* Get auto-negotiation results. */
|
|
if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
|
|
puts("PHY AN duplex");
|
|
goto miiphy_read_failed;
|
|
}
|
|
return (anlpar & (LPA_10FULL | LPA_100FULL)) ?
|
|
FULL : HALF;
|
|
}
|
|
/* Get speed from basic control settings. */
|
|
return (bmcr & BMCR_FULLDPLX) ? FULL : HALF;
|
|
|
|
miiphy_read_failed:
|
|
printf(" read failed, assuming half duplex\n");
|
|
return HALF;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Return 1 if PHY supports 1000BASE-X, 0 if PHY supports 10BASE-T/100BASE-TX/
|
|
* 1000BASE-T, or on error.
|
|
*/
|
|
int miiphy_is_1000base_x(const char *devname, unsigned char addr)
|
|
{
|
|
#if defined(CONFIG_PHY_GIGE)
|
|
u16 exsr;
|
|
|
|
if (miiphy_read(devname, addr, MII_ESTATUS, &exsr)) {
|
|
printf("PHY extended status read failed, assuming no "
|
|
"1000BASE-X\n");
|
|
return 0;
|
|
}
|
|
return 0 != (exsr & (ESTATUS_1000XF | ESTATUS_1000XH));
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CONFIG_SYS_FAULT_ECHO_LINK_DOWN
|
|
/*****************************************************************************
|
|
*
|
|
* Determine link status
|
|
*/
|
|
int miiphy_link(const char *devname, unsigned char addr)
|
|
{
|
|
unsigned short reg;
|
|
|
|
/* dummy read; needed to latch some phys */
|
|
(void)miiphy_read(devname, addr, MII_BMSR, ®);
|
|
if (miiphy_read(devname, addr, MII_BMSR, ®)) {
|
|
puts("MII_BMSR read failed, assuming no link\n");
|
|
return 0;
|
|
}
|
|
|
|
/* Determine if a link is active */
|
|
if ((reg & BMSR_LSTATUS) != 0) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|