leandrof/u-boot
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

miiphy: Fix some formatting issues

Browse Source 
Mostly putting a space between function name and "(", and
doing return (foo)

Signed-off-by: Andy Fleming <afleming@freescale.com>
Acked-by: Detlev Zundel <dzu@denx.de>
This commit is contained in:
Andy Fleming 2011-04-07 14:38:35 -05:00
parent 09c04c2096
commit 16a5323833
2 changed files with 90 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
common/miiphyutil.c
View File

@ -39,17 +39,17 @@
#undef debug #undef debug
#ifdef MII_DEBUG #ifdef MII_DEBUG
#define debug(fmt,args...) printf (fmt ,##args) #define debug(fmt, args...) printf(fmt, ##args)
#else #else
#define debug(fmt,args...) #define debug(fmt, args...)
#endif /* MII_DEBUG */ #endif /* MII_DEBUG */
struct mii_dev { struct mii_dev {
struct list_head link; struct list_head link;
const char *name; const char *name;
int (*read) (const char *devname, unsigned char addr, int (*read)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short *value); unsigned char reg, unsigned short *value);
int (*write) (const char *devname, unsigned char addr, int (*write)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short value); unsigned char reg, unsigned short value);
}; };
@ -86,7 +86,7 @@ static struct mii_dev *miiphy_get_dev_by_name(const char *devname, int quiet)
*/ */
void miiphy_init(void) void miiphy_init(void)
{ {
INIT_LIST_HEAD (&mii_devs); INIT_LIST_HEAD(&mii_devs);
current_mii = NULL; current_mii = NULL;
} }
@ -95,9 +95,9 @@ void miiphy_init(void)
* Register read and write MII access routines for the device <name>. * Register read and write MII access routines for the device <name>.
*/ */
void miiphy_register(const char *name, void miiphy_register(const char *name,
int (*read) (const char *devname, unsigned char addr, int (*read)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short *value), unsigned char reg, unsigned short *value),
int (*write) (const char *devname, unsigned char addr, int (*write)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short value)) unsigned char reg, unsigned short value))
{ {
struct mii_dev *new_dev; struct mii_dev *new_dev;
@ -112,30 +112,30 @@ void miiphy_register(const char *name,
} }
/* allocate memory */ /* allocate memory */
name_len = strlen (name); name_len = strlen(name);
new_dev = new_dev =
(struct mii_dev *)malloc (sizeof (struct mii_dev) + name_len + 1); (struct mii_dev *)malloc(sizeof(struct mii_dev) + name_len + 1);
if (new_dev == NULL) { if (new_dev == NULL) {
printf ("miiphy_register: cannot allocate memory for '%s'\n", printf("miiphy_register: cannot allocate memory for '%s'\n",
name); name);
return; return;
} }
memset (new_dev, 0, sizeof (struct mii_dev) + name_len); memset(new_dev, 0, sizeof(struct mii_dev) + name_len);
/* initalize mii_dev struct fields */ /* initalize mii_dev struct fields */
INIT_LIST_HEAD (&new_dev->link); INIT_LIST_HEAD(&new_dev->link);
new_dev->read = read; new_dev->read = read;
new_dev->write = write; new_dev->write = write;
new_dev->name = new_name = (char *)(new_dev + 1); new_dev->name = new_name = (char *)(new_dev + 1);
strncpy (new_name, name, name_len); strncpy(new_name, name, name_len);
new_name[name_len] = '\0'; new_name[name_len] = '\0';
debug ("miiphy_register: added '%s', read=0x%08lx, write=0x%08lx\n", debug("miiphy_register: added '%s', read=0x%08lx, write=0x%08lx\n",
new_dev->name, new_dev->read, new_dev->write); new_dev->name, new_dev->read, new_dev->write);
/* add it to the list */ /* add it to the list */
list_add_tail (&new_dev->link, &mii_devs); list_add_tail(&new_dev->link, &mii_devs);
if (!current_mii) if (!current_mii)
current_mii = new_dev; current_mii = new_dev;
@ -220,20 +220,20 @@ int miiphy_write(const char *devname, unsigned char addr, unsigned char reg,
* *
* Print out list of registered MII capable devices. * Print out list of registered MII capable devices.
*/ */
void miiphy_listdev (void) void miiphy_listdev(void)
{ {
struct list_head *entry; struct list_head *entry;
struct mii_dev *dev; struct mii_dev *dev;
puts ("MII devices: "); puts("MII devices: ");
list_for_each (entry, &mii_devs) { list_for_each(entry, &mii_devs) {
dev = list_entry (entry, struct mii_dev, link); dev = list_entry(entry, struct mii_dev, link);
printf ("'%s' ", dev->name); printf("'%s' ", dev->name);
} }
puts ("\n"); puts("\n");
if (current_mii) if (current_mii)
printf ("Current device: '%s'\n", current_mii->name); printf("Current device: '%s'\n", current_mii->name);
} }
/***************************************************************************** /*****************************************************************************
@ -253,30 +253,30 @@ int miiphy_info(const char *devname, unsigned char addr, unsigned int *oui,
unsigned int reg = 0; unsigned int reg = 0;
unsigned short tmp; unsigned short tmp;
if (miiphy_read (devname, addr, MII_PHYSID2, &tmp) != 0) { if (miiphy_read(devname, addr, MII_PHYSID2, &tmp) != 0) {
debug ("PHY ID register 2 read failed\n"); debug("PHY ID register 2 read failed\n");
return (-1); return -1;
} }
reg = tmp; reg = tmp;
debug ("MII_PHYSID2 @ 0x%x = 0x%04x\n", addr, reg); debug("MII_PHYSID2 @ 0x%x = 0x%04x\n", addr, reg);
if (reg == 0xFFFF) { if (reg == 0xFFFF) {
/* No physical device present at this address */ /* No physical device present at this address */
return (-1); return -1;
} }
if (miiphy_read (devname, addr, MII_PHYSID1, &tmp) != 0) { if (miiphy_read(devname, addr, MII_PHYSID1, &tmp) != 0) {
debug ("PHY ID register 1 read failed\n"); debug("PHY ID register 1 read failed\n");
return (-1); return -1;
} }
reg |= tmp << 16; reg |= tmp << 16;
debug ("PHY_PHYIDR[1,2] @ 0x%x = 0x%08x\n", addr, reg); debug("PHY_PHYIDR[1,2] @ 0x%x = 0x%08x\n", addr, reg);
*oui = (reg >> 10); *oui = (reg >> 10);
*model = (unsigned char)((reg >> 4) & 0x0000003F); *model = (unsigned char)((reg >> 4) & 0x0000003F);
*rev = (unsigned char)(reg & 0x0000000F); *rev = (unsigned char)(reg & 0x0000000F);
return (0); return 0;
} }
/***************************************************************************** /*****************************************************************************
@ -290,16 +290,16 @@ int miiphy_reset(const char *devname, unsigned char addr)
unsigned short reg; unsigned short reg;
int timeout = 500; int timeout = 500;
if (miiphy_read (devname, addr, MII_BMCR, &reg) != 0) { if (miiphy_read(devname, addr, MII_BMCR, &reg) != 0) {
debug ("PHY status read failed\n"); debug("PHY status read failed\n");
return (-1); return -1;
} }
if (miiphy_write (devname, addr, MII_BMCR, reg | BMCR_RESET) != 0) { if (miiphy_write(devname, addr, MII_BMCR, reg | BMCR_RESET) != 0) {
debug ("PHY reset failed\n"); debug("PHY reset failed\n");
return (-1); return -1;
} }
#ifdef CONFIG_PHY_RESET_DELAY #ifdef CONFIG_PHY_RESET_DELAY
udelay (CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */ udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */
#endif #endif
/* /*
* Poll the control register for the reset bit to go to 0 (it is * Poll the control register for the reset bit to go to 0 (it is
@ -315,12 +315,12 @@ int miiphy_reset(const char *devname, unsigned char addr)
udelay(1000); udelay(1000);
} }
if ((reg & 0x8000) == 0) { if ((reg & 0x8000) == 0) {
return (0); return 0;
} else { } else {
puts ("PHY reset timed out\n"); puts("PHY reset timed out\n");
return (-1); return -1;
} }
return (0); return 0;
} }
/***************************************************************************** /*****************************************************************************
@ -338,33 +338,33 @@ int miiphy_speed(const char *devname, unsigned char addr)
* Check for 1000BASE-X. If it is supported, then assume that the speed * Check for 1000BASE-X. If it is supported, then assume that the speed
* is 1000. * is 1000.
*/ */
if (miiphy_is_1000base_x (devname, addr)) { if (miiphy_is_1000base_x(devname, addr))
return _1000BASET; return _1000BASET;
}
/* /*
* No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set. * No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
*/ */
/* Check for 1000BASE-T. */ /* Check for 1000BASE-T. */
if (miiphy_read (devname, addr, MII_STAT1000, &btsr)) { if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
printf ("PHY 1000BT status"); printf("PHY 1000BT status");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
if (btsr != 0xFFFF && if (btsr != 0xFFFF &&
(btsr & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD))) { (btsr & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD)))
return _1000BASET; return _1000BASET;
}
#endif /* CONFIG_PHY_GIGE */ #endif /* CONFIG_PHY_GIGE */
/* Check Basic Management Control Register first. */ /* Check Basic Management Control Register first. */
if (miiphy_read (devname, addr, MII_BMCR, &bmcr)) { if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
printf ("PHY speed"); printf("PHY speed");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
/* Check if auto-negotiation is on. */ /* Check if auto-negotiation is on. */
if (bmcr & BMCR_ANENABLE) { if (bmcr & BMCR_ANENABLE) {
/* Get auto-negotiation results. */ /* Get auto-negotiation results. */
if (miiphy_read (devname, addr, MII_LPA, &anlpar)) { if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
printf ("PHY AN speed"); printf("PHY AN speed");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
return (anlpar & LPA_100) ? _100BASET : _10BASET; return (anlpar & LPA_100) ? _100BASET : _10BASET;
@ -373,7 +373,7 @@ int miiphy_speed(const char *devname, unsigned char addr)
return (bmcr & BMCR_SPEED100) ? _100BASET : _10BASET; return (bmcr & BMCR_SPEED100) ? _100BASET : _10BASET;
miiphy_read_failed: miiphy_read_failed:
printf (" read failed, assuming 10BASE-T\n"); printf(" read failed, assuming 10BASE-T\n");
return _10BASET; return _10BASET;
} }
@ -389,10 +389,10 @@ int miiphy_duplex(const char *devname, unsigned char addr)
u16 btsr; u16 btsr;
/* Check for 1000BASE-X. */ /* Check for 1000BASE-X. */
if (miiphy_is_1000base_x (devname, addr)) { if (miiphy_is_1000base_x(devname, addr)) {
/* 1000BASE-X */ /* 1000BASE-X */
if (miiphy_read (devname, addr, MII_LPA, &anlpar)) { if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
printf ("1000BASE-X PHY AN duplex"); printf("1000BASE-X PHY AN duplex");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
} }
@ -400,8 +400,8 @@ int miiphy_duplex(const char *devname, unsigned char addr)
* No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set. * No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
*/ */
/* Check for 1000BASE-T. */ /* Check for 1000BASE-T. */
if (miiphy_read (devname, addr, MII_STAT1000, &btsr)) { if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
printf ("PHY 1000BT status"); printf("PHY 1000BT status");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
if (btsr != 0xFFFF) { if (btsr != 0xFFFF) {
@ -414,15 +414,15 @@ int miiphy_duplex(const char *devname, unsigned char addr)
#endif /* CONFIG_PHY_GIGE */ #endif /* CONFIG_PHY_GIGE */
/* Check Basic Management Control Register first. */ /* Check Basic Management Control Register first. */
if (miiphy_read (devname, addr, MII_BMCR, &bmcr)) { if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
puts ("PHY duplex"); puts("PHY duplex");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
/* Check if auto-negotiation is on. */ /* Check if auto-negotiation is on. */
if (bmcr & BMCR_ANENABLE) { if (bmcr & BMCR_ANENABLE) {
/* Get auto-negotiation results. */ /* Get auto-negotiation results. */
if (miiphy_read (devname, addr, MII_LPA, &anlpar)) { if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
puts ("PHY AN duplex"); puts("PHY AN duplex");
goto miiphy_read_failed; goto miiphy_read_failed;
} }
return (anlpar & (LPA_10FULL | LPA_100FULL)) ? return (anlpar & (LPA_10FULL | LPA_100FULL)) ?
@ -432,7 +432,7 @@ int miiphy_duplex(const char *devname, unsigned char addr)
return (bmcr & BMCR_FULLDPLX) ? FULL : HALF; return (bmcr & BMCR_FULLDPLX) ? FULL : HALF;
miiphy_read_failed: miiphy_read_failed:
printf (" read failed, assuming half duplex\n"); printf(" read failed, assuming half duplex\n");
return HALF; return HALF;
} }
@ -446,8 +446,8 @@ int miiphy_is_1000base_x(const char *devname, unsigned char addr)
#if defined(CONFIG_PHY_GIGE) #if defined(CONFIG_PHY_GIGE)
u16 exsr; u16 exsr;
if (miiphy_read (devname, addr, MII_ESTATUS, &exsr)) { if (miiphy_read(devname, addr, MII_ESTATUS, &exsr)) {
printf ("PHY extended status read failed, assuming no " printf("PHY extended status read failed, assuming no "
"1000BASE-X\n"); "1000BASE-X\n");
return 0; return 0;
} }
@ -467,17 +467,17 @@ int miiphy_link(const char *devname, unsigned char addr)
unsigned short reg; unsigned short reg;
/* dummy read; needed to latch some phys */ /* dummy read; needed to latch some phys */
(void)miiphy_read (devname, addr, MII_BMSR, &reg); (void)miiphy_read(devname, addr, MII_BMSR, &reg);
if (miiphy_read (devname, addr, MII_BMSR, &reg)) { if (miiphy_read(devname, addr, MII_BMSR, &reg)) {
puts ("MII_BMSR read failed, assuming no link\n"); puts("MII_BMSR read failed, assuming no link\n");
return (0); return 0;
} }
/* Determine if a link is active */ /* Determine if a link is active */
if ((reg & BMSR_LSTATUS) != 0) { if ((reg & BMSR_LSTATUS) != 0) {
return (1); return 1;
} else { } else {
return (0); return 0;
} }
} }
#endif #endif

36
include/miiphy.h
View File

@ -37,32 +37,32 @@
#include <linux/mii.h> #include <linux/mii.h>
#include <net.h> #include <net.h>
int miiphy_read (const char *devname, unsigned char addr, unsigned char reg, int miiphy_read(const char *devname, unsigned char addr, unsigned char reg,
unsigned short *value); unsigned short *value);
int miiphy_write (const char *devname, unsigned char addr, unsigned char reg, int miiphy_write(const char *devname, unsigned char addr, unsigned char reg,
unsigned short value); unsigned short value);
int miiphy_info (const char *devname, unsigned char addr, unsigned int *oui, int miiphy_info(const char *devname, unsigned char addr, unsigned int *oui,
unsigned char *model, unsigned char *rev); unsigned char *model, unsigned char *rev);
int miiphy_reset (const char *devname, unsigned char addr); int miiphy_reset(const char *devname, unsigned char addr);
int miiphy_speed (const char *devname, unsigned char addr); int miiphy_speed(const char *devname, unsigned char addr);
int miiphy_duplex (const char *devname, unsigned char addr); int miiphy_duplex(const char *devname, unsigned char addr);
int miiphy_is_1000base_x (const char *devname, unsigned char addr); int miiphy_is_1000base_x(const char *devname, unsigned char addr);
#ifdef CONFIG_SYS_FAULT_ECHO_LINK_DOWN #ifdef CONFIG_SYS_FAULT_ECHO_LINK_DOWN
int miiphy_link (const char *devname, unsigned char addr); int miiphy_link(const char *devname, unsigned char addr);
#endif #endif
void miiphy_init (void); void miiphy_init(void);
void miiphy_register (const char *devname, void miiphy_register(const char *devname,
int (*read) (const char *devname, unsigned char addr, int (*read)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short *value), unsigned char reg, unsigned short *value),
int (*write) (const char *devname, unsigned char addr, int (*write)(const char *devname, unsigned char addr,
unsigned char reg, unsigned short value)); unsigned char reg, unsigned short value));
int miiphy_set_current_dev (const char *devname); int miiphy_set_current_dev(const char *devname);
const char *miiphy_get_current_dev (void); const char *miiphy_get_current_dev(void);
void miiphy_listdev (void); void miiphy_listdev(void);
#ifdef CONFIG_BITBANGMII #ifdef CONFIG_BITBANGMII
@ -85,10 +85,10 @@ struct bb_miiphy_bus {
extern struct bb_miiphy_bus bb_miiphy_buses[]; extern struct bb_miiphy_bus bb_miiphy_buses[];
extern int bb_miiphy_buses_num; extern int bb_miiphy_buses_num;
void bb_miiphy_init (void); void bb_miiphy_init(void);
int bb_miiphy_read (const char *devname, unsigned char addr, int bb_miiphy_read(const char *devname, unsigned char addr,
unsigned char reg, unsigned short *value); unsigned char reg, unsigned short *value);
int bb_miiphy_write (const char *devname, unsigned char addr, int bb_miiphy_write(const char *devname, unsigned char addr,
unsigned char reg, unsigned short value); unsigned char reg, unsigned short value);
#endif #endif