Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-12-29 14:33:08 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/drivers/net/lpc32xx_eth.c
Gregory CLEMENT 32dfc12b70 net: lpc32xx: Use IRAM for transmit buffer 
Since the introduction of the driver, some memory in IRAM is reserved for
the TX buffers.

However there are not used but instead of it, it is the buffer provided
by the net stack which is used. As stated in the comment of the driver,
not using the IRAM buffer could cause cache issue and lower the
throughput.

For the second argument it is less the case for transmitting buffers
because the throughput gain in IRAM is mitigated by the time to copy the
data from RAM to IRAM, but the first argument is still valid and indeed
this patch fixes issue seen with Ethernet on some boards

Signed-off-by: Gregory CLEMENT <gregory.clement@bootlin.com>
2019-04-26 18:58:20 -04:00

649 lines
18 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* LPC32xx Ethernet MAC interface driver
*
* (C) Copyright 2014 DENX Software Engineering GmbH
* Written-by: Albert ARIBAUD - 3ADEV <albert.aribaud@3adev.fr>
*/
#include <common.h>
#include <net.h>
#include <malloc.h>
#include <miiphy.h>
#include <asm/io.h>
#include <linux/errno.h>
#include <asm/types.h>
#include <asm/system.h>
#include <asm/byteorder.h>
#include <asm/arch/cpu.h>
#include <asm/arch/config.h>
/*
* Notes:
*
* 1. Unless specified otherwise, all references to tables or paragraphs
* are to UM10326, "LPC32x0 and LPC32x0/01 User manual".
*
* 2. Only bitfield masks/values which are actually used by the driver
* are defined.
*/
/* a single RX descriptor. The controller has an array of these */
struct lpc32xx_eth_rxdesc {
u32 packet; /* Receive packet pointer */
u32 control; /* Descriptor command status */
};
#define LPC32XX_ETH_RX_DESC_SIZE (sizeof(struct lpc32xx_eth_rxdesc))
/* RX control bitfields/masks (see Table 330) */
#define LPC32XX_ETH_RX_CTRL_SIZE_MASK 0x000007FF
#define LPC32XX_ETH_RX_CTRL_UNUSED 0x7FFFF800
#define LPC32XX_ETH_RX_CTRL_INTERRUPT 0x80000000
/* a single RX status. The controller has an array of these */
struct lpc32xx_eth_rxstat {
u32 statusinfo; /* Transmit Descriptor status */
u32 statushashcrc; /* Transmit Descriptor CRCs */
};
#define LPC32XX_ETH_RX_STAT_SIZE (sizeof(struct lpc32xx_eth_rxstat))
/* RX statusinfo bitfields/masks (see Table 333) */
#define RX_STAT_RXSIZE 0x000007FF
/* Helper: OR of all errors except RANGE */
#define RX_STAT_ERRORS 0x1B800000
/* a single TX descriptor. The controller has an array of these */
struct lpc32xx_eth_txdesc {
u32 packet; /* Transmit packet pointer */
u32 control; /* Descriptor control */
};
#define LPC32XX_ETH_TX_DESC_SIZE (sizeof(struct lpc32xx_eth_txdesc))
/* TX control bitfields/masks (see Table 335) */
#define TX_CTRL_TXSIZE 0x000007FF
#define TX_CTRL_LAST 0x40000000
/* a single TX status. The controller has an array of these */
struct lpc32xx_eth_txstat {
u32 statusinfo; /* Transmit Descriptor status */
};
#define LPC32XX_ETH_TX_STAT_SIZE (sizeof(struct lpc32xx_eth_txstat))
/* Ethernet MAC interface registers (see Table 283) */
struct lpc32xx_eth_registers {
/* MAC registers - 0x3106_0000 to 0x3106_01FC */
u32 mac1; /* MAC configuration register 1 */
u32 mac2; /* MAC configuration register 2 */
u32 ipgt; /* Back-to-back Inter-Packet Gap reg. */
u32 ipgr; /* Non-back-to-back IPG register */
u32 clrt; /* Collision Window / Retry register */
u32 maxf; /* Maximum Frame register */
u32 supp; /* Phy Support register */
u32 test;
u32 mcfg; /* MII management configuration reg. */
u32 mcmd; /* MII management command register */
u32 madr; /* MII management address register */
u32 mwtd; /* MII management wite data register */
u32 mrdd; /* MII management read data register */
u32 mind; /* MII management indicators register */
u32 reserved1[2];
u32 sa0; /* Station address register 0 */
u32 sa1; /* Station address register 1 */
u32 sa2; /* Station address register 2 */
u32 reserved2[45];
/* Control registers */
u32 command;
u32 status;
u32 rxdescriptor;
u32 rxstatus;
u32 rxdescriptornumber; /* actually, number MINUS ONE */
u32 rxproduceindex; /* head of rx desc fifo */
u32 rxconsumeindex; /* tail of rx desc fifo */
u32 txdescriptor;
u32 txstatus;
u32 txdescriptornumber; /* actually, number MINUS ONE */
u32 txproduceindex; /* head of rx desc fifo */
u32 txconsumeindex; /* tail of rx desc fifo */
u32 reserved3[10];
u32 tsv0; /* Transmit status vector register 0 */
u32 tsv1; /* Transmit status vector register 1 */
u32 rsv; /* Receive status vector register */
u32 reserved4[3];
u32 flowcontrolcounter;
u32 flowcontrolstatus;
u32 reserved5[34];
/* RX filter registers - 0x3106_0200 to 0x3106_0FDC */
u32 rxfilterctrl;
u32 rxfilterwolstatus;
u32 rxfilterwolclear;
u32 reserved6;
u32 hashfilterl;
u32 hashfilterh;
u32 reserved7[882];
/* Module control registers - 0x3106_0FE0 to 0x3106_0FF8 */
u32 intstatus; /* Interrupt status register */
u32 intenable;
u32 intclear;
u32 intset;
u32 reserved8;
u32 powerdown;
u32 reserved9;
};
/* MAC1 register bitfields/masks and offsets (see Table 283) */
#define MAC1_RECV_ENABLE 0x00000001
#define MAC1_PASS_ALL_RX_FRAMES 0x00000002
#define MAC1_SOFT_RESET 0x00008000
/* Helper: general reset */
#define MAC1_RESETS 0x0000CF00
/* MAC2 register bitfields/masks and offsets (see Table 284) */
#define MAC2_FULL_DUPLEX 0x00000001
#define MAC2_CRC_ENABLE 0x00000010
#define MAC2_PAD_CRC_ENABLE 0x00000020
/* SUPP register bitfields/masks and offsets (see Table 290) */
#define SUPP_SPEED 0x00000100
/* MCFG register bitfields/masks and offsets (see Table 292) */
#define MCFG_RESET_MII_MGMT 0x00008000
/* divide clock by 28 (see Table 293) */
#define MCFG_CLOCK_SELECT_DIV28 0x0000001C
/* MADR register bitfields/masks and offsets (see Table 295) */
#define MADR_REG_MASK 0x0000001F
#define MADR_PHY_MASK 0x00001F00
#define MADR_REG_OFFSET 0
#define MADR_PHY_OFFSET 8
/* MIND register bitfields/masks (see Table 298) */
#define MIND_BUSY 0x00000001
/* COMMAND register bitfields/masks and offsets (see Table 283) */
#define COMMAND_RXENABLE 0x00000001
#define COMMAND_TXENABLE 0x00000002
#define COMMAND_PASSRUNTFRAME 0x00000040
#define COMMAND_RMII 0x00000200
#define COMMAND_FULL_DUPLEX 0x00000400
/* Helper: general reset */
#define COMMAND_RESETS 0x00000038
/* STATUS register bitfields/masks and offsets (see Table 283) */
#define STATUS_RXSTATUS 0x00000001
#define STATUS_TXSTATUS 0x00000002
/* RXFILTERCTRL register bitfields/masks (see Table 319) */
#define RXFILTERCTRL_ACCEPTBROADCAST 0x00000002
#define RXFILTERCTRL_ACCEPTPERFECT 0x00000020
/* Buffers and descriptors */
#define ATTRS(n) __aligned(n)
#define TX_BUF_COUNT 4
#define RX_BUF_COUNT 4
struct lpc32xx_eth_buffers {
ATTRS(4) struct lpc32xx_eth_txdesc tx_desc[TX_BUF_COUNT];
ATTRS(4) struct lpc32xx_eth_txstat tx_stat[TX_BUF_COUNT];
ATTRS(PKTALIGN) u8 tx_buf[TX_BUF_COUNT*PKTSIZE_ALIGN];
ATTRS(4) struct lpc32xx_eth_rxdesc rx_desc[RX_BUF_COUNT];
ATTRS(8) struct lpc32xx_eth_rxstat rx_stat[RX_BUF_COUNT];
ATTRS(PKTALIGN) u8 rx_buf[RX_BUF_COUNT*PKTSIZE_ALIGN];
};
/* port device data struct */
struct lpc32xx_eth_device {
struct eth_device dev;
struct lpc32xx_eth_registers *regs;
struct lpc32xx_eth_buffers *bufs;
bool phy_rmii;
};
#define LPC32XX_ETH_DEVICE_SIZE (sizeof(struct lpc32xx_eth_device))
/* generic macros */
#define to_lpc32xx_eth(_d) container_of(_d, struct lpc32xx_eth_device, dev)
/* timeout for MII polling */
#define MII_TIMEOUT 10000000
/* limits for PHY and register addresses */
#define MII_MAX_REG (MADR_REG_MASK >> MADR_REG_OFFSET)
#define MII_MAX_PHY (MADR_PHY_MASK >> MADR_PHY_OFFSET)
#if defined(CONFIG_PHYLIB) || defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
/*
* mii_reg_read - miiphy_read callback function.
*
* Returns 16bit phy register value, or 0xffff on error
*/
static int mii_reg_read(struct mii_dev *bus, int phy_adr, int devad,
int reg_ofs)
{
u16 data = 0;
struct eth_device *dev = eth_get_dev_by_name(bus->name);
struct lpc32xx_eth_device *dlpc32xx_eth = to_lpc32xx_eth(dev);
struct lpc32xx_eth_registers *regs = dlpc32xx_eth->regs;
u32 mind_reg;
u32 timeout;
/* check parameters */
if (phy_adr > MII_MAX_PHY) {
printf("%s:%u: Invalid PHY address %d\n",
__func__, __LINE__, phy_adr);
return -EFAULT;
}
if (reg_ofs > MII_MAX_REG) {
printf("%s:%u: Invalid register offset %d\n",
__func__, __LINE__, reg_ofs);
return -EFAULT;
}
/* write the phy and reg addressse into the MII address reg */
writel((phy_adr << MADR_PHY_OFFSET) | (reg_ofs << MADR_REG_OFFSET),
&regs->madr);
/* write 1 to the MII command register to cause a read */
writel(1, &regs->mcmd);
/* wait till the MII is not busy */
timeout = MII_TIMEOUT;
do {
/* read MII indicators register */
mind_reg = readl(&regs->mind);
if (--timeout == 0)
break;
} while (mind_reg & MIND_BUSY);
/* write 0 to the MII command register to finish the read */
writel(0, &regs->mcmd);
if (timeout == 0) {
printf("%s:%u: MII busy timeout\n", __func__, __LINE__);
return -EFAULT;
}
data = (u16) readl(&regs->mrdd);
debug("%s:(adr %d, off %d) => %04x\n", __func__, phy_adr,
reg_ofs, data);
return data;
}
/*
* mii_reg_write - imiiphy_write callback function.
*
* Returns 0 if write succeed, -EINVAL on bad parameters
* -ETIME on timeout
*/
static int mii_reg_write(struct mii_dev *bus, int phy_adr, int devad,
int reg_ofs, u16 data)
{
struct eth_device *dev = eth_get_dev_by_name(bus->name);
struct lpc32xx_eth_device *dlpc32xx_eth = to_lpc32xx_eth(dev);
struct lpc32xx_eth_registers *regs = dlpc32xx_eth->regs;
u32 mind_reg;
u32 timeout;
/* check parameters */
if (phy_adr > MII_MAX_PHY) {
printf("%s:%u: Invalid PHY address %d\n",
__func__, __LINE__, phy_adr);
return -EFAULT;
}
if (reg_ofs > MII_MAX_REG) {
printf("%s:%u: Invalid register offset %d\n",
__func__, __LINE__, reg_ofs);
return -EFAULT;
}
/* write the phy and reg addressse into the MII address reg */
writel((phy_adr << MADR_PHY_OFFSET) | (reg_ofs << MADR_REG_OFFSET),
&regs->madr);
/* write data to the MII write register */
writel(data, &regs->mwtd);
/* wait till the MII is not busy */
timeout = MII_TIMEOUT;
do {
/* read MII indicators register */
mind_reg = readl(&regs->mind);
if (--timeout == 0)
break;
} while (mind_reg & MIND_BUSY);
if (timeout == 0) {
printf("%s:%u: MII busy timeout\n", __func__,
__LINE__);
return -EFAULT;
}
/*debug("%s:(adr %d, off %d) <= %04x\n", __func__, phy_adr,
reg_ofs, data);*/
return 0;
}
#endif
/*
* Provide default Ethernet buffers base address if target did not.
* Locate buffers in SRAM at 0x00001000 to avoid cache issues and
* maximize throughput.
*/
#if !defined(CONFIG_LPC32XX_ETH_BUFS_BASE)
#define CONFIG_LPC32XX_ETH_BUFS_BASE 0x00001000
#endif
static struct lpc32xx_eth_device lpc32xx_eth = {
.regs = (struct lpc32xx_eth_registers *)LPC32XX_ETH_BASE,
.bufs = (struct lpc32xx_eth_buffers *)CONFIG_LPC32XX_ETH_BUFS_BASE,
#if defined(CONFIG_RMII)
.phy_rmii = true,
#endif
};
#define TX_TIMEOUT 10000
static int lpc32xx_eth_send(struct eth_device *dev, void *dataptr, int datasize)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct lpc32xx_eth_registers *regs = lpc32xx_eth_device->regs;
struct lpc32xx_eth_buffers *bufs = lpc32xx_eth_device->bufs;
int timeout, tx_index;
/* time out if transmit descriptor array remains full too long */
timeout = TX_TIMEOUT;
while ((readl(&regs->status) & STATUS_TXSTATUS) &&
(readl(&regs->txconsumeindex)
== readl(&regs->txproduceindex))) {
if (timeout-- == 0)
return -1;
}
/* determine next transmit packet index to use */
tx_index = readl(&regs->txproduceindex);
/* set up transmit packet */
memcpy((void *)&bufs->tx_buf[tx_index * PKTSIZE_ALIGN],
(void *)dataptr, datasize);
writel(TX_CTRL_LAST | ((datasize - 1) & TX_CTRL_TXSIZE),
&bufs->tx_desc[tx_index].control);
writel(0, &bufs->tx_stat[tx_index].statusinfo);
/* pass transmit packet to DMA engine */
tx_index = (tx_index + 1) % TX_BUF_COUNT;
writel(tx_index, &regs->txproduceindex);
/* transmission succeeded */
return 0;
}
#define RX_TIMEOUT 1000000
static int lpc32xx_eth_recv(struct eth_device *dev)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct lpc32xx_eth_registers *regs = lpc32xx_eth_device->regs;
struct lpc32xx_eth_buffers *bufs = lpc32xx_eth_device->bufs;
int timeout, rx_index;
/* time out if receive descriptor array remains empty too long */
timeout = RX_TIMEOUT;
while (readl(&regs->rxproduceindex) == readl(&regs->rxconsumeindex)) {
if (timeout-- == 0)
return -1;
}
/* determine next receive packet index to use */
rx_index = readl(&regs->rxconsumeindex);
/* if data was valid, pass it on */
if (!(bufs->rx_stat[rx_index].statusinfo & RX_STAT_ERRORS)) {
net_process_received_packet(
&(bufs->rx_buf[rx_index * PKTSIZE_ALIGN]),
(bufs->rx_stat[rx_index].statusinfo
& RX_STAT_RXSIZE) + 1);
}
/* pass receive slot back to DMA engine */
rx_index = (rx_index + 1) % RX_BUF_COUNT;
writel(rx_index, &regs->rxconsumeindex);
/* reception successful */
return 0;
}
static int lpc32xx_eth_write_hwaddr(struct eth_device *dev)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct lpc32xx_eth_registers *regs = lpc32xx_eth_device->regs;
/* Save station address */
writel((unsigned long) (dev->enetaddr[0] |
(dev->enetaddr[1] << 8)), &regs->sa2);
writel((unsigned long) (dev->enetaddr[2] |
(dev->enetaddr[3] << 8)), &regs->sa1);
writel((unsigned long) (dev->enetaddr[4] |
(dev->enetaddr[5] << 8)), &regs->sa0);
return 0;
}
static int lpc32xx_eth_init(struct eth_device *dev)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct lpc32xx_eth_registers *regs = lpc32xx_eth_device->regs;
struct lpc32xx_eth_buffers *bufs = lpc32xx_eth_device->bufs;
int index;
/* Initial MAC initialization */
writel(MAC1_PASS_ALL_RX_FRAMES, &regs->mac1);
writel(MAC2_PAD_CRC_ENABLE | MAC2_CRC_ENABLE, &regs->mac2);
writel(PKTSIZE_ALIGN, &regs->maxf);
/* Retries: 15 (0xF). Collision window: 57 (0x37). */
writel(0x370F, &regs->clrt);
/* Set IP gap pt 2 to default 0x12 but pt 1 to non-default 0 */
writel(0x0012, &regs->ipgr);
/* pass runt (smaller than 64 bytes) frames */
if (lpc32xx_eth_device->phy_rmii)
writel(COMMAND_PASSRUNTFRAME | COMMAND_RMII, &regs->command);
else
writel(COMMAND_PASSRUNTFRAME, &regs->command);
/* Configure Full/Half Duplex mode */
if (miiphy_duplex(dev->name, CONFIG_PHY_ADDR) == FULL) {
setbits_le32(&regs->mac2, MAC2_FULL_DUPLEX);
setbits_le32(&regs->command, COMMAND_FULL_DUPLEX);
writel(0x15, &regs->ipgt);
} else {
writel(0x12, &regs->ipgt);
}
/* Configure 100MBit/10MBit mode */
if (miiphy_speed(dev->name, CONFIG_PHY_ADDR) == _100BASET)
writel(SUPP_SPEED, &regs->supp);
else
writel(0, &regs->supp);
/* Save station address */
writel((unsigned long) (dev->enetaddr[0] |
(dev->enetaddr[1] << 8)), &regs->sa2);
writel((unsigned long) (dev->enetaddr[2] |
(dev->enetaddr[3] << 8)), &regs->sa1);
writel((unsigned long) (dev->enetaddr[4] |
(dev->enetaddr[5] << 8)), &regs->sa0);
/* set up transmit buffers */
for (index = 0; index < TX_BUF_COUNT; index++) {
bufs->tx_desc[index].control = 0;
bufs->tx_stat[index].statusinfo = 0;
}
writel((u32)(&bufs->tx_desc), (u32 *)&regs->txdescriptor);
writel((u32)(&bufs->tx_stat), &regs->txstatus);
writel(TX_BUF_COUNT-1, &regs->txdescriptornumber);
/* set up receive buffers */
for (index = 0; index < RX_BUF_COUNT; index++) {
bufs->rx_desc[index].packet =
(u32) (bufs->rx_buf+index*PKTSIZE_ALIGN);
bufs->rx_desc[index].control = PKTSIZE_ALIGN - 1;
bufs->rx_stat[index].statusinfo = 0;
bufs->rx_stat[index].statushashcrc = 0;
}
writel((u32)(&bufs->rx_desc), &regs->rxdescriptor);
writel((u32)(&bufs->rx_stat), &regs->rxstatus);
writel(RX_BUF_COUNT-1, &regs->rxdescriptornumber);
/* set up transmit buffers */
for (index = 0; index < TX_BUF_COUNT; index++)
bufs->tx_desc[index].packet =
(u32)(bufs->tx_buf + index * PKTSIZE_ALIGN);
/* Enable broadcast and matching address packets */
writel(RXFILTERCTRL_ACCEPTBROADCAST |
RXFILTERCTRL_ACCEPTPERFECT, &regs->rxfilterctrl);
/* Clear and disable interrupts */
writel(0xFFFF, &regs->intclear);
writel(0, &regs->intenable);
/* Enable receive and transmit mode of MAC ethernet core */
setbits_le32(&regs->command, COMMAND_RXENABLE | COMMAND_TXENABLE);
setbits_le32(&regs->mac1, MAC1_RECV_ENABLE);
/*
* Perform a 'dummy' first send to work around Ethernet.1
* erratum (see ES_LPC3250 rev. 9 dated 1 June 2011).
* Use zeroed "index" variable as the dummy.
*/
index = 0;
lpc32xx_eth_send(dev, &index, 4);
return 0;
}
static int lpc32xx_eth_halt(struct eth_device *dev)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct lpc32xx_eth_registers *regs = lpc32xx_eth_device->regs;
/* Reset all MAC logic */
writel(MAC1_RESETS, &regs->mac1);
writel(COMMAND_RESETS, &regs->command);
/* Let reset condition settle */
udelay(2000);
return 0;
}
#if defined(CONFIG_PHYLIB)
int lpc32xx_eth_phylib_init(struct eth_device *dev, int phyid)
{
struct lpc32xx_eth_device *lpc32xx_eth_device =
container_of(dev, struct lpc32xx_eth_device, dev);
struct mii_dev *bus;
struct phy_device *phydev;
int ret;
bus = mdio_alloc();
if (!bus) {
printf("mdio_alloc failed\n");
return -ENOMEM;
}
bus->read = mii_reg_read;
bus->write = mii_reg_write;
strcpy(bus->name, dev->name);
ret = mdio_register(bus);
if (ret) {
printf("mdio_register failed\n");
free(bus);
return -ENOMEM;
}
if (lpc32xx_eth_device->phy_rmii)
phydev = phy_connect(bus, phyid, dev, PHY_INTERFACE_MODE_RMII);
else
phydev = phy_connect(bus, phyid, dev, PHY_INTERFACE_MODE_MII);
if (!phydev) {
printf("phy_connect failed\n");
return -ENODEV;
}
phy_config(phydev);
phy_startup(phydev);
return 0;
}
#endif
int lpc32xx_eth_initialize(bd_t *bis)
{
struct eth_device *dev = &lpc32xx_eth.dev;
struct lpc32xx_eth_registers *regs = lpc32xx_eth.regs;
/*
* Set RMII management clock rate. With HCLK at 104 MHz and
* a divider of 28, this will be 3.72 MHz.
*/
writel(MCFG_RESET_MII_MGMT, &regs->mcfg);
writel(MCFG_CLOCK_SELECT_DIV28, &regs->mcfg);
/* Reset all MAC logic */
writel(MAC1_RESETS, &regs->mac1);
writel(COMMAND_RESETS, &regs->command);
/* wait 10 ms for the whole I/F to reset */
udelay(10000);
/* must be less than sizeof(dev->name) */
strcpy(dev->name, "eth0");
dev->init = (void *)lpc32xx_eth_init;
dev->halt = (void *)lpc32xx_eth_halt;
dev->send = (void *)lpc32xx_eth_send;
dev->recv = (void *)lpc32xx_eth_recv;
dev->write_hwaddr = (void *)lpc32xx_eth_write_hwaddr;
/* Release SOFT reset to let MII talk to PHY */
clrbits_le32(&regs->mac1, MAC1_SOFT_RESET);
/* register driver before talking to phy */
eth_register(dev);
#if defined(CONFIG_PHYLIB)
lpc32xx_eth_phylib_init(dev, CONFIG_PHY_ADDR);
#elif defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
int retval;
struct mii_dev *mdiodev = mdio_alloc();
if (!mdiodev)
return -ENOMEM;
strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN);
mdiodev->read = mii_reg_read;
mdiodev->write = mii_reg_write;
retval = mdio_register(mdiodev);
if (retval < 0)
return retval;
#endif
return 0;
}
Reference in a new issue View git blame Copy permalink