UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'amd811e-cleanups' 

Varka Bhadram says:

====================
This series cleanup for AMD8111E ethernet driver

v1: fix checkpatch warnings.
v2: added new line in debug messages
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2014-07-14 19:14:44 -07:00
parent 30c9e022c5 46c73ecc61
commit 0854a7f132
1 changed files with 176 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
drivers/net/ethernet/amd/amd8111e.c
View File

@ -101,7 +101,6 @@ Revision History:
MODULE_AUTHOR("Advanced Micro Devices, Inc."); MODULE_AUTHOR("Advanced Micro Devices, Inc.");
MODULE_DESCRIPTION ("AMD8111 based 10/100 Ethernet Controller. Driver Version "MODULE_VERS); MODULE_DESCRIPTION ("AMD8111 based 10/100 Ethernet Controller. Driver Version "MODULE_VERS);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, amd8111e_pci_tbl);
module_param_array(speed_duplex, int, NULL, 0); module_param_array(speed_duplex, int, NULL, 0);
MODULE_PARM_DESC(speed_duplex, "Set device speed and duplex modes, 0: Auto Negotiate, 1: 10Mbps Half Duplex, 2: 10Mbps Full Duplex, 3: 100Mbps Half Duplex, 4: 100Mbps Full Duplex"); MODULE_PARM_DESC(speed_duplex, "Set device speed and duplex modes, 0: Auto Negotiate, 1: 10Mbps Half Duplex, 2: 10Mbps Full Duplex, 3: 100Mbps Half Duplex, 4: 100Mbps Full Duplex");
module_param_array(coalesce, bool, NULL, 0); module_param_array(coalesce, bool, NULL, 0);
@ -109,17 +108,9 @@ MODULE_PARM_DESC(coalesce, "Enable or Disable interrupt coalescing, 1: Enable, 0
module_param_array(dynamic_ipg, bool, NULL, 0); module_param_array(dynamic_ipg, bool, NULL, 0);
MODULE_PARM_DESC(dynamic_ipg, "Enable or Disable dynamic IPG, 1: Enable, 0: Disable"); MODULE_PARM_DESC(dynamic_ipg, "Enable or Disable dynamic IPG, 1: Enable, 0: Disable");
static DEFINE_PCI_DEVICE_TABLE(amd8111e_pci_tbl) = { /* This function will read the PHY registers. */
static int amd8111e_read_phy(struct amd8111e_priv *lp,
{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD8111E_7462, int phy_id, int reg, u32 *val)
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
{ 0, }
};
/*
This function will read the PHY registers.
*/
static int amd8111e_read_phy(struct amd8111e_priv* lp, int phy_id, int reg, u32* val)
{ {
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
unsigned int reg_val; unsigned int reg_val;
@ -146,10 +137,9 @@ err_phy_read:
} }
/* /* This function will write into PHY registers. */
This function will write into PHY registers. static int amd8111e_write_phy(struct amd8111e_priv *lp,
*/ int phy_id, int reg, u32 val)
static int amd8111e_write_phy(struct amd8111e_priv* lp,int phy_id, int reg, u32 val)
{ {
unsigned int repeat = REPEAT_CNT; unsigned int repeat = REPEAT_CNT;
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
@ -176,12 +166,11 @@ err_phy_write:
return -EINVAL; return -EINVAL;
} }
/*
This is the mii register read function provided to the mii interface. /* This is the mii register read function provided to the mii interface. */
*/ static int amd8111e_mdio_read(struct net_device *dev, int phy_id, int reg_num)
static int amd8111e_mdio_read(struct net_device * dev, int phy_id, int reg_num)
{ {
struct amd8111e_priv* lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
unsigned int reg_val; unsigned int reg_val;
amd8111e_read_phy(lp,phy_id,reg_num,&reg_val); amd8111e_read_phy(lp,phy_id,reg_num,&reg_val);
@ -189,19 +178,18 @@ static int amd8111e_mdio_read(struct net_device * dev, int phy_id, int reg_num)
} }
/* /* This is the mii register write function provided to the mii interface. */
This is the mii register write function provided to the mii interface. static void amd8111e_mdio_write(struct net_device *dev,
*/ int phy_id, int reg_num, int val)
static void amd8111e_mdio_write(struct net_device * dev, int phy_id, int reg_num, int val)
{ {
struct amd8111e_priv* lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
amd8111e_write_phy(lp, phy_id, reg_num, val); amd8111e_write_phy(lp, phy_id, reg_num, val);
} }
/* /* This function will set PHY speed. During initialization sets
This function will set PHY speed. During initialization sets the original speed to 100 full. * the original speed to 100 full
*/ */
static void amd8111e_set_ext_phy(struct net_device *dev) static void amd8111e_set_ext_phy(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
@ -240,14 +228,13 @@ static void amd8111e_set_ext_phy(struct net_device *dev)
} }
/* /* This function will unmap skb->data space and will free
This function will unmap skb->data space and will free * all transmit and receive skbuffs.
all transmit and receive skbuffs. */
*/
static int amd8111e_free_skbs(struct net_device *dev) static int amd8111e_free_skbs(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
struct sk_buff* rx_skbuff; struct sk_buff *rx_skbuff;
int i; int i;
/* Freeing transmit skbs */ /* Freeing transmit skbs */
@ -274,18 +261,18 @@ static int amd8111e_free_skbs(struct net_device *dev)
return 0; return 0;
} }
/* /* This will set the receive buffer length corresponding
This will set the receive buffer length corresponding to the mtu size of networkinterface. * to the mtu size of networkinterface.
*/ */
static inline void amd8111e_set_rx_buff_len(struct net_device* dev) static inline void amd8111e_set_rx_buff_len(struct net_device *dev)
{ {
struct amd8111e_priv* lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
unsigned int mtu = dev->mtu; unsigned int mtu = dev->mtu;
if (mtu > ETH_DATA_LEN){ if (mtu > ETH_DATA_LEN){
/* MTU + ethernet header + FCS /* MTU + ethernet header + FCS
+ optional VLAN tag + skb reserve space 2 */ * + optional VLAN tag + skb reserve space 2
*/
lp->rx_buff_len = mtu + ETH_HLEN + 10; lp->rx_buff_len = mtu + ETH_HLEN + 10;
lp->options |= OPTION_JUMBO_ENABLE; lp->options |= OPTION_JUMBO_ENABLE;
} else{ } else{
@ -294,8 +281,10 @@ static inline void amd8111e_set_rx_buff_len(struct net_device* dev)
} }
} }
/* /* This function will free all the previously allocated buffers,
This function will free all the previously allocated buffers, determine new receive buffer length and will allocate new receive buffers. This function also allocates and initializes both the transmitter and receive hardware descriptors. * determine new receive buffer length and will allocate new receive buffers.
* This function also allocates and initializes both the transmitter
* and receive hardware descriptors.
*/ */
static int amd8111e_init_ring(struct net_device *dev) static int amd8111e_init_ring(struct net_device *dev)
{ {
@ -376,15 +365,18 @@ err_free_tx_ring:
err_no_mem: err_no_mem:
return -ENOMEM; return -ENOMEM;
} }
/* This function will set the interrupt coalescing according to the input arguments */
static int amd8111e_set_coalesce(struct net_device * dev, enum coal_mode cmod) /* This function will set the interrupt coalescing according
* to the input arguments
*/
static int amd8111e_set_coalesce(struct net_device *dev, enum coal_mode cmod)
{ {
unsigned int timeout; unsigned int timeout;
unsigned int event_count; unsigned int event_count;
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
struct amd8111e_coalesce_conf * coal_conf = &lp->coal_conf; struct amd8111e_coalesce_conf *coal_conf = &lp->coal_conf;
switch(cmod) switch(cmod)
@ -435,9 +427,7 @@ static int amd8111e_set_coalesce(struct net_device * dev, enum coal_mode cmod)
} }
/* /* This function initializes the device registers and starts the device. */
This function initializes the device registers and starts the device.
*/
static int amd8111e_restart(struct net_device *dev) static int amd8111e_restart(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
@ -501,8 +491,7 @@ static int amd8111e_restart(struct net_device *dev)
/* Enable interrupt coalesce */ /* Enable interrupt coalesce */
if(lp->options & OPTION_INTR_COAL_ENABLE){ if(lp->options & OPTION_INTR_COAL_ENABLE){
printk(KERN_INFO "%s: Interrupt Coalescing Enabled.\n", netdev_info(dev, "Interrupt Coalescing Enabled.\n");
dev->name);
amd8111e_set_coalesce(dev,ENABLE_COAL); amd8111e_set_coalesce(dev,ENABLE_COAL);
} }
@ -514,10 +503,9 @@ static int amd8111e_restart(struct net_device *dev)
readl(mmio+CMD0); readl(mmio+CMD0);
return 0; return 0;
} }
/*
This function clears necessary the device registers. /* This function clears necessary the device registers. */
*/ static void amd8111e_init_hw_default(struct amd8111e_priv *lp)
static void amd8111e_init_hw_default( struct amd8111e_priv* lp)
{ {
unsigned int reg_val; unsigned int reg_val;
unsigned int logic_filter[2] ={0,}; unsigned int logic_filter[2] ={0,};
@ -587,7 +575,7 @@ static void amd8111e_init_hw_default( struct amd8111e_priv* lp)
writew(MIB_CLEAR, mmio + MIB_ADDR); writew(MIB_CLEAR, mmio + MIB_ADDR);
/* Clear LARF */ /* Clear LARF */
amd8111e_writeq(*(u64*)logic_filter,mmio+LADRF); amd8111e_writeq(*(u64 *)logic_filter, mmio + LADRF);
/* SRAM_SIZE register */ /* SRAM_SIZE register */
reg_val = readl(mmio + SRAM_SIZE); reg_val = readl(mmio + SRAM_SIZE);
@ -605,11 +593,10 @@ static void amd8111e_init_hw_default( struct amd8111e_priv* lp)
} }
/* /* This function disables the interrupt and clears all the pending
This function disables the interrupt and clears all the pending * interrupts in INT0
interrupts in INT0
*/ */
static void amd8111e_disable_interrupt(struct amd8111e_priv* lp) static void amd8111e_disable_interrupt(struct amd8111e_priv *lp)
{ {
u32 intr0; u32 intr0;
@ -625,10 +612,8 @@ static void amd8111e_disable_interrupt(struct amd8111e_priv* lp)
} }
/* /* This function stops the chip. */
This function stops the chip. static void amd8111e_stop_chip(struct amd8111e_priv *lp)
*/
static void amd8111e_stop_chip(struct amd8111e_priv* lp)
{ {
writel(RUN, lp->mmio + CMD0); writel(RUN, lp->mmio + CMD0);
@ -636,10 +621,8 @@ static void amd8111e_stop_chip(struct amd8111e_priv* lp)
readl(lp->mmio + CMD0); readl(lp->mmio + CMD0);
} }
/* /* This function frees the transmiter and receiver descriptor rings. */
This function frees the transmiter and receiver descriptor rings. static void amd8111e_free_ring(struct amd8111e_priv *lp)
*/
static void amd8111e_free_ring(struct amd8111e_priv* lp)
{ {
/* Free transmit and receive descriptor rings */ /* Free transmit and receive descriptor rings */
if(lp->rx_ring){ if(lp->rx_ring){
@ -659,12 +642,13 @@ static void amd8111e_free_ring(struct amd8111e_priv* lp)
} }
/* /* This function will free all the transmit skbs that are actually
This function will free all the transmit skbs that are actually transmitted by the device. It will check the ownership of the skb before freeing the skb. * transmitted by the device. It will check the ownership of the
*/ * skb before freeing the skb.
*/
static int amd8111e_tx(struct net_device *dev) static int amd8111e_tx(struct net_device *dev)
{ {
struct amd8111e_priv* lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
int tx_index = lp->tx_complete_idx & TX_RING_DR_MOD_MASK; int tx_index = lp->tx_complete_idx & TX_RING_DR_MOD_MASK;
int status; int status;
/* Complete all the transmit packet */ /* Complete all the transmit packet */
@ -724,21 +708,20 @@ static int amd8111e_rx_poll(struct napi_struct *napi, int budget)
goto rx_not_empty; goto rx_not_empty;
do{ do{
/* process receive packets until we use the quota*/ /* process receive packets until we use the quota.
/* If we own the next entry, it's a new packet. Send it up. */ * If we own the next entry, it's a new packet. Send it up.
*/
while(1) { while(1) {
status = le16_to_cpu(lp->rx_ring[rx_index].rx_flags); status = le16_to_cpu(lp->rx_ring[rx_index].rx_flags);
if (status & OWN_BIT) if (status & OWN_BIT)
break; break;
/* /* There is a tricky error noted by John Murphy,
* There is a tricky error noted by John Murphy,
* <murf@perftech.com> to Russ Nelson: Even with * <murf@perftech.com> to Russ Nelson: Even with
* full-sized * buffers it's possible for a * full-sized * buffers it's possible for a
* jabber packet to use two buffers, with only * jabber packet to use two buffers, with only
* the last correctly noting the error. * the last correctly noting the error.
*/ */
if(status & ERR_BIT) { if(status & ERR_BIT) {
/* reseting flags */ /* reseting flags */
lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS; lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
@ -771,7 +754,8 @@ static int amd8111e_rx_poll(struct napi_struct *napi, int budget)
new_skb = netdev_alloc_skb(dev, lp->rx_buff_len); new_skb = netdev_alloc_skb(dev, lp->rx_buff_len);
if (!new_skb) { if (!new_skb) {
/* if allocation fail, /* if allocation fail,
ignore that pkt and go to next one */ * ignore that pkt and go to next one
*/
lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS; lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
lp->drv_rx_errors++; lp->drv_rx_errors++;
goto err_next_pkt; goto err_next_pkt;
@ -812,8 +796,8 @@ static int amd8111e_rx_poll(struct napi_struct *napi, int budget)
rx_index = (++lp->rx_idx) & RX_RING_DR_MOD_MASK; rx_index = (++lp->rx_idx) & RX_RING_DR_MOD_MASK;
} }
/* Check the interrupt status register for more packets in the /* Check the interrupt status register for more packets in the
mean time. Process them since we have not used up our quota.*/ * mean time. Process them since we have not used up our quota.
*/
intr0 = readl(mmio + INT0); intr0 = readl(mmio + INT0);
/*Ack receive packets */ /*Ack receive packets */
writel(intr0 & RINT0,mmio + INT0); writel(intr0 & RINT0,mmio + INT0);
@ -833,10 +817,8 @@ rx_not_empty:
return num_rx_pkt; return num_rx_pkt;
} }
/* /* This function will indicate the link status to the kernel. */
This function will indicate the link status to the kernel. static int amd8111e_link_change(struct net_device *dev)
*/
static int amd8111e_link_change(struct net_device* dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
int status0,speed; int status0,speed;
@ -860,24 +842,26 @@ static int amd8111e_link_change(struct net_device* dev)
else if(speed == PHY_SPEED_100) else if(speed == PHY_SPEED_100)
lp->link_config.speed = SPEED_100; lp->link_config.speed = SPEED_100;
printk(KERN_INFO "%s: Link is Up. Speed is %s Mbps %s Duplex\n", dev->name, netdev_info(dev, "Link is Up. Speed is %s Mbps %s Duplex\n",
(lp->link_config.speed == SPEED_100) ? "100": "10", (lp->link_config.speed == SPEED_100) ?
(lp->link_config.duplex == DUPLEX_FULL)? "Full": "Half"); "100" : "10",
(lp->link_config.duplex == DUPLEX_FULL) ?
"Full" : "Half");
netif_carrier_on(dev); netif_carrier_on(dev);
} }
else{ else{
lp->link_config.speed = SPEED_INVALID; lp->link_config.speed = SPEED_INVALID;
lp->link_config.duplex = DUPLEX_INVALID; lp->link_config.duplex = DUPLEX_INVALID;
lp->link_config.autoneg = AUTONEG_INVALID; lp->link_config.autoneg = AUTONEG_INVALID;
printk(KERN_INFO "%s: Link is Down.\n",dev->name); netdev_info(dev, "Link is Down.\n");
netif_carrier_off(dev); netif_carrier_off(dev);
} }
return 0; return 0;
} }
/*
This function reads the mib counters. /* This function reads the mib counters. */
*/
static int amd8111e_read_mib(void __iomem *mmio, u8 MIB_COUNTER) static int amd8111e_read_mib(void __iomem *mmio, u8 MIB_COUNTER)
{ {
unsigned int status; unsigned int status;
@ -895,8 +879,7 @@ static int amd8111e_read_mib(void __iomem *mmio, u8 MIB_COUNTER)
return data; return data;
} }
/* /* This function reads the mib registers and returns the hardware statistics.
* This function reads the mib registers and returns the hardware statistics.
* It updates previous internal driver statistics with new values. * It updates previous internal driver statistics with new values.
*/ */
static struct net_device_stats *amd8111e_get_stats(struct net_device *dev) static struct net_device_stats *amd8111e_get_stats(struct net_device *dev)
@ -992,13 +975,14 @@ static struct net_device_stats *amd8111e_get_stats(struct net_device *dev)
return new_stats; return new_stats;
} }
/* This function recalculate the interrupt coalescing mode on every interrupt /* This function recalculate the interrupt coalescing mode on every interrupt
according to the datarate and the packet rate. * according to the datarate and the packet rate.
*/ */
static int amd8111e_calc_coalesce(struct net_device *dev) static int amd8111e_calc_coalesce(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
struct amd8111e_coalesce_conf * coal_conf = &lp->coal_conf; struct amd8111e_coalesce_conf *coal_conf = &lp->coal_conf;
int tx_pkt_rate; int tx_pkt_rate;
int rx_pkt_rate; int rx_pkt_rate;
int tx_data_rate; int tx_data_rate;
@ -1126,13 +1110,14 @@ static int amd8111e_calc_coalesce(struct net_device *dev)
return 0; return 0;
} }
/*
This is device interrupt function. It handles transmit, receive,link change and hardware timer interrupts. /* This is device interrupt function. It handles transmit,
*/ * receive,link change and hardware timer interrupts.
*/
static irqreturn_t amd8111e_interrupt(int irq, void *dev_id) static irqreturn_t amd8111e_interrupt(int irq, void *dev_id)
{ {
struct net_device * dev = (struct net_device *) dev_id; struct net_device *dev = (struct net_device *)dev_id;
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
unsigned int intr0, intren0; unsigned int intr0, intren0;
@ -1168,7 +1153,7 @@ static irqreturn_t amd8111e_interrupt(int irq, void *dev_id)
/* Schedule a polling routine */ /* Schedule a polling routine */
__napi_schedule(&lp->napi); __napi_schedule(&lp->napi);
} else if (intren0 & RINTEN0) { } else if (intren0 & RINTEN0) {
printk("************Driver bug! interrupt while in poll\n"); netdev_dbg(dev, "************Driver bug! interrupt while in poll\n");
/* Fix by disable receive interrupts */ /* Fix by disable receive interrupts */
writel(RINTEN0, mmio + INTEN0); writel(RINTEN0, mmio + INTEN0);
} }
@ -1205,10 +1190,11 @@ static void amd8111e_poll(struct net_device *dev)
#endif #endif
/* /* This function closes the network interface and updates
This function closes the network interface and updates the statistics so that most recent statistics will be available after the interface is down. * the statistics so that most recent statistics will be
*/ * available after the interface is down.
static int amd8111e_close(struct net_device * dev) */
static int amd8111e_close(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
netif_stop_queue(dev); netif_stop_queue(dev);
@ -1238,9 +1224,11 @@ static int amd8111e_close(struct net_device * dev)
lp->opened = 0; lp->opened = 0;
return 0; return 0;
} }
/* This function opens new interface.It requests irq for the device, initializes the device,buffers and descriptors, and starts the device.
*/ /* This function opens new interface.It requests irq for the device,
static int amd8111e_open(struct net_device * dev ) * initializes the device,buffers and descriptors, and starts the device.
*/
static int amd8111e_open(struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
@ -1264,7 +1252,7 @@ static int amd8111e_open(struct net_device * dev )
/* Start ipg timer */ /* Start ipg timer */
if(lp->options & OPTION_DYN_IPG_ENABLE){ if(lp->options & OPTION_DYN_IPG_ENABLE){
add_timer(&lp->ipg_data.ipg_timer); add_timer(&lp->ipg_data.ipg_timer);
printk(KERN_INFO "%s: Dynamic IPG Enabled.\n",dev->name); netdev_info(dev, "Dynamic IPG Enabled\n");
} }
lp->opened = 1; lp->opened = 1;
@ -1275,10 +1263,11 @@ static int amd8111e_open(struct net_device * dev )
return 0; return 0;
} }
/*
This function checks if there is any transmit descriptors available to queue more packet. /* This function checks if there is any transmit descriptors
*/ * available to queue more packet.
static int amd8111e_tx_queue_avail(struct amd8111e_priv* lp ) */
static int amd8111e_tx_queue_avail(struct amd8111e_priv *lp)
{ {
int tx_index = lp->tx_idx & TX_BUFF_MOD_MASK; int tx_index = lp->tx_idx & TX_BUFF_MOD_MASK;
if (lp->tx_skbuff[tx_index]) if (lp->tx_skbuff[tx_index])
@ -1287,12 +1276,14 @@ static int amd8111e_tx_queue_avail(struct amd8111e_priv* lp )
return 0; return 0;
} }
/*
This function will queue the transmit packets to the descriptors and will trigger the send operation. It also initializes the transmit descriptors with buffer physical address, byte count, ownership to hardware etc.
*/
/* This function will queue the transmit packets to the
* descriptors and will trigger the send operation. It also
* initializes the transmit descriptors with buffer physical address,
* byte count, ownership to hardware etc.
*/
static netdev_tx_t amd8111e_start_xmit(struct sk_buff *skb, static netdev_tx_t amd8111e_start_xmit(struct sk_buff *skb,
struct net_device * dev) struct net_device *dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
int tx_index; int tx_index;
@ -1338,9 +1329,7 @@ static netdev_tx_t amd8111e_start_xmit(struct sk_buff *skb,
spin_unlock_irqrestore(&lp->lock, flags); spin_unlock_irqrestore(&lp->lock, flags);
return NETDEV_TX_OK; return NETDEV_TX_OK;
} }
/* /* This function returns all the memory mapped registers of the device. */
This function returns all the memory mapped registers of the device.
*/
static void amd8111e_read_regs(struct amd8111e_priv *lp, u32 *buf) static void amd8111e_read_regs(struct amd8111e_priv *lp, u32 *buf)
{ {
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
@ -1361,10 +1350,9 @@ static void amd8111e_read_regs(struct amd8111e_priv *lp, u32 *buf)
} }
/* /* This function sets promiscuos mode, all-multi mode or the multicast address
This function sets promiscuos mode, all-multi mode or the multicast address * list to the device.
list to the device. */
*/
static void amd8111e_set_multicast_list(struct net_device *dev) static void amd8111e_set_multicast_list(struct net_device *dev)
{ {
struct netdev_hw_addr *ha; struct netdev_hw_addr *ha;
@ -1383,14 +1371,14 @@ static void amd8111e_set_multicast_list(struct net_device *dev)
/* get all multicast packet */ /* get all multicast packet */
mc_filter[1] = mc_filter[0] = 0xffffffff; mc_filter[1] = mc_filter[0] = 0xffffffff;
lp->options |= OPTION_MULTICAST_ENABLE; lp->options |= OPTION_MULTICAST_ENABLE;
amd8111e_writeq(*(u64*)mc_filter,lp->mmio + LADRF); amd8111e_writeq(*(u64 *)mc_filter, lp->mmio + LADRF);
return; return;
} }
if (netdev_mc_empty(dev)) { if (netdev_mc_empty(dev)) {
/* get only own packets */ /* get only own packets */
mc_filter[1] = mc_filter[0] = 0; mc_filter[1] = mc_filter[0] = 0;
lp->options &= ~OPTION_MULTICAST_ENABLE; lp->options &= ~OPTION_MULTICAST_ENABLE;
amd8111e_writeq(*(u64*)mc_filter,lp->mmio + LADRF); amd8111e_writeq(*(u64 *)mc_filter, lp->mmio + LADRF);
/* disable promiscuous mode */ /* disable promiscuous mode */
writel(PROM, lp->mmio + CMD2); writel(PROM, lp->mmio + CMD2);
return; return;
@ -1402,14 +1390,15 @@ static void amd8111e_set_multicast_list(struct net_device *dev)
bit_num = (ether_crc_le(ETH_ALEN, ha->addr) >> 26) & 0x3f; bit_num = (ether_crc_le(ETH_ALEN, ha->addr) >> 26) & 0x3f;
mc_filter[bit_num >> 5] |= 1 << (bit_num & 31); mc_filter[bit_num >> 5] |= 1 << (bit_num & 31);
} }
amd8111e_writeq(*(u64*)mc_filter,lp->mmio+ LADRF); amd8111e_writeq(*(u64 *)mc_filter, lp->mmio + LADRF);
/* To eliminate PCI posting bug */ /* To eliminate PCI posting bug */
readl(lp->mmio + CMD2); readl(lp->mmio + CMD2);
} }
static void amd8111e_get_drvinfo(struct net_device* dev, struct ethtool_drvinfo *info) static void amd8111e_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
struct pci_dev *pci_dev = lp->pci_dev; struct pci_dev *pci_dev = lp->pci_dev;
@ -1501,11 +1490,11 @@ static const struct ethtool_ops ops = {
.set_wol = amd8111e_set_wol, .set_wol = amd8111e_set_wol,
}; };
/* /* This function handles all the ethtool ioctls. It gives driver info,
This function handles all the ethtool ioctls. It gives driver info, gets/sets driver speed, gets memory mapped register values, forces auto negotiation, sets/gets WOL options for ethtool application. * gets/sets driver speed, gets memory mapped register values, forces
*/ * auto negotiation, sets/gets WOL options for ethtool application.
*/
static int amd8111e_ioctl(struct net_device * dev , struct ifreq *ifr, int cmd) static int amd8111e_ioctl(struct net_device *dev , struct ifreq *ifr, int cmd)
{ {
struct mii_ioctl_data *data = if_mii(ifr); struct mii_ioctl_data *data = if_mii(ifr);
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
@ -1559,9 +1548,9 @@ static int amd8111e_set_mac_address(struct net_device *dev, void *p)
return 0; return 0;
} }
/* /* This function changes the mtu of the device. It restarts the device to
This function changes the mtu of the device. It restarts the device to initialize the descriptor with new receive buffers. * initialize the descriptor with new receive buffers.
*/ */
static int amd8111e_change_mtu(struct net_device *dev, int new_mtu) static int amd8111e_change_mtu(struct net_device *dev, int new_mtu)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
@ -1572,7 +1561,8 @@ static int amd8111e_change_mtu(struct net_device *dev, int new_mtu)
if (!netif_running(dev)) { if (!netif_running(dev)) {
/* new_mtu will be used /* new_mtu will be used
when device starts netxt time */ * when device starts netxt time
*/
dev->mtu = new_mtu; dev->mtu = new_mtu;
return 0; return 0;
} }
@ -1591,7 +1581,7 @@ static int amd8111e_change_mtu(struct net_device *dev, int new_mtu)
return err; return err;
} }
static int amd8111e_enable_magicpkt(struct amd8111e_priv* lp) static int amd8111e_enable_magicpkt(struct amd8111e_priv *lp)
{ {
writel( VAL1|MPPLBA, lp->mmio + CMD3); writel( VAL1|MPPLBA, lp->mmio + CMD3);
writel( VAL0|MPEN_SW, lp->mmio + CMD7); writel( VAL0|MPEN_SW, lp->mmio + CMD7);
@ -1601,7 +1591,7 @@ static int amd8111e_enable_magicpkt(struct amd8111e_priv* lp)
return 0; return 0;
} }
static int amd8111e_enable_link_change(struct amd8111e_priv* lp) static int amd8111e_enable_link_change(struct amd8111e_priv *lp)
{ {
/* Adapter is already stoped/suspended/interrupt-disabled */ /* Adapter is already stoped/suspended/interrupt-disabled */
@ -1612,19 +1602,18 @@ static int amd8111e_enable_link_change(struct amd8111e_priv* lp)
return 0; return 0;
} }
/* /* This function is called when a packet transmission fails to complete
* This function is called when a packet transmission fails to complete
* within a reasonable period, on the assumption that an interrupt have * within a reasonable period, on the assumption that an interrupt have
* failed or the interface is locked up. This function will reinitialize * failed or the interface is locked up. This function will reinitialize
* the hardware. * the hardware.
*/ */
static void amd8111e_tx_timeout(struct net_device *dev) static void amd8111e_tx_timeout(struct net_device *dev)
{ {
struct amd8111e_priv* lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
int err; int err;
printk(KERN_ERR "%s: transmit timed out, resetting\n", netdev_err(dev, "transmit timed out, resetting\n");
dev->name);
spin_lock_irq(&lp->lock); spin_lock_irq(&lp->lock);
err = amd8111e_restart(dev); err = amd8111e_restart(dev);
spin_unlock_irq(&lp->lock); spin_unlock_irq(&lp->lock);
@ -1701,22 +1690,10 @@ static int amd8111e_resume(struct pci_dev *pci_dev)
return 0; return 0;
} }
static void amd8111e_config_ipg(struct net_device *dev)
static void amd8111e_remove_one(struct pci_dev *pdev)
{
struct net_device *dev = pci_get_drvdata(pdev);
if (dev) {
unregister_netdev(dev);
iounmap(((struct amd8111e_priv *)netdev_priv(dev))->mmio);
free_netdev(dev);
pci_release_regions(pdev);
pci_disable_device(pdev);
}
}
static void amd8111e_config_ipg(struct net_device* dev)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = netdev_priv(dev);
struct ipg_info* ipg_data = &lp->ipg_data; struct ipg_info *ipg_data = &lp->ipg_data;
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
unsigned int prev_col_cnt = ipg_data->col_cnt; unsigned int prev_col_cnt = ipg_data->col_cnt;
unsigned int total_col_cnt; unsigned int total_col_cnt;
@ -1814,27 +1791,24 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
{ {
int err, i; int err, i;
unsigned long reg_addr,reg_len; unsigned long reg_addr,reg_len;
struct amd8111e_priv* lp; struct amd8111e_priv *lp;
struct net_device* dev; struct net_device *dev;
err = pci_enable_device(pdev); err = pci_enable_device(pdev);
if(err){ if(err){
printk(KERN_ERR "amd8111e: Cannot enable new PCI device, " dev_err(&pdev->dev, "Cannot enable new PCI device\n");
"exiting.\n");
return err; return err;
} }
if(!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)){ if(!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)){
printk(KERN_ERR "amd8111e: Cannot find PCI base address, " dev_err(&pdev->dev, "Cannot find PCI base address\n");
"exiting.\n");
err = -ENODEV; err = -ENODEV;
goto err_disable_pdev; goto err_disable_pdev;
} }
err = pci_request_regions(pdev, MODULE_NAME); err = pci_request_regions(pdev, MODULE_NAME);
if(err){ if(err){
printk(KERN_ERR "amd8111e: Cannot obtain PCI resources, " dev_err(&pdev->dev, "Cannot obtain PCI resources\n");
"exiting.\n");
goto err_disable_pdev; goto err_disable_pdev;
} }
@ -1842,16 +1816,14 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
/* Find power-management capability. */ /* Find power-management capability. */
if (!pdev->pm_cap) { if (!pdev->pm_cap) {
printk(KERN_ERR "amd8111e: No Power Management capability, " dev_err(&pdev->dev, "No Power Management capability\n");
"exiting.\n");
err = -ENODEV; err = -ENODEV;
goto err_free_reg; goto err_free_reg;
} }
/* Initialize DMA */ /* Initialize DMA */
if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) < 0) { if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) < 0) {
printk(KERN_ERR "amd8111e: DMA not supported," dev_err(&pdev->dev, "DMA not supported\n");
"exiting.\n");
err = -ENODEV; err = -ENODEV;
goto err_free_reg; goto err_free_reg;
} }
@ -1878,10 +1850,9 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
spin_lock_init(&lp->lock); spin_lock_init(&lp->lock);
lp->mmio = ioremap(reg_addr, reg_len); lp->mmio = devm_ioremap(&pdev->dev, reg_addr, reg_len);
if (!lp->mmio) { if (!lp->mmio) {
printk(KERN_ERR "amd8111e: Cannot map device registers, " dev_err(&pdev->dev, "Cannot map device registers\n");
"exiting\n");
err = -ENOMEM; err = -ENOMEM;
goto err_free_dev; goto err_free_dev;
} }
@ -1923,9 +1894,8 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
err = register_netdev(dev); err = register_netdev(dev);
if (err) { if (err) {
printk(KERN_ERR "amd8111e: Cannot register net device, " dev_err(&pdev->dev, "Cannot register net device\n");
"exiting.\n"); goto err_free_dev;
goto err_iounmap;
} }
pci_set_drvdata(pdev, dev); pci_set_drvdata(pdev, dev);
@ -1942,21 +1912,17 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
} }
/* display driver and device information */ /* display driver and device information */
chip_version = (readl(lp->mmio + CHIPID) & 0xf0000000)>>28; chip_version = (readl(lp->mmio + CHIPID) & 0xf0000000)>>28;
printk(KERN_INFO "%s: AMD-8111e Driver Version: %s\n", dev_info(&pdev->dev, "AMD-8111e Driver Version: %s\n", MODULE_VERS);
dev->name,MODULE_VERS); dev_info(&pdev->dev, "[ Rev %x ] PCI 10/100BaseT Ethernet %pM\n",
printk(KERN_INFO "%s: [ Rev %x ] PCI 10/100BaseT Ethernet %pM\n", chip_version, dev->dev_addr);
dev->name, chip_version, dev->dev_addr);
if (lp->ext_phy_id) if (lp->ext_phy_id)
printk(KERN_INFO "%s: Found MII PHY ID 0x%08x at address 0x%02x\n", dev_info(&pdev->dev, "Found MII PHY ID 0x%08x at address 0x%02x\n",
dev->name, lp->ext_phy_id, lp->ext_phy_addr); lp->ext_phy_id, lp->ext_phy_addr);
else else
printk(KERN_INFO "%s: Couldn't detect MII PHY, assuming address 0x01\n", dev_info(&pdev->dev, "Couldn't detect MII PHY, assuming address 0x01\n");
dev->name);
return 0; return 0;
err_iounmap:
iounmap(lp->mmio);
err_free_dev: err_free_dev:
free_netdev(dev); free_netdev(dev);
@ -1970,6 +1936,29 @@ err_disable_pdev:
} }
static void amd8111e_remove_one(struct pci_dev *pdev)
{
struct net_device *dev = pci_get_drvdata(pdev);
if (dev) {
unregister_netdev(dev);
free_netdev(dev);
pci_release_regions(pdev);
pci_disable_device(pdev);
}
}
static const struct pci_device_id amd8111e_pci_tbl[] = {
{
.vendor = PCI_VENDOR_ID_AMD,
.device = PCI_DEVICE_ID_AMD8111E_7462,
},
{
.vendor = 0,
}
};
MODULE_DEVICE_TABLE(pci, amd8111e_pci_tbl);
static struct pci_driver amd8111e_driver = { static struct pci_driver amd8111e_driver = {
.name = MODULE_NAME, .name = MODULE_NAME,
.id_table = amd8111e_pci_tbl, .id_table = amd8111e_pci_tbl,