blob: 2061b471fd161b92cd9c4161fa15b955b63a28e2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002/* Advanced Micro Devices Inc. AMD8111E Linux Network Driver
3 * Copyright (C) 2004 Advanced Micro Devices
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright 2001,2002 Jeff Garzik <jgarzik@mandrakesoft.com> [ 8139cp.c,tg3.c ]
7 * Copyright (C) 2001, 2002 David S. Miller (davem@redhat.com)[ tg3.c]
8 * Copyright 1996-1999 Thomas Bogendoerfer [ pcnet32.c ]
9 * Derived from the lance driver written 1993,1994,1995 by Donald Becker.
10 * Copyright 1993 United States Government as represented by the
11 * Director, National Security Agency.[ pcnet32.c ]
12 * Carsten Langgaard, carstenl@mips.com [ pcnet32.c ]
13 * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved.
14 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -040015 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
Jeff Kirsher0ab75ae2013-12-06 06:28:43 -080027 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029Module Name:
30
31 amd8111e.c
32
33Abstract:
Jeff Garzik6aa20a22006-09-13 13:24:59 -040034
35 AMD8111 based 10/100 Ethernet Controller Driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37Environment:
38
39 Kernel Mode
40
41Revision History:
42 3.0.0
43 Initial Revision.
44 3.0.1
45 1. Dynamic interrupt coalescing.
46 2. Removed prev_stats.
47 3. MII support.
48 4. Dynamic IPG support
49 3.0.2 05/29/2003
50 1. Bug fix: Fixed failure to send jumbo packets larger than 4k.
51 2. Bug fix: Fixed VLAN support failure.
52 3. Bug fix: Fixed receive interrupt coalescing bug.
53 4. Dynamic IPG support is disabled by default.
54 3.0.3 06/05/2003
55 1. Bug fix: Fixed failure to close the interface if SMP is enabled.
56 3.0.4 12/09/2003
57 1. Added set_mac_address routine for bonding driver support.
58 2. Tested the driver for bonding support
Jeff Garzik6aa20a22006-09-13 13:24:59 -040059 3. Bug fix: Fixed mismach in actual receive buffer lenth and lenth
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 indicated to the h/w.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040061 4. Modified amd8111e_rx() routine to receive all the received packets
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 in the first interrupt.
63 5. Bug fix: Corrected rx_errors reported in get_stats() function.
64 3.0.5 03/22/2004
Jeff Garzik6aa20a22006-09-13 13:24:59 -040065 1. Added NAPI support
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67*/
68
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <linux/module.h>
71#include <linux/kernel.h>
72#include <linux/types.h>
73#include <linux/compiler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <linux/delay.h>
Alexey Dobriyana6b7a402011-06-06 10:43:46 +000075#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070076#include <linux/ioport.h>
77#include <linux/pci.h>
78#include <linux/netdevice.h>
79#include <linux/etherdevice.h>
80#include <linux/skbuff.h>
81#include <linux/ethtool.h>
82#include <linux/mii.h>
83#include <linux/if_vlan.h>
Jeff Garzik6aa20a22006-09-13 13:24:59 -040084#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#include <linux/crc32.h>
Tobias Klausercac8c812005-05-16 19:15:11 +020086#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#include <asm/io.h>
89#include <asm/byteorder.h>
90#include <asm/uaccess.h>
91
92#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
93#define AMD8111E_VLAN_TAG_USED 1
94#else
95#define AMD8111E_VLAN_TAG_USED 0
96#endif
97
98#include "amd8111e.h"
99#define MODULE_NAME "amd8111e"
Francois Romieu6ba33ac2008-07-06 20:55:12 -0700100#define MODULE_VERS "3.0.7"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101MODULE_AUTHOR("Advanced Micro Devices, Inc.");
Francois Romieu6ba33ac2008-07-06 20:55:12 -0700102MODULE_DESCRIPTION ("AMD8111 based 10/100 Ethernet Controller. Driver Version "MODULE_VERS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103MODULE_LICENSE("GPL");
104MODULE_DEVICE_TABLE(pci, amd8111e_pci_tbl);
105module_param_array(speed_duplex, int, NULL, 0);
Joe Perches983960b2011-05-02 09:59:29 +0000106MODULE_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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107module_param_array(coalesce, bool, NULL, 0);
108MODULE_PARM_DESC(coalesce, "Enable or Disable interrupt coalescing, 1: Enable, 0: Disable");
109module_param_array(dynamic_ipg, bool, NULL, 0);
110MODULE_PARM_DESC(dynamic_ipg, "Enable or Disable dynamic IPG, 1: Enable, 0: Disable");
111
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000112static DEFINE_PCI_DEVICE_TABLE(amd8111e_pci_tbl) = {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD8111E_7462,
115 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
116 { 0, }
117
118};
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400119/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120This function will read the PHY registers.
121*/
122static int amd8111e_read_phy(struct amd8111e_priv* lp, int phy_id, int reg, u32* val)
123{
124 void __iomem *mmio = lp->mmio;
125 unsigned int reg_val;
126 unsigned int repeat= REPEAT_CNT;
127
128 reg_val = readl(mmio + PHY_ACCESS);
129 while (reg_val & PHY_CMD_ACTIVE)
130 reg_val = readl( mmio + PHY_ACCESS );
131
132 writel( PHY_RD_CMD | ((phy_id & 0x1f) << 21) |
133 ((reg & 0x1f) << 16), mmio +PHY_ACCESS);
134 do{
135 reg_val = readl(mmio + PHY_ACCESS);
136 udelay(30); /* It takes 30 us to read/write data */
137 } while (--repeat && (reg_val & PHY_CMD_ACTIVE));
138 if(reg_val & PHY_RD_ERR)
139 goto err_phy_read;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 *val = reg_val & 0xffff;
142 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400143err_phy_read:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 *val = 0;
145 return -EINVAL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400149/*
150This function will write into PHY registers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151*/
152static int amd8111e_write_phy(struct amd8111e_priv* lp,int phy_id, int reg, u32 val)
153{
Yoann Padioleau632155e2007-06-01 00:46:35 -0700154 unsigned int repeat = REPEAT_CNT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 void __iomem *mmio = lp->mmio;
156 unsigned int reg_val;
157
158 reg_val = readl(mmio + PHY_ACCESS);
159 while (reg_val & PHY_CMD_ACTIVE)
160 reg_val = readl( mmio + PHY_ACCESS );
161
162 writel( PHY_WR_CMD | ((phy_id & 0x1f) << 21) |
163 ((reg & 0x1f) << 16)|val, mmio + PHY_ACCESS);
164
165 do{
166 reg_val = readl(mmio + PHY_ACCESS);
167 udelay(30); /* It takes 30 us to read/write the data */
168 } while (--repeat && (reg_val & PHY_CMD_ACTIVE));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 if(reg_val & PHY_RD_ERR)
171 goto err_phy_write;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return 0;
174
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400175err_phy_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return -EINVAL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400179/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180This is the mii register read function provided to the mii interface.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400181*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182static int amd8111e_mdio_read(struct net_device * dev, int phy_id, int reg_num)
183{
184 struct amd8111e_priv* lp = netdev_priv(dev);
185 unsigned int reg_val;
186
187 amd8111e_read_phy(lp,phy_id,reg_num,&reg_val);
188 return reg_val;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190}
191
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400192/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193This is the mii register write function provided to the mii interface.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400194*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195static void amd8111e_mdio_write(struct net_device * dev, int phy_id, int reg_num, int val)
196{
197 struct amd8111e_priv* lp = netdev_priv(dev);
198
199 amd8111e_write_phy(lp, phy_id, reg_num, val);
200}
201
202/*
203This function will set PHY speed. During initialization sets the original speed to 100 full.
204*/
205static void amd8111e_set_ext_phy(struct net_device *dev)
206{
207 struct amd8111e_priv *lp = netdev_priv(dev);
208 u32 bmcr,advert,tmp;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 /* Determine mii register values to set the speed */
211 advert = amd8111e_mdio_read(dev, lp->ext_phy_addr, MII_ADVERTISE);
212 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
213 switch (lp->ext_phy_option){
214
215 default:
216 case SPEED_AUTONEG: /* advertise all values */
217 tmp |= ( ADVERTISE_10HALF|ADVERTISE_10FULL|
218 ADVERTISE_100HALF|ADVERTISE_100FULL) ;
219 break;
220 case SPEED10_HALF:
221 tmp |= ADVERTISE_10HALF;
222 break;
223 case SPEED10_FULL:
224 tmp |= ADVERTISE_10FULL;
225 break;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400226 case SPEED100_HALF:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 tmp |= ADVERTISE_100HALF;
228 break;
229 case SPEED100_FULL:
230 tmp |= ADVERTISE_100FULL;
231 break;
232 }
233
234 if(advert != tmp)
235 amd8111e_mdio_write(dev, lp->ext_phy_addr, MII_ADVERTISE, tmp);
236 /* Restart auto negotiation */
237 bmcr = amd8111e_mdio_read(dev, lp->ext_phy_addr, MII_BMCR);
238 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
239 amd8111e_mdio_write(dev, lp->ext_phy_addr, MII_BMCR, bmcr);
240
241}
242
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400243/*
244This function will unmap skb->data space and will free
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245all transmit and receive skbuffs.
246*/
247static int amd8111e_free_skbs(struct net_device *dev)
248{
249 struct amd8111e_priv *lp = netdev_priv(dev);
250 struct sk_buff* rx_skbuff;
251 int i;
252
253 /* Freeing transmit skbs */
254 for(i = 0; i < NUM_TX_BUFFERS; i++){
255 if(lp->tx_skbuff[i]){
256 pci_unmap_single(lp->pci_dev,lp->tx_dma_addr[i], lp->tx_skbuff[i]->len,PCI_DMA_TODEVICE);
257 dev_kfree_skb (lp->tx_skbuff[i]);
258 lp->tx_skbuff[i] = NULL;
259 lp->tx_dma_addr[i] = 0;
260 }
261 }
262 /* Freeing previously allocated receive buffers */
263 for (i = 0; i < NUM_RX_BUFFERS; i++){
264 rx_skbuff = lp->rx_skbuff[i];
265 if(rx_skbuff != NULL){
266 pci_unmap_single(lp->pci_dev,lp->rx_dma_addr[i],
267 lp->rx_buff_len - 2,PCI_DMA_FROMDEVICE);
268 dev_kfree_skb(lp->rx_skbuff[i]);
269 lp->rx_skbuff[i] = NULL;
270 lp->rx_dma_addr[i] = 0;
271 }
272 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return 0;
275}
276
277/*
278This will set the receive buffer length corresponding to the mtu size of networkinterface.
279*/
280static inline void amd8111e_set_rx_buff_len(struct net_device* dev)
281{
282 struct amd8111e_priv* lp = netdev_priv(dev);
283 unsigned int mtu = dev->mtu;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (mtu > ETH_DATA_LEN){
286 /* MTU + ethernet header + FCS
287 + optional VLAN tag + skb reserve space 2 */
288
289 lp->rx_buff_len = mtu + ETH_HLEN + 10;
290 lp->options |= OPTION_JUMBO_ENABLE;
291 } else{
292 lp->rx_buff_len = PKT_BUFF_SZ;
293 lp->options &= ~OPTION_JUMBO_ENABLE;
294 }
295}
296
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400297/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298This 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.
299 */
300static int amd8111e_init_ring(struct net_device *dev)
301{
302 struct amd8111e_priv *lp = netdev_priv(dev);
303 int i;
304
305 lp->rx_idx = lp->tx_idx = 0;
306 lp->tx_complete_idx = 0;
307 lp->tx_ring_idx = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
310 if(lp->opened)
311 /* Free previously allocated transmit and receive skbs */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400312 amd8111e_free_skbs(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314 else{
315 /* allocate the tx and rx descriptors */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400316 if((lp->tx_ring = pci_alloc_consistent(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 sizeof(struct amd8111e_tx_dr)*NUM_TX_RING_DR,
318 &lp->tx_ring_dma_addr)) == NULL)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 goto err_no_mem;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400321
322 if((lp->rx_ring = pci_alloc_consistent(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 sizeof(struct amd8111e_rx_dr)*NUM_RX_RING_DR,
324 &lp->rx_ring_dma_addr)) == NULL)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 goto err_free_tx_ring;
327
328 }
329 /* Set new receive buff size */
330 amd8111e_set_rx_buff_len(dev);
331
332 /* Allocating receive skbs */
333 for (i = 0; i < NUM_RX_BUFFERS; i++) {
334
Pradeep A Dalvi1d266432012-02-05 02:49:09 +0000335 lp->rx_skbuff[i] = netdev_alloc_skb(dev, lp->rx_buff_len);
336 if (!lp->rx_skbuff[i]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 /* Release previos allocated skbs */
338 for(--i; i >= 0 ;i--)
339 dev_kfree_skb(lp->rx_skbuff[i]);
340 goto err_free_rx_ring;
341 }
342 skb_reserve(lp->rx_skbuff[i],2);
343 }
344 /* Initilaizing receive descriptors */
345 for (i = 0; i < NUM_RX_BUFFERS; i++) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400346 lp->rx_dma_addr[i] = pci_map_single(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 lp->rx_skbuff[i]->data,lp->rx_buff_len-2, PCI_DMA_FROMDEVICE);
348
349 lp->rx_ring[i].buff_phy_addr = cpu_to_le32(lp->rx_dma_addr[i]);
350 lp->rx_ring[i].buff_count = cpu_to_le16(lp->rx_buff_len-2);
351 wmb();
352 lp->rx_ring[i].rx_flags = cpu_to_le16(OWN_BIT);
353 }
354
355 /* Initializing transmit descriptors */
356 for (i = 0; i < NUM_TX_RING_DR; i++) {
357 lp->tx_ring[i].buff_phy_addr = 0;
358 lp->tx_ring[i].tx_flags = 0;
359 lp->tx_ring[i].buff_count = 0;
360 }
361
362 return 0;
363
364err_free_rx_ring:
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400365
366 pci_free_consistent(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 sizeof(struct amd8111e_rx_dr)*NUM_RX_RING_DR,lp->rx_ring,
368 lp->rx_ring_dma_addr);
369
370err_free_tx_ring:
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 pci_free_consistent(lp->pci_dev,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400373 sizeof(struct amd8111e_tx_dr)*NUM_TX_RING_DR,lp->tx_ring,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 lp->tx_ring_dma_addr);
375
376err_no_mem:
377 return -ENOMEM;
378}
379/* This function will set the interrupt coalescing according to the input arguments */
380static int amd8111e_set_coalesce(struct net_device * dev, enum coal_mode cmod)
381{
382 unsigned int timeout;
383 unsigned int event_count;
384
385 struct amd8111e_priv *lp = netdev_priv(dev);
386 void __iomem *mmio = lp->mmio;
387 struct amd8111e_coalesce_conf * coal_conf = &lp->coal_conf;
388
389
390 switch(cmod)
391 {
392 case RX_INTR_COAL :
393 timeout = coal_conf->rx_timeout;
394 event_count = coal_conf->rx_event_count;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400395 if( timeout > MAX_TIMEOUT ||
396 event_count > MAX_EVENT_COUNT )
Julia Lawall022484c2010-08-05 10:22:20 +0000397 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400399 timeout = timeout * DELAY_TIMER_CONV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 writel(VAL0|STINTEN, mmio+INTEN0);
401 writel((u32)DLY_INT_A_R0|( event_count<< 16 )|timeout,
402 mmio+DLY_INT_A);
403 break;
404
405 case TX_INTR_COAL :
406 timeout = coal_conf->tx_timeout;
407 event_count = coal_conf->tx_event_count;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400408 if( timeout > MAX_TIMEOUT ||
409 event_count > MAX_EVENT_COUNT )
Julia Lawall022484c2010-08-05 10:22:20 +0000410 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400412
413 timeout = timeout * DELAY_TIMER_CONV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 writel(VAL0|STINTEN,mmio+INTEN0);
415 writel((u32)DLY_INT_B_T0|( event_count<< 16 )|timeout,
416 mmio+DLY_INT_B);
417 break;
418
419 case DISABLE_COAL:
420 writel(0,mmio+STVAL);
421 writel(STINTEN, mmio+INTEN0);
422 writel(0, mmio +DLY_INT_B);
423 writel(0, mmio+DLY_INT_A);
424 break;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400425 case ENABLE_COAL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /* Start the timer */
427 writel((u32)SOFT_TIMER_FREQ, mmio+STVAL); /* 0.5 sec */
428 writel(VAL0|STINTEN, mmio+INTEN0);
429 break;
430 default:
431 break;
432
433 }
434 return 0;
435
436}
437
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400438/*
439This function initializes the device registers and starts the device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440*/
441static int amd8111e_restart(struct net_device *dev)
442{
443 struct amd8111e_priv *lp = netdev_priv(dev);
444 void __iomem *mmio = lp->mmio;
445 int i,reg_val;
446
447 /* stop the chip */
448 writel(RUN, mmio + CMD0);
449
450 if(amd8111e_init_ring(dev))
451 return -ENOMEM;
452
453 /* enable the port manager and set auto negotiation always */
454 writel((u32) VAL1|EN_PMGR, mmio + CMD3 );
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400455 writel((u32)XPHYANE|XPHYRST , mmio + CTRL2);
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 amd8111e_set_ext_phy(dev);
458
459 /* set control registers */
460 reg_val = readl(mmio + CTRL1);
461 reg_val &= ~XMTSP_MASK;
462 writel( reg_val| XMTSP_128 | CACHE_ALIGN, mmio + CTRL1 );
463
464 /* enable interrupt */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400465 writel( APINT5EN | APINT4EN | APINT3EN | APINT2EN | APINT1EN |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 APINT0EN | MIIPDTINTEN | MCCIINTEN | MCCINTEN | MREINTEN |
467 SPNDINTEN | MPINTEN | SINTEN | STINTEN, mmio + INTEN0);
468
469 writel(VAL3 | LCINTEN | VAL1 | TINTEN0 | VAL0 | RINTEN0, mmio + INTEN0);
470
471 /* initialize tx and rx ring base addresses */
472 writel((u32)lp->tx_ring_dma_addr,mmio + XMT_RING_BASE_ADDR0);
473 writel((u32)lp->rx_ring_dma_addr,mmio+ RCV_RING_BASE_ADDR0);
474
475 writew((u32)NUM_TX_RING_DR, mmio + XMT_RING_LEN0);
476 writew((u16)NUM_RX_RING_DR, mmio + RCV_RING_LEN0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /* set default IPG to 96 */
479 writew((u32)DEFAULT_IPG,mmio+IPG);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400480 writew((u32)(DEFAULT_IPG-IFS1_DELTA), mmio + IFS1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 if(lp->options & OPTION_JUMBO_ENABLE){
483 writel((u32)VAL2|JUMBO, mmio + CMD3);
484 /* Reset REX_UFLO */
485 writel( REX_UFLO, mmio + CMD2);
486 /* Should not set REX_UFLO for jumbo frames */
487 writel( VAL0 | APAD_XMT|REX_RTRY , mmio + CMD2);
488 }else{
489 writel( VAL0 | APAD_XMT | REX_RTRY|REX_UFLO, mmio + CMD2);
490 writel((u32)JUMBO, mmio + CMD3);
491 }
492
493#if AMD8111E_VLAN_TAG_USED
494 writel((u32) VAL2|VSIZE|VL_TAG_DEL, mmio + CMD3);
495#endif
496 writel( VAL0 | APAD_XMT | REX_RTRY, mmio + CMD2 );
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 /* Setting the MAC address to the device */
Joe Perchesc857ff62011-11-16 09:38:05 +0000499 for (i = 0; i < ETH_ALEN; i++)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400500 writeb( dev->dev_addr[i], mmio + PADR + i );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 /* Enable interrupt coalesce */
503 if(lp->options & OPTION_INTR_COAL_ENABLE){
504 printk(KERN_INFO "%s: Interrupt Coalescing Enabled.\n",
505 dev->name);
506 amd8111e_set_coalesce(dev,ENABLE_COAL);
507 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 /* set RUN bit to start the chip */
510 writel(VAL2 | RDMD0, mmio + CMD0);
511 writel(VAL0 | INTREN | RUN, mmio + CMD0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 /* To avoid PCI posting bug */
514 readl(mmio+CMD0);
515 return 0;
516}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400517/*
518This function clears necessary the device registers.
519*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520static void amd8111e_init_hw_default( struct amd8111e_priv* lp)
521{
522 unsigned int reg_val;
523 unsigned int logic_filter[2] ={0,};
524 void __iomem *mmio = lp->mmio;
525
526
527 /* stop the chip */
528 writel(RUN, mmio + CMD0);
529
530 /* AUTOPOLL0 Register *//*TBD default value is 8100 in FPS */
531 writew( 0x8100 | lp->ext_phy_addr, mmio + AUTOPOLL0);
532
533 /* Clear RCV_RING_BASE_ADDR */
534 writel(0, mmio + RCV_RING_BASE_ADDR0);
535
536 /* Clear XMT_RING_BASE_ADDR */
537 writel(0, mmio + XMT_RING_BASE_ADDR0);
538 writel(0, mmio + XMT_RING_BASE_ADDR1);
539 writel(0, mmio + XMT_RING_BASE_ADDR2);
540 writel(0, mmio + XMT_RING_BASE_ADDR3);
541
542 /* Clear CMD0 */
543 writel(CMD0_CLEAR,mmio + CMD0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 /* Clear CMD2 */
546 writel(CMD2_CLEAR, mmio +CMD2);
547
548 /* Clear CMD7 */
549 writel(CMD7_CLEAR , mmio + CMD7);
550
551 /* Clear DLY_INT_A and DLY_INT_B */
552 writel(0x0, mmio + DLY_INT_A);
553 writel(0x0, mmio + DLY_INT_B);
554
555 /* Clear FLOW_CONTROL */
556 writel(0x0, mmio + FLOW_CONTROL);
557
558 /* Clear INT0 write 1 to clear register */
559 reg_val = readl(mmio + INT0);
560 writel(reg_val, mmio + INT0);
561
562 /* Clear STVAL */
563 writel(0x0, mmio + STVAL);
564
565 /* Clear INTEN0 */
566 writel( INTEN0_CLEAR, mmio + INTEN0);
567
568 /* Clear LADRF */
569 writel(0x0 , mmio + LADRF);
570
571 /* Set SRAM_SIZE & SRAM_BOUNDARY registers */
572 writel( 0x80010,mmio + SRAM_SIZE);
573
574 /* Clear RCV_RING0_LEN */
575 writel(0x0, mmio + RCV_RING_LEN0);
576
577 /* Clear XMT_RING0/1/2/3_LEN */
578 writel(0x0, mmio + XMT_RING_LEN0);
579 writel(0x0, mmio + XMT_RING_LEN1);
580 writel(0x0, mmio + XMT_RING_LEN2);
581 writel(0x0, mmio + XMT_RING_LEN3);
582
583 /* Clear XMT_RING_LIMIT */
584 writel(0x0, mmio + XMT_RING_LIMIT);
585
586 /* Clear MIB */
587 writew(MIB_CLEAR, mmio + MIB_ADDR);
588
589 /* Clear LARF */
590 amd8111e_writeq(*(u64*)logic_filter,mmio+LADRF);
591
592 /* SRAM_SIZE register */
593 reg_val = readl(mmio + SRAM_SIZE);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 if(lp->options & OPTION_JUMBO_ENABLE)
596 writel( VAL2|JUMBO, mmio + CMD3);
597#if AMD8111E_VLAN_TAG_USED
598 writel(VAL2|VSIZE|VL_TAG_DEL, mmio + CMD3 );
599#endif
600 /* Set default value to CTRL1 Register */
601 writel(CTRL1_DEFAULT, mmio + CTRL1);
602
603 /* To avoid PCI posting bug */
604 readl(mmio + CMD2);
605
606}
607
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400608/*
609This function disables the interrupt and clears all the pending
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610interrupts in INT0
611 */
612static void amd8111e_disable_interrupt(struct amd8111e_priv* lp)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400613{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 u32 intr0;
615
616 /* Disable interrupt */
617 writel(INTREN, lp->mmio + CMD0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /* Clear INT0 */
620 intr0 = readl(lp->mmio + INT0);
621 writel(intr0, lp->mmio + INT0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400622
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /* To avoid PCI posting bug */
624 readl(lp->mmio + INT0);
625
626}
627
628/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400629This function stops the chip.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630*/
631static void amd8111e_stop_chip(struct amd8111e_priv* lp)
632{
633 writel(RUN, lp->mmio + CMD0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 /* To avoid PCI posting bug */
636 readl(lp->mmio + CMD0);
637}
638
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400639/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640This function frees the transmiter and receiver descriptor rings.
641*/
642static void amd8111e_free_ring(struct amd8111e_priv* lp)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400643{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 /* Free transmit and receive descriptor rings */
645 if(lp->rx_ring){
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400646 pci_free_consistent(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 sizeof(struct amd8111e_rx_dr)*NUM_RX_RING_DR,
648 lp->rx_ring, lp->rx_ring_dma_addr);
649 lp->rx_ring = NULL;
650 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 if(lp->tx_ring){
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400653 pci_free_consistent(lp->pci_dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 sizeof(struct amd8111e_tx_dr)*NUM_TX_RING_DR,
655 lp->tx_ring, lp->tx_ring_dma_addr);
656
657 lp->tx_ring = NULL;
658 }
659
660}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400663This 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664*/
665static int amd8111e_tx(struct net_device *dev)
666{
667 struct amd8111e_priv* lp = netdev_priv(dev);
668 int tx_index = lp->tx_complete_idx & TX_RING_DR_MOD_MASK;
669 int status;
670 /* Complete all the transmit packet */
671 while (lp->tx_complete_idx != lp->tx_idx){
672 tx_index = lp->tx_complete_idx & TX_RING_DR_MOD_MASK;
673 status = le16_to_cpu(lp->tx_ring[tx_index].tx_flags);
674
675 if(status & OWN_BIT)
676 break; /* It still hasn't been Txed */
677
678 lp->tx_ring[tx_index].buff_phy_addr = 0;
679
680 /* We must free the original skb */
681 if (lp->tx_skbuff[tx_index]) {
682 pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[tx_index],
683 lp->tx_skbuff[tx_index]->len,
684 PCI_DMA_TODEVICE);
685 dev_kfree_skb_irq (lp->tx_skbuff[tx_index]);
686 lp->tx_skbuff[tx_index] = NULL;
687 lp->tx_dma_addr[tx_index] = 0;
688 }
689 lp->tx_complete_idx++;
690 /*COAL update tx coalescing parameters */
691 lp->coal_conf.tx_packets++;
Al Viro05d2fec2007-08-22 21:42:28 -0400692 lp->coal_conf.tx_bytes +=
693 le16_to_cpu(lp->tx_ring[tx_index].buff_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
695 if (netif_queue_stopped(dev) &&
696 lp->tx_complete_idx > lp->tx_idx - NUM_TX_BUFFERS +2){
697 /* The ring is no longer full, clear tbusy. */
698 /* lp->tx_full = 0; */
699 netif_wake_queue (dev);
700 }
701 }
702 return 0;
703}
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705/* This function handles the driver receive operation in polling mode */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700706static int amd8111e_rx_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700708 struct amd8111e_priv *lp = container_of(napi, struct amd8111e_priv, napi);
709 struct net_device *dev = lp->amd8111e_net_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int rx_index = lp->rx_idx & RX_RING_DR_MOD_MASK;
711 void __iomem *mmio = lp->mmio;
712 struct sk_buff *skb,*new_skb;
713 int min_pkt_len, status;
714 unsigned int intr0;
715 int num_rx_pkt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 short pkt_len;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400717#if AMD8111E_VLAN_TAG_USED
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 short vtag;
719#endif
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700720 int rx_pkt_limit = budget;
Liu Taodfa1b732005-05-12 19:40:38 -0400721 unsigned long flags;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400722
723 do{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 /* process receive packets until we use the quota*/
725 /* If we own the next entry, it's a new packet. Send it up. */
726 while(1) {
727 status = le16_to_cpu(lp->rx_ring[rx_index].rx_flags);
728 if (status & OWN_BIT)
729 break;
730
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400731 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 * There is a tricky error noted by John Murphy,
733 * <murf@perftech.com> to Russ Nelson: Even with
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400734 * full-sized * buffers it's possible for a
735 * jabber packet to use two buffers, with only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 * the last correctly noting the error.
737 */
738
739 if(status & ERR_BIT) {
740 /* reseting flags */
741 lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
742 goto err_next_pkt;
743 }
744 /* check for STP and ENP */
745 if(!((status & STP_BIT) && (status & ENP_BIT))){
746 /* reseting flags */
747 lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
748 goto err_next_pkt;
749 }
750 pkt_len = le16_to_cpu(lp->rx_ring[rx_index].msg_count) - 4;
751
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400752#if AMD8111E_VLAN_TAG_USED
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 vtag = status & TT_MASK;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400754 /*MAC will strip vlan tag*/
Jiri Pirkoc8d9e6d2011-07-20 04:54:11 +0000755 if (vtag != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 min_pkt_len =MIN_PKT_LEN - 4;
757 else
758#endif
759 min_pkt_len =MIN_PKT_LEN;
760
761 if (pkt_len < min_pkt_len) {
762 lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
763 lp->drv_rx_errors++;
764 goto err_next_pkt;
765 }
766 if(--rx_pkt_limit < 0)
767 goto rx_not_empty;
Pradeep A Dalvi1d266432012-02-05 02:49:09 +0000768 new_skb = netdev_alloc_skb(dev, lp->rx_buff_len);
769 if (!new_skb) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400770 /* if allocation fail,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 ignore that pkt and go to next one */
772 lp->rx_ring[rx_index].rx_flags &= RESET_RX_FLAGS;
773 lp->drv_rx_errors++;
774 goto err_next_pkt;
775 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400776
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 skb_reserve(new_skb, 2);
778 skb = lp->rx_skbuff[rx_index];
779 pci_unmap_single(lp->pci_dev,lp->rx_dma_addr[rx_index],
780 lp->rx_buff_len-2, PCI_DMA_FROMDEVICE);
781 skb_put(skb, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 lp->rx_skbuff[rx_index] = new_skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 lp->rx_dma_addr[rx_index] = pci_map_single(lp->pci_dev,
784 new_skb->data,
785 lp->rx_buff_len-2,
786 PCI_DMA_FROMDEVICE);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400787
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 skb->protocol = eth_type_trans(skb, dev);
789
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400790#if AMD8111E_VLAN_TAG_USED
Jiri Pirkoc8d9e6d2011-07-20 04:54:11 +0000791 if (vtag == TT_VLAN_TAGGED){
792 u16 vlan_tag = le16_to_cpu(lp->rx_ring[rx_index].tag_ctrl_info);
Patrick McHardy86a9bad2013-04-19 02:04:30 +0000793 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
Jiri Pirkoc8d9e6d2011-07-20 04:54:11 +0000794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795#endif
Jiri Pirkoc8d9e6d2011-07-20 04:54:11 +0000796 netif_receive_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 /*COAL update rx coalescing parameters*/
798 lp->coal_conf.rx_packets++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400799 lp->coal_conf.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 num_rx_pkt++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400801
802 err_next_pkt:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 lp->rx_ring[rx_index].buff_phy_addr
804 = cpu_to_le32(lp->rx_dma_addr[rx_index]);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400805 lp->rx_ring[rx_index].buff_count =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 cpu_to_le16(lp->rx_buff_len-2);
807 wmb();
808 lp->rx_ring[rx_index].rx_flags |= cpu_to_le16(OWN_BIT);
809 rx_index = (++lp->rx_idx) & RX_RING_DR_MOD_MASK;
810 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400811 /* Check the interrupt status register for more packets in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 mean time. Process them since we have not used up our quota.*/
813
814 intr0 = readl(mmio + INT0);
815 /*Ack receive packets */
816 writel(intr0 & RINT0,mmio + INT0);
817
818 } while(intr0 & RINT0);
819
Chris Friesen48e5eca2008-10-28 15:50:54 -0700820 if (rx_pkt_limit > 0) {
821 /* Receive descriptor is empty now */
822 spin_lock_irqsave(&lp->lock, flags);
Ben Hutchings288379f2009-01-19 16:43:59 -0800823 __napi_complete(napi);
Chris Friesen48e5eca2008-10-28 15:50:54 -0700824 writel(VAL0|RINTEN0, mmio + INTEN0);
825 writel(VAL2 | RDMD0, mmio + CMD0);
826 spin_unlock_irqrestore(&lp->lock, flags);
827 }
Liu Taodfa1b732005-05-12 19:40:38 -0400828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829rx_not_empty:
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700830 return num_rx_pkt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831}
832
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400833/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834This function will indicate the link status to the kernel.
835*/
836static int amd8111e_link_change(struct net_device* dev)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400837{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 struct amd8111e_priv *lp = netdev_priv(dev);
839 int status0,speed;
840
841 /* read the link change */
842 status0 = readl(lp->mmio + STAT0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 if(status0 & LINK_STATS){
845 if(status0 & AUTONEG_COMPLETE)
846 lp->link_config.autoneg = AUTONEG_ENABLE;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400847 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 lp->link_config.autoneg = AUTONEG_DISABLE;
849
850 if(status0 & FULL_DPLX)
851 lp->link_config.duplex = DUPLEX_FULL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400852 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 lp->link_config.duplex = DUPLEX_HALF;
854 speed = (status0 & SPEED_MASK) >> 7;
855 if(speed == PHY_SPEED_10)
856 lp->link_config.speed = SPEED_10;
857 else if(speed == PHY_SPEED_100)
858 lp->link_config.speed = SPEED_100;
859
860 printk(KERN_INFO "%s: Link is Up. Speed is %s Mbps %s Duplex\n", dev->name,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400861 (lp->link_config.speed == SPEED_100) ? "100": "10",
862 (lp->link_config.duplex == DUPLEX_FULL)? "Full": "Half");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 netif_carrier_on(dev);
864 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400865 else{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 lp->link_config.speed = SPEED_INVALID;
867 lp->link_config.duplex = DUPLEX_INVALID;
868 lp->link_config.autoneg = AUTONEG_INVALID;
869 printk(KERN_INFO "%s: Link is Down.\n",dev->name);
870 netif_carrier_off(dev);
871 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400872
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 return 0;
874}
875/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400876This function reads the mib counters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877*/
878static int amd8111e_read_mib(void __iomem *mmio, u8 MIB_COUNTER)
879{
880 unsigned int status;
881 unsigned int data;
882 unsigned int repeat = REPEAT_CNT;
883
884 writew( MIB_RD_CMD | MIB_COUNTER, mmio + MIB_ADDR);
885 do {
886 status = readw(mmio + MIB_ADDR);
887 udelay(2); /* controller takes MAX 2 us to get mib data */
888 }
889 while (--repeat && (status & MIB_CMD_ACTIVE));
890
891 data = readl(mmio + MIB_DATA);
892 return data;
893}
894
895/*
Eric Dumazetc3227e52010-08-20 03:08:23 +0000896 * This function reads the mib registers and returns the hardware statistics.
897 * It updates previous internal driver statistics with new values.
898 */
899static struct net_device_stats *amd8111e_get_stats(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
901 struct amd8111e_priv *lp = netdev_priv(dev);
902 void __iomem *mmio = lp->mmio;
903 unsigned long flags;
Eric Dumazetc3227e52010-08-20 03:08:23 +0000904 struct net_device_stats *new_stats = &dev->stats;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400905
Eric Dumazetc3227e52010-08-20 03:08:23 +0000906 if (!lp->opened)
907 return new_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 spin_lock_irqsave (&lp->lock, flags);
909
910 /* stats.rx_packets */
911 new_stats->rx_packets = amd8111e_read_mib(mmio, rcv_broadcast_pkts)+
912 amd8111e_read_mib(mmio, rcv_multicast_pkts)+
913 amd8111e_read_mib(mmio, rcv_unicast_pkts);
914
915 /* stats.tx_packets */
916 new_stats->tx_packets = amd8111e_read_mib(mmio, xmt_packets);
917
918 /*stats.rx_bytes */
919 new_stats->rx_bytes = amd8111e_read_mib(mmio, rcv_octets);
920
921 /* stats.tx_bytes */
922 new_stats->tx_bytes = amd8111e_read_mib(mmio, xmt_octets);
923
924 /* stats.rx_errors */
925 /* hw errors + errors driver reported */
926 new_stats->rx_errors = amd8111e_read_mib(mmio, rcv_undersize_pkts)+
927 amd8111e_read_mib(mmio, rcv_fragments)+
928 amd8111e_read_mib(mmio, rcv_jabbers)+
929 amd8111e_read_mib(mmio, rcv_alignment_errors)+
930 amd8111e_read_mib(mmio, rcv_fcs_errors)+
931 amd8111e_read_mib(mmio, rcv_miss_pkts)+
932 lp->drv_rx_errors;
933
934 /* stats.tx_errors */
935 new_stats->tx_errors = amd8111e_read_mib(mmio, xmt_underrun_pkts);
936
937 /* stats.rx_dropped*/
938 new_stats->rx_dropped = amd8111e_read_mib(mmio, rcv_miss_pkts);
939
940 /* stats.tx_dropped*/
941 new_stats->tx_dropped = amd8111e_read_mib(mmio, xmt_underrun_pkts);
942
943 /* stats.multicast*/
944 new_stats->multicast = amd8111e_read_mib(mmio, rcv_multicast_pkts);
945
946 /* stats.collisions*/
947 new_stats->collisions = amd8111e_read_mib(mmio, xmt_collisions);
948
949 /* stats.rx_length_errors*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400950 new_stats->rx_length_errors =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 amd8111e_read_mib(mmio, rcv_undersize_pkts)+
952 amd8111e_read_mib(mmio, rcv_oversize_pkts);
953
954 /* stats.rx_over_errors*/
955 new_stats->rx_over_errors = amd8111e_read_mib(mmio, rcv_miss_pkts);
956
957 /* stats.rx_crc_errors*/
958 new_stats->rx_crc_errors = amd8111e_read_mib(mmio, rcv_fcs_errors);
959
960 /* stats.rx_frame_errors*/
961 new_stats->rx_frame_errors =
962 amd8111e_read_mib(mmio, rcv_alignment_errors);
963
964 /* stats.rx_fifo_errors */
965 new_stats->rx_fifo_errors = amd8111e_read_mib(mmio, rcv_miss_pkts);
966
967 /* stats.rx_missed_errors */
968 new_stats->rx_missed_errors = amd8111e_read_mib(mmio, rcv_miss_pkts);
969
970 /* stats.tx_aborted_errors*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400971 new_stats->tx_aborted_errors =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 amd8111e_read_mib(mmio, xmt_excessive_collision);
973
974 /* stats.tx_carrier_errors*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400975 new_stats->tx_carrier_errors =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 amd8111e_read_mib(mmio, xmt_loss_carrier);
977
978 /* stats.tx_fifo_errors*/
979 new_stats->tx_fifo_errors = amd8111e_read_mib(mmio, xmt_underrun_pkts);
980
981 /* stats.tx_window_errors*/
982 new_stats->tx_window_errors =
983 amd8111e_read_mib(mmio, xmt_late_collision);
984
985 /* Reset the mibs for collecting new statistics */
986 /* writew(MIB_CLEAR, mmio + MIB_ADDR);*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 spin_unlock_irqrestore (&lp->lock, flags);
989
990 return new_stats;
991}
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200992/* This function recalculate the interrupt coalescing mode on every interrupt
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993according to the datarate and the packet rate.
994*/
995static int amd8111e_calc_coalesce(struct net_device *dev)
996{
997 struct amd8111e_priv *lp = netdev_priv(dev);
998 struct amd8111e_coalesce_conf * coal_conf = &lp->coal_conf;
999 int tx_pkt_rate;
1000 int rx_pkt_rate;
1001 int tx_data_rate;
1002 int rx_data_rate;
1003 int rx_pkt_size;
1004 int tx_pkt_size;
1005
1006 tx_pkt_rate = coal_conf->tx_packets - coal_conf->tx_prev_packets;
1007 coal_conf->tx_prev_packets = coal_conf->tx_packets;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 tx_data_rate = coal_conf->tx_bytes - coal_conf->tx_prev_bytes;
1010 coal_conf->tx_prev_bytes = coal_conf->tx_bytes;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001011
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 rx_pkt_rate = coal_conf->rx_packets - coal_conf->rx_prev_packets;
1013 coal_conf->rx_prev_packets = coal_conf->rx_packets;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 rx_data_rate = coal_conf->rx_bytes - coal_conf->rx_prev_bytes;
1016 coal_conf->rx_prev_bytes = coal_conf->rx_bytes;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001017
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 if(rx_pkt_rate < 800){
1019 if(coal_conf->rx_coal_type != NO_COALESCE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 coal_conf->rx_timeout = 0x0;
1022 coal_conf->rx_event_count = 0;
1023 amd8111e_set_coalesce(dev,RX_INTR_COAL);
1024 coal_conf->rx_coal_type = NO_COALESCE;
1025 }
1026 }
1027 else{
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 rx_pkt_size = rx_data_rate/rx_pkt_rate;
1030 if (rx_pkt_size < 128){
1031 if(coal_conf->rx_coal_type != NO_COALESCE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 coal_conf->rx_timeout = 0;
1034 coal_conf->rx_event_count = 0;
1035 amd8111e_set_coalesce(dev,RX_INTR_COAL);
1036 coal_conf->rx_coal_type = NO_COALESCE;
1037 }
1038
1039 }
1040 else if ( (rx_pkt_size >= 128) && (rx_pkt_size < 512) ){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 if(coal_conf->rx_coal_type != LOW_COALESCE){
1043 coal_conf->rx_timeout = 1;
1044 coal_conf->rx_event_count = 4;
1045 amd8111e_set_coalesce(dev,RX_INTR_COAL);
1046 coal_conf->rx_coal_type = LOW_COALESCE;
1047 }
1048 }
1049 else if ((rx_pkt_size >= 512) && (rx_pkt_size < 1024)){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 if(coal_conf->rx_coal_type != MEDIUM_COALESCE){
1052 coal_conf->rx_timeout = 1;
1053 coal_conf->rx_event_count = 4;
1054 amd8111e_set_coalesce(dev,RX_INTR_COAL);
1055 coal_conf->rx_coal_type = MEDIUM_COALESCE;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001056 }
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 }
1059 else if(rx_pkt_size >= 1024){
1060 if(coal_conf->rx_coal_type != HIGH_COALESCE){
1061 coal_conf->rx_timeout = 2;
1062 coal_conf->rx_event_count = 3;
1063 amd8111e_set_coalesce(dev,RX_INTR_COAL);
1064 coal_conf->rx_coal_type = HIGH_COALESCE;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 }
1067 }
1068 /* NOW FOR TX INTR COALESC */
1069 if(tx_pkt_rate < 800){
1070 if(coal_conf->tx_coal_type != NO_COALESCE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 coal_conf->tx_timeout = 0x0;
1073 coal_conf->tx_event_count = 0;
1074 amd8111e_set_coalesce(dev,TX_INTR_COAL);
1075 coal_conf->tx_coal_type = NO_COALESCE;
1076 }
1077 }
1078 else{
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 tx_pkt_size = tx_data_rate/tx_pkt_rate;
1081 if (tx_pkt_size < 128){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if(coal_conf->tx_coal_type != NO_COALESCE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 coal_conf->tx_timeout = 0;
1086 coal_conf->tx_event_count = 0;
1087 amd8111e_set_coalesce(dev,TX_INTR_COAL);
1088 coal_conf->tx_coal_type = NO_COALESCE;
1089 }
1090
1091 }
1092 else if ( (tx_pkt_size >= 128) && (tx_pkt_size < 512) ){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 if(coal_conf->tx_coal_type != LOW_COALESCE){
1095 coal_conf->tx_timeout = 1;
1096 coal_conf->tx_event_count = 2;
1097 amd8111e_set_coalesce(dev,TX_INTR_COAL);
1098 coal_conf->tx_coal_type = LOW_COALESCE;
1099
1100 }
1101 }
1102 else if ((tx_pkt_size >= 512) && (tx_pkt_size < 1024)){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001103
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 if(coal_conf->tx_coal_type != MEDIUM_COALESCE){
1105 coal_conf->tx_timeout = 2;
1106 coal_conf->tx_event_count = 5;
1107 amd8111e_set_coalesce(dev,TX_INTR_COAL);
1108 coal_conf->tx_coal_type = MEDIUM_COALESCE;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001109 }
1110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 }
1112 else if(tx_pkt_size >= 1024){
1113 if (tx_pkt_size >= 1024){
1114 if(coal_conf->tx_coal_type != HIGH_COALESCE){
1115 coal_conf->tx_timeout = 4;
1116 coal_conf->tx_event_count = 8;
1117 amd8111e_set_coalesce(dev,TX_INTR_COAL);
1118 coal_conf->tx_coal_type = HIGH_COALESCE;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 }
1121 }
1122 }
1123 return 0;
1124
1125}
1126/*
1127This is device interrupt function. It handles transmit, receive,link change and hardware timer interrupts.
1128*/
David Howells7d12e782006-10-05 14:55:46 +01001129static irqreturn_t amd8111e_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131
1132 struct net_device * dev = (struct net_device *) dev_id;
1133 struct amd8111e_priv *lp = netdev_priv(dev);
1134 void __iomem *mmio = lp->mmio;
Liu Taodfa1b732005-05-12 19:40:38 -04001135 unsigned int intr0, intren0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 unsigned int handled = 1;
1137
Liu Taodfa1b732005-05-12 19:40:38 -04001138 if(unlikely(dev == NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 return IRQ_NONE;
1140
Liu Taodfa1b732005-05-12 19:40:38 -04001141 spin_lock(&lp->lock);
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 /* disabling interrupt */
1144 writel(INTREN, mmio + CMD0);
1145
1146 /* Read interrupt status */
1147 intr0 = readl(mmio + INT0);
Liu Taodfa1b732005-05-12 19:40:38 -04001148 intren0 = readl(mmio + INTEN0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 /* Process all the INT event until INTR bit is clear. */
1151
1152 if (!(intr0 & INTR)){
1153 handled = 0;
1154 goto err_no_interrupt;
1155 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001156
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 /* Current driver processes 4 interrupts : RINT,TINT,LCINT,STINT */
1158 writel(intr0, mmio + INT0);
1159
1160 /* Check if Receive Interrupt has occurred. */
Francois Romieu6ba33ac2008-07-06 20:55:12 -07001161 if (intr0 & RINT0) {
Ben Hutchings288379f2009-01-19 16:43:59 -08001162 if (napi_schedule_prep(&lp->napi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 /* Disable receive interupts */
1164 writel(RINTEN0, mmio + INTEN0);
1165 /* Schedule a polling routine */
Ben Hutchings288379f2009-01-19 16:43:59 -08001166 __napi_schedule(&lp->napi);
Francois Romieu6ba33ac2008-07-06 20:55:12 -07001167 } else if (intren0 & RINTEN0) {
Joe Perches91e83432010-01-31 10:02:09 +00001168 printk("************Driver bug! interrupt while in poll\n");
Liu Taodfa1b732005-05-12 19:40:38 -04001169 /* Fix by disable receive interrupts */
1170 writel(RINTEN0, mmio + INTEN0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172 }
Francois Romieu6ba33ac2008-07-06 20:55:12 -07001173
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 /* Check if Transmit Interrupt has occurred. */
Francois Romieu6ba33ac2008-07-06 20:55:12 -07001175 if (intr0 & TINT0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 amd8111e_tx(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001177
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 /* Check if Link Change Interrupt has occurred. */
1179 if (intr0 & LCINT)
1180 amd8111e_link_change(dev);
1181
1182 /* Check if Hardware Timer Interrupt has occurred. */
1183 if (intr0 & STINT)
1184 amd8111e_calc_coalesce(dev);
1185
1186err_no_interrupt:
1187 writel( VAL0 | INTREN,mmio + CMD0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001188
Liu Taodfa1b732005-05-12 19:40:38 -04001189 spin_unlock(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001190
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 return IRQ_RETVAL(handled);
1192}
1193
1194#ifdef CONFIG_NET_POLL_CONTROLLER
1195static void amd8111e_poll(struct net_device *dev)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001196{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 unsigned long flags;
Jiri Kosinab7e36bf2007-02-05 16:29:49 -08001198 local_irq_save(flags);
David Howells7d12e782006-10-05 14:55:46 +01001199 amd8111e_interrupt(0, dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001200 local_irq_restore(flags);
1201}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202#endif
1203
1204
1205/*
1206This function closes the network interface and updates the statistics so that most recent statistics will be available after the interface is down.
1207*/
1208static int amd8111e_close(struct net_device * dev)
1209{
1210 struct amd8111e_priv *lp = netdev_priv(dev);
1211 netif_stop_queue(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001212
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001213 napi_disable(&lp->napi);
1214
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 spin_lock_irq(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001216
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 amd8111e_disable_interrupt(lp);
1218 amd8111e_stop_chip(lp);
Chunbo Luoe83603f2008-10-28 09:51:46 +08001219
1220 /* Free transmit and receive skbs */
1221 amd8111e_free_skbs(lp->amd8111e_net_dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 netif_carrier_off(lp->amd8111e_net_dev);
1224
1225 /* Delete ipg timer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001226 if(lp->options & OPTION_DYN_IPG_ENABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 del_timer_sync(&lp->ipg_data.ipg_timer);
1228
1229 spin_unlock_irq(&lp->lock);
1230 free_irq(dev->irq, dev);
Chunbo Luoe83603f2008-10-28 09:51:46 +08001231 amd8111e_free_ring(lp);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 /* Update the statistics before closing */
1234 amd8111e_get_stats(dev);
1235 lp->opened = 0;
1236 return 0;
1237}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001238/* This function opens new interface.It requests irq for the device, initializes the device,buffers and descriptors, and starts the device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239*/
1240static int amd8111e_open(struct net_device * dev )
1241{
1242 struct amd8111e_priv *lp = netdev_priv(dev);
1243
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001244 if(dev->irq ==0 || request_irq(dev->irq, amd8111e_interrupt, IRQF_SHARED,
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001245 dev->name, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 return -EAGAIN;
1247
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001248 napi_enable(&lp->napi);
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 spin_lock_irq(&lp->lock);
1251
1252 amd8111e_init_hw_default(lp);
1253
1254 if(amd8111e_restart(dev)){
1255 spin_unlock_irq(&lp->lock);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001256 napi_disable(&lp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 if (dev->irq)
1258 free_irq(dev->irq, dev);
1259 return -ENOMEM;
1260 }
1261 /* Start ipg timer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001262 if(lp->options & OPTION_DYN_IPG_ENABLE){
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 add_timer(&lp->ipg_data.ipg_timer);
1264 printk(KERN_INFO "%s: Dynamic IPG Enabled.\n",dev->name);
1265 }
1266
1267 lp->opened = 1;
1268
1269 spin_unlock_irq(&lp->lock);
1270
1271 netif_start_queue(dev);
1272
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001273 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001275/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276This function checks if there is any transmit descriptors available to queue more packet.
1277*/
1278static int amd8111e_tx_queue_avail(struct amd8111e_priv* lp )
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001279{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 int tx_index = lp->tx_idx & TX_BUFF_MOD_MASK;
Al Viroee41a822007-08-22 21:37:46 -04001281 if (lp->tx_skbuff[tx_index])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 return -1;
1283 else
1284 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001287/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288This 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.
1289*/
1290
Stephen Hemminger613573252009-08-31 19:50:58 +00001291static netdev_tx_t amd8111e_start_xmit(struct sk_buff *skb,
1292 struct net_device * dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293{
1294 struct amd8111e_priv *lp = netdev_priv(dev);
1295 int tx_index;
1296 unsigned long flags;
1297
1298 spin_lock_irqsave(&lp->lock, flags);
1299
1300 tx_index = lp->tx_idx & TX_RING_DR_MOD_MASK;
1301
1302 lp->tx_ring[tx_index].buff_count = cpu_to_le16(skb->len);
1303
1304 lp->tx_skbuff[tx_index] = skb;
1305 lp->tx_ring[tx_index].tx_flags = 0;
1306
1307#if AMD8111E_VLAN_TAG_USED
Jesse Grosseab6d182010-10-20 13:56:03 +00001308 if (vlan_tx_tag_present(skb)) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001309 lp->tx_ring[tx_index].tag_ctrl_cmd |=
1310 cpu_to_le16(TCC_VLAN_INSERT);
1311 lp->tx_ring[tx_index].tag_ctrl_info =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 cpu_to_le16(vlan_tx_tag_get(skb));
1313
1314 }
1315#endif
1316 lp->tx_dma_addr[tx_index] =
1317 pci_map_single(lp->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE);
1318 lp->tx_ring[tx_index].buff_phy_addr =
Al Viroee41a822007-08-22 21:37:46 -04001319 cpu_to_le32(lp->tx_dma_addr[tx_index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
1321 /* Set FCS and LTINT bits */
1322 wmb();
1323 lp->tx_ring[tx_index].tx_flags |=
1324 cpu_to_le16(OWN_BIT | STP_BIT | ENP_BIT|ADD_FCS_BIT|LTINT_BIT);
1325
1326 lp->tx_idx++;
1327
1328 /* Trigger an immediate send poll. */
1329 writel( VAL1 | TDMD0, lp->mmio + CMD0);
1330 writel( VAL2 | RDMD0,lp->mmio + CMD0);
1331
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if(amd8111e_tx_queue_avail(lp) < 0){
1333 netif_stop_queue(dev);
1334 }
1335 spin_unlock_irqrestore(&lp->lock, flags);
Patrick McHardy6ed10652009-06-23 06:03:08 +00001336 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337}
1338/*
1339This function returns all the memory mapped registers of the device.
1340*/
1341static void amd8111e_read_regs(struct amd8111e_priv *lp, u32 *buf)
1342{
1343 void __iomem *mmio = lp->mmio;
1344 /* Read only necessary registers */
1345 buf[0] = readl(mmio + XMT_RING_BASE_ADDR0);
1346 buf[1] = readl(mmio + XMT_RING_LEN0);
1347 buf[2] = readl(mmio + RCV_RING_BASE_ADDR0);
1348 buf[3] = readl(mmio + RCV_RING_LEN0);
1349 buf[4] = readl(mmio + CMD0);
1350 buf[5] = readl(mmio + CMD2);
1351 buf[6] = readl(mmio + CMD3);
1352 buf[7] = readl(mmio + CMD7);
1353 buf[8] = readl(mmio + INT0);
1354 buf[9] = readl(mmio + INTEN0);
1355 buf[10] = readl(mmio + LADRF);
1356 buf[11] = readl(mmio + LADRF+4);
1357 buf[12] = readl(mmio + STAT0);
1358}
1359
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001362This function sets promiscuos mode, all-multi mode or the multicast address
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363list to the device.
1364*/
1365static void amd8111e_set_multicast_list(struct net_device *dev)
1366{
Jiri Pirko22bedad32010-04-01 21:22:57 +00001367 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 struct amd8111e_priv *lp = netdev_priv(dev);
1369 u32 mc_filter[2] ;
Jiri Pirko0ddf4772010-02-20 00:13:58 +00001370 int bit_num;
1371
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 if(dev->flags & IFF_PROMISC){
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 writel( VAL2 | PROM, lp->mmio + CMD2);
1374 return;
1375 }
1376 else
1377 writel( PROM, lp->mmio + CMD2);
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001378 if (dev->flags & IFF_ALLMULTI ||
1379 netdev_mc_count(dev) > MAX_FILTER_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 /* get all multicast packet */
1381 mc_filter[1] = mc_filter[0] = 0xffffffff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 lp->options |= OPTION_MULTICAST_ENABLE;
1383 amd8111e_writeq(*(u64*)mc_filter,lp->mmio + LADRF);
1384 return;
1385 }
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001386 if (netdev_mc_empty(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 /* get only own packets */
1388 mc_filter[1] = mc_filter[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 lp->options &= ~OPTION_MULTICAST_ENABLE;
1390 amd8111e_writeq(*(u64*)mc_filter,lp->mmio + LADRF);
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001391 /* disable promiscuous mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 writel(PROM, lp->mmio + CMD2);
1393 return;
1394 }
1395 /* load all the multicast addresses in the logic filter */
1396 lp->options |= OPTION_MULTICAST_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 mc_filter[1] = mc_filter[0] = 0;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001398 netdev_for_each_mc_addr(ha, dev) {
1399 bit_num = (ether_crc_le(ETH_ALEN, ha->addr) >> 26) & 0x3f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 mc_filter[bit_num >> 5] |= 1 << (bit_num & 31);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 amd8111e_writeq(*(u64*)mc_filter,lp->mmio+ LADRF);
1403
1404 /* To eliminate PCI posting bug */
1405 readl(lp->mmio + CMD2);
1406
1407}
1408
1409static void amd8111e_get_drvinfo(struct net_device* dev, struct ethtool_drvinfo *info)
1410{
1411 struct amd8111e_priv *lp = netdev_priv(dev);
1412 struct pci_dev *pci_dev = lp->pci_dev;
Rick Jones23020ab2011-11-09 09:58:07 +00001413 strlcpy(info->driver, MODULE_NAME, sizeof(info->driver));
1414 strlcpy(info->version, MODULE_VERS, sizeof(info->version));
1415 snprintf(info->fw_version, sizeof(info->fw_version),
1416 "%u", chip_version);
1417 strlcpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418}
1419
1420static int amd8111e_get_regs_len(struct net_device *dev)
1421{
1422 return AMD8111E_REG_DUMP_LEN;
1423}
1424
1425static void amd8111e_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *buf)
1426{
1427 struct amd8111e_priv *lp = netdev_priv(dev);
1428 regs->version = 0;
1429 amd8111e_read_regs(lp, buf);
1430}
1431
1432static int amd8111e_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1433{
1434 struct amd8111e_priv *lp = netdev_priv(dev);
1435 spin_lock_irq(&lp->lock);
1436 mii_ethtool_gset(&lp->mii_if, ecmd);
1437 spin_unlock_irq(&lp->lock);
1438 return 0;
1439}
1440
1441static int amd8111e_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1442{
1443 struct amd8111e_priv *lp = netdev_priv(dev);
1444 int res;
1445 spin_lock_irq(&lp->lock);
1446 res = mii_ethtool_sset(&lp->mii_if, ecmd);
1447 spin_unlock_irq(&lp->lock);
1448 return res;
1449}
1450
1451static int amd8111e_nway_reset(struct net_device *dev)
1452{
1453 struct amd8111e_priv *lp = netdev_priv(dev);
1454 return mii_nway_restart(&lp->mii_if);
1455}
1456
1457static u32 amd8111e_get_link(struct net_device *dev)
1458{
1459 struct amd8111e_priv *lp = netdev_priv(dev);
1460 return mii_link_ok(&lp->mii_if);
1461}
1462
1463static void amd8111e_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol_info)
1464{
1465 struct amd8111e_priv *lp = netdev_priv(dev);
1466 wol_info->supported = WAKE_MAGIC|WAKE_PHY;
1467 if (lp->options & OPTION_WOL_ENABLE)
1468 wol_info->wolopts = WAKE_MAGIC;
1469}
1470
1471static int amd8111e_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol_info)
1472{
1473 struct amd8111e_priv *lp = netdev_priv(dev);
1474 if (wol_info->wolopts & ~(WAKE_MAGIC|WAKE_PHY))
1475 return -EINVAL;
1476 spin_lock_irq(&lp->lock);
1477 if (wol_info->wolopts & WAKE_MAGIC)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001478 lp->options |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 (OPTION_WOL_ENABLE | OPTION_WAKE_MAGIC_ENABLE);
1480 else if(wol_info->wolopts & WAKE_PHY)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001481 lp->options |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 (OPTION_WOL_ENABLE | OPTION_WAKE_PHY_ENABLE);
1483 else
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001484 lp->options &= ~OPTION_WOL_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 spin_unlock_irq(&lp->lock);
1486 return 0;
1487}
1488
Jeff Garzik7282d492006-09-13 14:30:00 -04001489static const struct ethtool_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 .get_drvinfo = amd8111e_get_drvinfo,
1491 .get_regs_len = amd8111e_get_regs_len,
1492 .get_regs = amd8111e_get_regs,
1493 .get_settings = amd8111e_get_settings,
1494 .set_settings = amd8111e_set_settings,
1495 .nway_reset = amd8111e_nway_reset,
1496 .get_link = amd8111e_get_link,
1497 .get_wol = amd8111e_get_wol,
1498 .set_wol = amd8111e_set_wol,
1499};
1500
1501/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001502This 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505static int amd8111e_ioctl(struct net_device * dev , struct ifreq *ifr, int cmd)
1506{
1507 struct mii_ioctl_data *data = if_mii(ifr);
1508 struct amd8111e_priv *lp = netdev_priv(dev);
1509 int err;
1510 u32 mii_regval;
1511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 switch(cmd) {
1513 case SIOCGMIIPHY:
1514 data->phy_id = lp->ext_phy_addr;
1515
1516 /* fallthru */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001517 case SIOCGMIIREG:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519 spin_lock_irq(&lp->lock);
1520 err = amd8111e_read_phy(lp, data->phy_id,
1521 data->reg_num & PHY_REG_ADDR_MASK, &mii_regval);
1522 spin_unlock_irq(&lp->lock);
1523
1524 data->val_out = mii_regval;
1525 return err;
1526
1527 case SIOCSMIIREG:
1528
1529 spin_lock_irq(&lp->lock);
1530 err = amd8111e_write_phy(lp, data->phy_id,
1531 data->reg_num & PHY_REG_ADDR_MASK, data->val_in);
1532 spin_unlock_irq(&lp->lock);
1533
1534 return err;
1535
1536 default:
1537 /* do nothing */
1538 break;
1539 }
1540 return -EOPNOTSUPP;
1541}
1542static int amd8111e_set_mac_address(struct net_device *dev, void *p)
1543{
1544 struct amd8111e_priv *lp = netdev_priv(dev);
1545 int i;
1546 struct sockaddr *addr = p;
1547
1548 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1549 spin_lock_irq(&lp->lock);
1550 /* Setting the MAC address to the device */
Joe Perchesc857ff62011-11-16 09:38:05 +00001551 for (i = 0; i < ETH_ALEN; i++)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001552 writeb( dev->dev_addr[i], lp->mmio + PADR + i );
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 spin_unlock_irq(&lp->lock);
1555
1556 return 0;
1557}
1558
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001559/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560This function changes the mtu of the device. It restarts the device to initialize the descriptor with new receive buffers.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001561*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562static int amd8111e_change_mtu(struct net_device *dev, int new_mtu)
1563{
1564 struct amd8111e_priv *lp = netdev_priv(dev);
1565 int err;
1566
1567 if ((new_mtu < AMD8111E_MIN_MTU) || (new_mtu > AMD8111E_MAX_MTU))
1568 return -EINVAL;
1569
1570 if (!netif_running(dev)) {
1571 /* new_mtu will be used
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001572 when device starts netxt time */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 dev->mtu = new_mtu;
1574 return 0;
1575 }
1576
1577 spin_lock_irq(&lp->lock);
1578
1579 /* stop the chip */
1580 writel(RUN, lp->mmio + CMD0);
1581
1582 dev->mtu = new_mtu;
1583
1584 err = amd8111e_restart(dev);
1585 spin_unlock_irq(&lp->lock);
1586 if(!err)
1587 netif_start_queue(dev);
1588 return err;
1589}
1590
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591static int amd8111e_enable_magicpkt(struct amd8111e_priv* lp)
1592{
1593 writel( VAL1|MPPLBA, lp->mmio + CMD3);
1594 writel( VAL0|MPEN_SW, lp->mmio + CMD7);
1595
1596 /* To eliminate PCI posting bug */
1597 readl(lp->mmio + CMD7);
1598 return 0;
1599}
1600
1601static int amd8111e_enable_link_change(struct amd8111e_priv* lp)
1602{
1603
1604 /* Adapter is already stoped/suspended/interrupt-disabled */
1605 writel(VAL0|LCMODE_SW,lp->mmio + CMD7);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 /* To eliminate PCI posting bug */
1608 readl(lp->mmio + CMD7);
1609 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001610}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001612/*
1613 * This function is called when a packet transmission fails to complete
1614 * within a reasonable period, on the assumption that an interrupt have
1615 * failed or the interface is locked up. This function will reinitialize
1616 * the hardware.
1617 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618static void amd8111e_tx_timeout(struct net_device *dev)
1619{
1620 struct amd8111e_priv* lp = netdev_priv(dev);
1621 int err;
1622
1623 printk(KERN_ERR "%s: transmit timed out, resetting\n",
1624 dev->name);
1625 spin_lock_irq(&lp->lock);
1626 err = amd8111e_restart(dev);
1627 spin_unlock_irq(&lp->lock);
1628 if(!err)
1629 netif_wake_queue(dev);
1630}
1631static int amd8111e_suspend(struct pci_dev *pci_dev, pm_message_t state)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001632{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 struct net_device *dev = pci_get_drvdata(pci_dev);
1634 struct amd8111e_priv *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001635
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 if (!netif_running(dev))
1637 return 0;
1638
1639 /* disable the interrupt */
1640 spin_lock_irq(&lp->lock);
1641 amd8111e_disable_interrupt(lp);
1642 spin_unlock_irq(&lp->lock);
1643
1644 netif_device_detach(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001645
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 /* stop chip */
1647 spin_lock_irq(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001648 if(lp->options & OPTION_DYN_IPG_ENABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 del_timer_sync(&lp->ipg_data.ipg_timer);
1650 amd8111e_stop_chip(lp);
1651 spin_unlock_irq(&lp->lock);
1652
1653 if(lp->options & OPTION_WOL_ENABLE){
1654 /* enable wol */
1655 if(lp->options & OPTION_WAKE_MAGIC_ENABLE)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001656 amd8111e_enable_magicpkt(lp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 if(lp->options & OPTION_WAKE_PHY_ENABLE)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001658 amd8111e_enable_link_change(lp);
1659
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 pci_enable_wake(pci_dev, PCI_D3hot, 1);
1661 pci_enable_wake(pci_dev, PCI_D3cold, 1);
1662
1663 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001664 else{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 pci_enable_wake(pci_dev, PCI_D3hot, 0);
1666 pci_enable_wake(pci_dev, PCI_D3cold, 0);
1667 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 pci_save_state(pci_dev);
1670 pci_set_power_state(pci_dev, PCI_D3hot);
1671
1672 return 0;
1673}
1674static int amd8111e_resume(struct pci_dev *pci_dev)
1675{
1676 struct net_device *dev = pci_get_drvdata(pci_dev);
1677 struct amd8111e_priv *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001678
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (!netif_running(dev))
1680 return 0;
1681
1682 pci_set_power_state(pci_dev, PCI_D0);
1683 pci_restore_state(pci_dev);
1684
1685 pci_enable_wake(pci_dev, PCI_D3hot, 0);
1686 pci_enable_wake(pci_dev, PCI_D3cold, 0); /* D3 cold */
1687
1688 netif_device_attach(dev);
1689
1690 spin_lock_irq(&lp->lock);
1691 amd8111e_restart(dev);
1692 /* Restart ipg timer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001693 if(lp->options & OPTION_DYN_IPG_ENABLE)
1694 mod_timer(&lp->ipg_data.ipg_timer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 jiffies + IPG_CONVERGE_JIFFIES);
1696 spin_unlock_irq(&lp->lock);
1697
1698 return 0;
1699}
1700
1701
Bill Pemberton0cb05682012-12-03 09:23:54 -05001702static void amd8111e_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
1704 struct net_device *dev = pci_get_drvdata(pdev);
1705 if (dev) {
1706 unregister_netdev(dev);
1707 iounmap(((struct amd8111e_priv *)netdev_priv(dev))->mmio);
1708 free_netdev(dev);
1709 pci_release_regions(pdev);
1710 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 }
1712}
1713static void amd8111e_config_ipg(struct net_device* dev)
1714{
1715 struct amd8111e_priv *lp = netdev_priv(dev);
1716 struct ipg_info* ipg_data = &lp->ipg_data;
1717 void __iomem *mmio = lp->mmio;
1718 unsigned int prev_col_cnt = ipg_data->col_cnt;
1719 unsigned int total_col_cnt;
1720 unsigned int tmp_ipg;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001721
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 if(lp->link_config.duplex == DUPLEX_FULL){
1723 ipg_data->ipg = DEFAULT_IPG;
1724 return;
1725 }
1726
1727 if(ipg_data->ipg_state == SSTATE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001728
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 if(ipg_data->timer_tick == IPG_STABLE_TIME){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001730
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 ipg_data->timer_tick = 0;
1732 ipg_data->ipg = MIN_IPG - IPG_STEP;
1733 ipg_data->current_ipg = MIN_IPG;
1734 ipg_data->diff_col_cnt = 0xFFFFFFFF;
1735 ipg_data->ipg_state = CSTATE;
1736 }
1737 else
1738 ipg_data->timer_tick++;
1739 }
1740
1741 if(ipg_data->ipg_state == CSTATE){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001742
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 /* Get the current collision count */
1744
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001745 total_col_cnt = ipg_data->col_cnt =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 amd8111e_read_mib(mmio, xmt_collisions);
1747
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001748 if ((total_col_cnt - prev_col_cnt) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 (ipg_data->diff_col_cnt)){
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001750
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 ipg_data->diff_col_cnt =
1752 total_col_cnt - prev_col_cnt ;
1753
1754 ipg_data->ipg = ipg_data->current_ipg;
1755 }
1756
1757 ipg_data->current_ipg += IPG_STEP;
1758
1759 if (ipg_data->current_ipg <= MAX_IPG)
1760 tmp_ipg = ipg_data->current_ipg;
1761 else{
1762 tmp_ipg = ipg_data->ipg;
1763 ipg_data->ipg_state = SSTATE;
1764 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001765 writew((u32)tmp_ipg, mmio + IPG);
1766 writew((u32)(tmp_ipg - IFS1_DELTA), mmio + IFS1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 }
1768 mod_timer(&lp->ipg_data.ipg_timer, jiffies + IPG_CONVERGE_JIFFIES);
1769 return;
1770
1771}
1772
Bill Pemberton0cb05682012-12-03 09:23:54 -05001773static void amd8111e_probe_ext_phy(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774{
1775 struct amd8111e_priv *lp = netdev_priv(dev);
1776 int i;
1777
1778 for (i = 0x1e; i >= 0; i--) {
1779 u32 id1, id2;
1780
1781 if (amd8111e_read_phy(lp, i, MII_PHYSID1, &id1))
1782 continue;
1783 if (amd8111e_read_phy(lp, i, MII_PHYSID2, &id2))
1784 continue;
1785 lp->ext_phy_id = (id1 << 16) | id2;
1786 lp->ext_phy_addr = i;
1787 return;
1788 }
1789 lp->ext_phy_id = 0;
1790 lp->ext_phy_addr = 1;
1791}
1792
Stephen Hemminger887e53d2009-01-07 18:09:58 -08001793static const struct net_device_ops amd8111e_netdev_ops = {
1794 .ndo_open = amd8111e_open,
1795 .ndo_stop = amd8111e_close,
1796 .ndo_start_xmit = amd8111e_start_xmit,
1797 .ndo_tx_timeout = amd8111e_tx_timeout,
1798 .ndo_get_stats = amd8111e_get_stats,
Jiri Pirkoafc4b132011-08-16 06:29:01 +00001799 .ndo_set_rx_mode = amd8111e_set_multicast_list,
Stephen Hemminger887e53d2009-01-07 18:09:58 -08001800 .ndo_validate_addr = eth_validate_addr,
1801 .ndo_set_mac_address = amd8111e_set_mac_address,
1802 .ndo_do_ioctl = amd8111e_ioctl,
1803 .ndo_change_mtu = amd8111e_change_mtu,
Stephen Hemminger887e53d2009-01-07 18:09:58 -08001804#ifdef CONFIG_NET_POLL_CONTROLLER
1805 .ndo_poll_controller = amd8111e_poll,
1806#endif
1807};
1808
Bill Pemberton0cb05682012-12-03 09:23:54 -05001809static int amd8111e_probe_one(struct pci_dev *pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 const struct pci_device_id *ent)
1811{
Yijing Wangf9c7da52013-06-18 16:06:37 +08001812 int err, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 unsigned long reg_addr,reg_len;
1814 struct amd8111e_priv* lp;
1815 struct net_device* dev;
1816
1817 err = pci_enable_device(pdev);
1818 if(err){
Joe Perches24500222007-11-19 17:48:28 -08001819 printk(KERN_ERR "amd8111e: Cannot enable new PCI device, "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 "exiting.\n");
1821 return err;
1822 }
1823
1824 if(!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)){
Joe Perches24500222007-11-19 17:48:28 -08001825 printk(KERN_ERR "amd8111e: Cannot find PCI base address, "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 "exiting.\n");
1827 err = -ENODEV;
1828 goto err_disable_pdev;
1829 }
1830
1831 err = pci_request_regions(pdev, MODULE_NAME);
1832 if(err){
1833 printk(KERN_ERR "amd8111e: Cannot obtain PCI resources, "
1834 "exiting.\n");
1835 goto err_disable_pdev;
1836 }
1837
1838 pci_set_master(pdev);
1839
1840 /* Find power-management capability. */
Yijing Wangf9c7da52013-06-18 16:06:37 +08001841 if (!pdev->pm_cap) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 printk(KERN_ERR "amd8111e: No Power Management capability, "
1843 "exiting.\n");
Peter Senna Tschudin86e506e2012-10-05 12:10:51 +00001844 err = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 goto err_free_reg;
1846 }
1847
1848 /* Initialize DMA */
Yang Hongyang284901a2009-04-06 19:01:15 -07001849 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 printk(KERN_ERR "amd8111e: DMA not supported,"
1851 "exiting.\n");
Peter Senna Tschudin86e506e2012-10-05 12:10:51 +00001852 err = -ENODEV;
Tobias Klausercac8c812005-05-16 19:15:11 +02001853 goto err_free_reg;
1854 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 reg_addr = pci_resource_start(pdev, 0);
1857 reg_len = pci_resource_len(pdev, 0);
1858
1859 dev = alloc_etherdev(sizeof(struct amd8111e_priv));
1860 if (!dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 err = -ENOMEM;
1862 goto err_free_reg;
1863 }
1864
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 SET_NETDEV_DEV(dev, &pdev->dev);
1866
1867#if AMD8111E_VLAN_TAG_USED
Patrick McHardyf6469682013-04-19 02:04:27 +00001868 dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX ;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001869#endif
1870
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 lp = netdev_priv(dev);
1872 lp->pci_dev = pdev;
1873 lp->amd8111e_net_dev = dev;
Yijing Wangf9c7da52013-06-18 16:06:37 +08001874 lp->pm_cap = pdev->pm_cap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
1876 spin_lock_init(&lp->lock);
1877
1878 lp->mmio = ioremap(reg_addr, reg_len);
Al Viroee41a822007-08-22 21:37:46 -04001879 if (!lp->mmio) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 printk(KERN_ERR "amd8111e: Cannot map device registers, "
1881 "exiting\n");
1882 err = -ENOMEM;
1883 goto err_free_dev;
1884 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001885
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 /* Initializing MAC address */
Joe Perchesc857ff62011-11-16 09:38:05 +00001887 for (i = 0; i < ETH_ALEN; i++)
Joe Perches0795af52007-10-03 17:59:30 -07001888 dev->dev_addr[i] = readb(lp->mmio + PADR + i);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001889
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 /* Setting user defined parametrs */
1891 lp->ext_phy_option = speed_duplex[card_idx];
1892 if(coalesce[card_idx])
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001893 lp->options |= OPTION_INTR_COAL_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 if(dynamic_ipg[card_idx++])
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001895 lp->options |= OPTION_DYN_IPG_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
Stephen Hemminger887e53d2009-01-07 18:09:58 -08001897
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 /* Initialize driver entry points */
Stephen Hemminger887e53d2009-01-07 18:09:58 -08001899 dev->netdev_ops = &amd8111e_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 SET_ETHTOOL_OPS(dev, &ops);
1901 dev->irq =pdev->irq;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001902 dev->watchdog_timeo = AMD8111E_TX_TIMEOUT;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001903 netif_napi_add(dev, &lp->napi, amd8111e_rx_poll, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
1905#if AMD8111E_VLAN_TAG_USED
Patrick McHardyf6469682013-04-19 02:04:27 +00001906 dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001907#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 /* Probe the external PHY */
1909 amd8111e_probe_ext_phy(dev);
1910
1911 /* setting mii default values */
1912 lp->mii_if.dev = dev;
1913 lp->mii_if.mdio_read = amd8111e_mdio_read;
1914 lp->mii_if.mdio_write = amd8111e_mdio_write;
1915 lp->mii_if.phy_id = lp->ext_phy_addr;
1916
1917 /* Set receive buffer length and set jumbo option*/
1918 amd8111e_set_rx_buff_len(dev);
1919
1920
1921 err = register_netdev(dev);
1922 if (err) {
1923 printk(KERN_ERR "amd8111e: Cannot register net device, "
1924 "exiting.\n");
1925 goto err_iounmap;
1926 }
1927
1928 pci_set_drvdata(pdev, dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001929
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 /* Initialize software ipg timer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001931 if(lp->options & OPTION_DYN_IPG_ENABLE){
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 init_timer(&lp->ipg_data.ipg_timer);
1933 lp->ipg_data.ipg_timer.data = (unsigned long) dev;
1934 lp->ipg_data.ipg_timer.function = (void *)&amd8111e_config_ipg;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001935 lp->ipg_data.ipg_timer.expires = jiffies +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 IPG_CONVERGE_JIFFIES;
1937 lp->ipg_data.ipg = DEFAULT_IPG;
1938 lp->ipg_data.ipg_state = CSTATE;
Joe Perches6403eab2011-06-03 11:51:20 +00001939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
1941 /* display driver and device information */
1942
1943 chip_version = (readl(lp->mmio + CHIPID) & 0xf0000000)>>28;
Joe Perches0795af52007-10-03 17:59:30 -07001944 printk(KERN_INFO "%s: AMD-8111e Driver Version: %s\n",
1945 dev->name,MODULE_VERS);
Johannes Berge1749612008-10-27 15:59:26 -07001946 printk(KERN_INFO "%s: [ Rev %x ] PCI 10/100BaseT Ethernet %pM\n",
1947 dev->name, chip_version, dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 if (lp->ext_phy_id)
1949 printk(KERN_INFO "%s: Found MII PHY ID 0x%08x at address 0x%02x\n",
1950 dev->name, lp->ext_phy_id, lp->ext_phy_addr);
1951 else
1952 printk(KERN_INFO "%s: Couldn't detect MII PHY, assuming address 0x01\n",
1953 dev->name);
1954 return 0;
1955err_iounmap:
1956 iounmap(lp->mmio);
1957
1958err_free_dev:
1959 free_netdev(dev);
1960
1961err_free_reg:
1962 pci_release_regions(pdev);
1963
1964err_disable_pdev:
1965 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 return err;
1967
1968}
1969
1970static struct pci_driver amd8111e_driver = {
1971 .name = MODULE_NAME,
1972 .id_table = amd8111e_pci_tbl,
1973 .probe = amd8111e_probe_one,
Bill Pemberton0cb05682012-12-03 09:23:54 -05001974 .remove = amd8111e_remove_one,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 .suspend = amd8111e_suspend,
1976 .resume = amd8111e_resume
1977};
1978
Peter Hüwea46e6cc2013-05-21 12:58:10 +00001979module_pci_driver(amd8111e_driver);