1 /******************************************************************************

     2  *

     3  *  $Id$

     4  *

     5  *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6  *

     7  *  This file is part of the IgH EtherCAT Master.

     8  *

     9  *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10  *  modify it under the terms of the GNU General Public License version 2, as

    11  *  published by the Free Software Foundation.

    12  *

    13  *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16  *  Public License for more details.

    17  *

    18  *  You should have received a copy of the GNU General Public License along

    19  *  with the IgH EtherCAT Master; if not, write to the Free Software

    20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21  *

    22  *  ---

    23  *

    24  *  The license mentioned above concerns the source code only. Using the

    25  *  EtherCAT technology and brand is only permitted in compliance with the

    26  *  industrial property and similar rights of Beckhoff Automation GmbH.

    27  *

    28  *****************************************************************************/

    29 

    30 /**

    31    \file

    32    EtherCAT driver for RTL8139-compatible NICs.

    33 */

    34 

    35 /*****************************************************************************/

    36 

    37 /*

    38   Former documentation:

    39 

    40 	8139too.c: A RealTek RTL-8139 Fast Ethernet driver for Linux.

    41 

    42 	Maintained by Jeff Garzik <jgarzik@pobox.com>

    43 	Copyright 2000-2002 Jeff Garzik

    44 

    45 	Much code comes from Donald Becker's rtl8139.c driver,

    46 	versions 1.13 and older.  This driver was originally based

    47 	on rtl8139.c version 1.07.  Header of rtl8139.c version 1.13:

    48 

    49 	-----<snip>-----

    50 

    51         	Written 1997-2001 by Donald Becker.

    52 		This software may be used and distributed according to the

    53 		terms of the GNU General Public License (GPL), incorporated

    54 		herein by reference.  Drivers based on or derived from this

    55 		code fall under the GPL and must retain the authorship,

    56 		copyright and license notice.  This file is not a complete

    57 		program and may only be used when the entire operating

    58 		system is licensed under the GPL.

    59 

    60 		This driver is for boards based on the RTL8129 and RTL8139

    61 		PCI ethernet chips.

    62 

    63 		The author may be reached as becker@scyld.com, or C/O Scyld

    64 		Computing Corporation 410 Severn Ave., Suite 210 Annapolis

    65 		MD 21403

    66 

    67 		Support and updates available at

    68 		http://www.scyld.com/network/rtl8139.html

    69 

    70 		Twister-tuning table provided by Kinston

    71 		<shangh@realtek.com.tw>.

    72 

    73 	-----<snip>-----

    74 

    75 	This software may be used and distributed according to the terms

    76 	of the GNU General Public License, incorporated herein by reference.

    77 

    78 	Contributors:

    79 

    80 		Donald Becker - he wrote the original driver, kudos to him!

    81 		(but please don't e-mail him for support, this isn't his driver)

    82 

    83 		Tigran Aivazian - bug fixes, skbuff free cleanup

    84 

    85 		Martin Mares - suggestions for PCI cleanup

    86 

    87 		David S. Miller - PCI DMA and softnet updates

    88 

    89 		Ernst Gill - fixes ported from BSD driver

    90 

    91 		Daniel Kobras - identified specific locations of

    92 			posted MMIO write bugginess

    93 

    94 		Gerard Sharp - bug fix, testing and feedback

    95 

    96 		David Ford - Rx ring wrap fix

    97 

    98 		Dan DeMaggio - swapped RTL8139 cards with me, and allowed me

    99 		to find and fix a crucial bug on older chipsets.

   100 

   101 		Donald Becker/Chris Butterworth/Marcus Westergren -

   102 		Noticed various Rx packet size-related buglets.

   103 

   104 		Santiago Garcia Mantinan - testing and feedback

   105 

   106 		Jens David - 2.2.x kernel backports

   107 

   108 		Martin Dennett - incredibly helpful insight on undocumented

   109 		features of the 8139 chips

   110 

   111 		Jean-Jacques Michel - bug fix

   112 

   113 		Tobias Ringström - Rx interrupt status checking suggestion

   114 

   115 		Andrew Morton - Clear blocked signals, avoid

   116 		buffer overrun setting current->comm.

   117 

   118 		Kalle Olavi Niemitalo - Wake-on-LAN ioctls

   119 

   120 		Robert Kuebel - Save kernel thread from dying on any signal.

   121 

   122 	Submitting bug reports:

   123 

   124 		"rtl8139-diag -mmmaaavvveefN" output

   125 		enable RTL8139_DEBUG below, and look at 'dmesg' or kernel log

   126 

   127 */

   128 

   129 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

   130 

   131 #define DRV_NAME	"ec_8139too"

   132 #define DRV_VERSION	"0.9.28"

   133 

   134 

   135 #include <linux/module.h>

   136 #include <linux/kernel.h>

   137 #include <linux/compiler.h>

   138 #include <linux/pci.h>

   139 #include <linux/init.h>

   140 #include <linux/interrupt.h>

   141 #include <linux/netdevice.h>

   142 #include <linux/etherdevice.h>

   143 #include <linux/rtnetlink.h>

   144 #include <linux/delay.h>

   145 #include <linux/ethtool.h>

   146 #include <linux/mii.h>

   147 #include <linux/completion.h>

   148 #include <linux/crc32.h>

   149 #include <linux/io.h>

   150 #include <linux/uaccess.h>

   151 #include <linux/gfp.h>

   152 #include <asm/irq.h>

   153 

   154 #include "../globals.h"

   155 #include "ecdev.h"

   156 

   157 #define RTL8139_DRIVER_NAME DRV_NAME \

   158                             " EtherCAT-capable Fast Ethernet driver " \

   159                             DRV_VERSION ", master " EC_MASTER_VERSION

   160 

   161 #define PFX DRV_NAME ": "

   162 

   163 /* Default Message level */

   164 #define RTL8139_DEF_MSG_ENABLE   (NETIF_MSG_DRV   | \

   165                                  NETIF_MSG_PROBE  | \

   166                                  NETIF_MSG_LINK)

   167 

   168 

   169 /* define to 1, 2 or 3 to enable copious debugging info */

   170 #define RTL8139_DEBUG 0

   171 

   172 /* define to 1 to disable lightweight runtime debugging checks */

   173 #undef RTL8139_NDEBUG

   174 

   175 

   176 #ifdef RTL8139_NDEBUG

   177 #  define assert(expr) do {} while (0)

   178 #else

   179 #  define assert(expr) \

   180         if (unlikely(!(expr))) {				\

   181 		pr_err("Assertion failed! %s,%s,%s,line=%d\n",	\

   182 		       #expr, __FILE__, __func__, __LINE__);	\

   183         }

   184 #endif

   185 

   186 

   187 /* A few user-configurable values. */

   188 /* media options */

   189 #define MAX_UNITS 8

   190 static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

   191 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

   192 

   193 /* Whether to use MMIO or PIO. Default to MMIO. */

   194 #ifdef CONFIG_8139TOO_PIO

   195 static int use_io = 1;

   196 #else

   197 static int use_io = 0;

   198 #endif

   199 

   200 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).

   201    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */

   202 static int multicast_filter_limit = 32;

   203 

   204 /* bitmapped message enable number */

   205 static int debug = -1;

   206 

   207 /*

   208  * Receive ring size

   209  * Warning: 64K ring has hardware issues and may lock up.

   210  */

   211 #if defined(CONFIG_SH_DREAMCAST)

   212 #define RX_BUF_IDX 0	/* 8K ring */

   213 #else

   214 #define RX_BUF_IDX	2	/* 32K ring */

   215 #endif

   216 #define RX_BUF_LEN	(8192 << RX_BUF_IDX)

   217 #define RX_BUF_PAD	16

   218 #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */

   219 

   220 #if RX_BUF_LEN == 65536

   221 #define RX_BUF_TOT_LEN	RX_BUF_LEN

   222 #else

   223 #define RX_BUF_TOT_LEN	(RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)

   224 #endif

   225 

   226 /* Number of Tx descriptor registers. */

   227 #define NUM_TX_DESC	4

   228 

   229 /* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/

   230 #define MAX_ETH_FRAME_SIZE	1536

   231 

   232 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */

   233 #define TX_BUF_SIZE	MAX_ETH_FRAME_SIZE

   234 #define TX_BUF_TOT_LEN	(TX_BUF_SIZE * NUM_TX_DESC)

   235 

   236 /* PCI Tuning Parameters

   237    Threshold is bytes transferred to chip before transmission starts. */

   238 #define TX_FIFO_THRESH 256	/* In bytes, rounded down to 32 byte units. */

   239 

   240 /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024, 7==end of packet. */

   241 #define RX_FIFO_THRESH	7	/* Rx buffer level before first PCI xfer.  */

   242 #define RX_DMA_BURST	7	/* Maximum PCI burst, '6' is 1024 */

   243 #define TX_DMA_BURST	6	/* Maximum PCI burst, '6' is 1024 */

   244 #define TX_RETRY	8	/* 0-15.  retries = 16 + (TX_RETRY * 16) */

   245 

   246 /* Operational parameters that usually are not changed. */

   247 /* Time in jiffies before concluding the transmitter is hung. */

   248 #define TX_TIMEOUT  (6*HZ)

   249 

   250 

   251 enum {

   252 	HAS_MII_XCVR = 0x010000,

   253 	HAS_CHIP_XCVR = 0x020000,

   254 	HAS_LNK_CHNG = 0x040000,

   255 };

   256 

   257 #define RTL_NUM_STATS 4		/* number of ETHTOOL_GSTATS u64's */

   258 #define RTL_REGS_VER 1		/* version of reg. data in ETHTOOL_GREGS */

   259 #define RTL_MIN_IO_SIZE 0x80

   260 #define RTL8139B_IO_SIZE 256

   261 

   262 #define RTL8129_CAPS	HAS_MII_XCVR

   263 #define RTL8139_CAPS	(HAS_CHIP_XCVR|HAS_LNK_CHNG)

   264 

   265 typedef enum {

   266 	RTL8139 = 0,

   267 	RTL8129,

   268 } board_t;

   269 

   270 

   271 /* indexed by board_t, above */

   272 static const struct {

   273 	const char *name;

   274 	u32 hw_flags;

   275 } board_info[] __devinitdata = {

   276 	{ "RealTek RTL8139", RTL8139_CAPS },

   277 	{ "RealTek RTL8129", RTL8129_CAPS },

   278 };

   279 

   280 

   281 static DEFINE_PCI_DEVICE_TABLE(rtl8139_pci_tbl) = {

   282 	{0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   283 	{0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   284 	{0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   285 	{0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   286 	{0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   287 	{0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   288 	{0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   289 	{0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   290 	{0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   291 	{0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   292 	{0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   293 	{0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   294 	{0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   295 	{0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   296 	{0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   297 	{0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   298 	{0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   299 	{0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   300 	{0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   301 

   302 #ifdef CONFIG_SH_SECUREEDGE5410

   303 	/* Bogus 8139 silicon reports 8129 without external PROM :-( */

   304 	{0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },

   305 #endif

   306 #ifdef CONFIG_8139TOO_8129

   307 	{0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },

   308 #endif

   309 

   310 	/* some crazy cards report invalid vendor ids like

   311 	 * 0x0001 here.  The other ids are valid and constant,

   312 	 * so we simply don't match on the main vendor id.

   313 	 */

   314 	{PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },

   315 	{PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },

   316 	{PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },

   317 

   318 	{0,}

   319 };

   320 

   321 /* prevent driver from being loaded automatically */

   322 //MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);

   323 

   324 static struct {

   325 	const char str[ETH_GSTRING_LEN];

   326 } ethtool_stats_keys[] = {

   327 	{ "early_rx" },

   328 	{ "tx_buf_mapped" },

   329 	{ "tx_timeouts" },

   330 	{ "rx_lost_in_ring" },

   331 };

   332 

   333 /* The rest of these values should never change. */

   334 

   335 /* Symbolic offsets to registers. */

   336 enum RTL8139_registers {

   337 	MAC0		= 0,	 /* Ethernet hardware address. */

   338 	MAR0		= 8,	 /* Multicast filter. */

   339 	TxStatus0	= 0x10,	 /* Transmit status (Four 32bit registers). */

   340 	TxAddr0		= 0x20,	 /* Tx descriptors (also four 32bit). */

   341 	RxBuf		= 0x30,

   342 	ChipCmd		= 0x37,

   343 	RxBufPtr	= 0x38,

   344 	RxBufAddr	= 0x3A,

   345 	IntrMask	= 0x3C,

   346 	IntrStatus	= 0x3E,

   347 	TxConfig	= 0x40,

   348 	RxConfig	= 0x44,

   349 	Timer		= 0x48,	 /* A general-purpose counter. */

   350 	RxMissed	= 0x4C,  /* 24 bits valid, write clears. */

   351 	Cfg9346		= 0x50,

   352 	Config0		= 0x51,

   353 	Config1		= 0x52,

   354 	TimerInt	= 0x54,

   355 	MediaStatus	= 0x58,

   356 	Config3		= 0x59,

   357 	Config4		= 0x5A,	 /* absent on RTL-8139A */

   358 	HltClk		= 0x5B,

   359 	MultiIntr	= 0x5C,

   360 	TxSummary	= 0x60,

   361 	BasicModeCtrl	= 0x62,

   362 	BasicModeStatus	= 0x64,

   363 	NWayAdvert	= 0x66,

   364 	NWayLPAR	= 0x68,

   365 	NWayExpansion	= 0x6A,

   366 	/* Undocumented registers, but required for proper operation. */

   367 	FIFOTMS		= 0x70,	 /* FIFO Control and test. */

   368 	CSCR		= 0x74,	 /* Chip Status and Configuration Register. */

   369 	PARA78		= 0x78,

   370 	FlashReg	= 0xD4,	/* Communication with Flash ROM, four bytes. */

   371 	PARA7c		= 0x7c,	 /* Magic transceiver parameter register. */

   372 	Config5		= 0xD8,	 /* absent on RTL-8139A */

   373 };

   374 

   375 enum ClearBitMasks {

   376 	MultiIntrClear	= 0xF000,

   377 	ChipCmdClear	= 0xE2,

   378 	Config1Clear	= (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),

   379 };

   380 

   381 enum ChipCmdBits {

   382 	CmdReset	= 0x10,

   383 	CmdRxEnb	= 0x08,

   384 	CmdTxEnb	= 0x04,

   385 	RxBufEmpty	= 0x01,

   386 };

   387 

   388 /* Interrupt register bits, using my own meaningful names. */

   389 enum IntrStatusBits {

   390 	PCIErr		= 0x8000,

   391 	PCSTimeout	= 0x4000,

   392 	RxFIFOOver	= 0x40,

   393 	RxUnderrun	= 0x20,

   394 	RxOverflow	= 0x10,

   395 	TxErr		= 0x08,

   396 	TxOK		= 0x04,

   397 	RxErr		= 0x02,

   398 	RxOK		= 0x01,

   399 

   400 	RxAckBits	= RxFIFOOver | RxOverflow | RxOK,

   401 };

   402 

   403 enum TxStatusBits {

   404 	TxHostOwns	= 0x2000,

   405 	TxUnderrun	= 0x4000,

   406 	TxStatOK	= 0x8000,

   407 	TxOutOfWindow	= 0x20000000,

   408 	TxAborted	= 0x40000000,

   409 	TxCarrierLost	= 0x80000000,

   410 };

   411 enum RxStatusBits {

   412 	RxMulticast	= 0x8000,

   413 	RxPhysical	= 0x4000,

   414 	RxBroadcast	= 0x2000,

   415 	RxBadSymbol	= 0x0020,

   416 	RxRunt		= 0x0010,

   417 	RxTooLong	= 0x0008,

   418 	RxCRCErr	= 0x0004,

   419 	RxBadAlign	= 0x0002,

   420 	RxStatusOK	= 0x0001,

   421 };

   422 

   423 /* Bits in RxConfig. */

   424 enum rx_mode_bits {

   425 	AcceptErr	= 0x20,

   426 	AcceptRunt	= 0x10,

   427 	AcceptBroadcast	= 0x08,

   428 	AcceptMulticast	= 0x04,

   429 	AcceptMyPhys	= 0x02,

   430 	AcceptAllPhys	= 0x01,

   431 };

   432 

   433 /* Bits in TxConfig. */

   434 enum tx_config_bits {

   435         /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */

   436         TxIFGShift	= 24,

   437         TxIFG84		= (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */

   438         TxIFG88		= (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */

   439         TxIFG92		= (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */

   440         TxIFG96		= (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */

   441 

   442 	TxLoopBack	= (1 << 18) | (1 << 17), /* enable loopback test mode */

   443 	TxCRC		= (1 << 16),	/* DISABLE Tx pkt CRC append */

   444 	TxClearAbt	= (1 << 0),	/* Clear abort (WO) */

   445 	TxDMAShift	= 8, /* DMA burst value (0-7) is shifted X many bits */

   446 	TxRetryShift	= 4, /* TXRR value (0-15) is shifted X many bits */

   447 

   448 	TxVersionMask	= 0x7C800000, /* mask out version bits 30-26, 23 */

   449 };

   450 

   451 /* Bits in Config1 */

   452 enum Config1Bits {

   453 	Cfg1_PM_Enable	= 0x01,

   454 	Cfg1_VPD_Enable	= 0x02,

   455 	Cfg1_PIO	= 0x04,

   456 	Cfg1_MMIO	= 0x08,

   457 	LWAKE		= 0x10,		/* not on 8139, 8139A */

   458 	Cfg1_Driver_Load = 0x20,

   459 	Cfg1_LED0	= 0x40,

   460 	Cfg1_LED1	= 0x80,

   461 	SLEEP		= (1 << 1),	/* only on 8139, 8139A */

   462 	PWRDN		= (1 << 0),	/* only on 8139, 8139A */

   463 };

   464 

   465 /* Bits in Config3 */

   466 enum Config3Bits {

   467 	Cfg3_FBtBEn   	= (1 << 0), /* 1	= Fast Back to Back */

   468 	Cfg3_FuncRegEn	= (1 << 1), /* 1	= enable CardBus Function registers */

   469 	Cfg3_CLKRUN_En	= (1 << 2), /* 1	= enable CLKRUN */

   470 	Cfg3_CardB_En 	= (1 << 3), /* 1	= enable CardBus registers */

   471 	Cfg3_LinkUp   	= (1 << 4), /* 1	= wake up on link up */

   472 	Cfg3_Magic    	= (1 << 5), /* 1	= wake up on Magic Packet (tm) */

   473 	Cfg3_PARM_En  	= (1 << 6), /* 0	= software can set twister parameters */

   474 	Cfg3_GNTSel   	= (1 << 7), /* 1	= delay 1 clock from PCI GNT signal */

   475 };

   476 

   477 /* Bits in Config4 */

   478 enum Config4Bits {

   479 	LWPTN	= (1 << 2),	/* not on 8139, 8139A */

   480 };

   481 

   482 /* Bits in Config5 */

   483 enum Config5Bits {

   484 	Cfg5_PME_STS   	= (1 << 0), /* 1	= PCI reset resets PME_Status */

   485 	Cfg5_LANWake   	= (1 << 1), /* 1	= enable LANWake signal */

   486 	Cfg5_LDPS      	= (1 << 2), /* 0	= save power when link is down */

   487 	Cfg5_FIFOAddrPtr= (1 << 3), /* Realtek internal SRAM testing */

   488 	Cfg5_UWF        = (1 << 4), /* 1 = accept unicast wakeup frame */

   489 	Cfg5_MWF        = (1 << 5), /* 1 = accept multicast wakeup frame */

   490 	Cfg5_BWF        = (1 << 6), /* 1 = accept broadcast wakeup frame */

   491 };

   492 

   493 enum RxConfigBits {

   494 	/* rx fifo threshold */

   495 	RxCfgFIFOShift	= 13,

   496 	RxCfgFIFONone	= (7 << RxCfgFIFOShift),

   497 

   498 	/* Max DMA burst */

   499 	RxCfgDMAShift	= 8,

   500 	RxCfgDMAUnlimited = (7 << RxCfgDMAShift),

   501 

   502 	/* rx ring buffer length */

   503 	RxCfgRcv8K	= 0,

   504 	RxCfgRcv16K	= (1 << 11),

   505 	RxCfgRcv32K	= (1 << 12),

   506 	RxCfgRcv64K	= (1 << 11) | (1 << 12),

   507 

   508 	/* Disable packet wrap at end of Rx buffer. (not possible with 64k) */

   509 	RxNoWrap	= (1 << 7),

   510 };

   511 

   512 /* Twister tuning parameters from RealTek.

   513    Completely undocumented, but required to tune bad links on some boards. */

   514 enum CSCRBits {

   515 	CSCR_LinkOKBit		= 0x0400,

   516 	CSCR_LinkChangeBit	= 0x0800,

   517 	CSCR_LinkStatusBits	= 0x0f000,

   518 	CSCR_LinkDownOffCmd	= 0x003c0,

   519 	CSCR_LinkDownCmd	= 0x0f3c0,

   520 };

   521 

   522 enum Cfg9346Bits {

   523 	Cfg9346_Lock	= 0x00,

   524 	Cfg9346_Unlock	= 0xC0,

   525 };

   526 

   527 typedef enum {

   528 	CH_8139	= 0,

   529 	CH_8139_K,

   530 	CH_8139A,

   531 	CH_8139A_G,

   532 	CH_8139B,

   533 	CH_8130,

   534 	CH_8139C,

   535 	CH_8100,

   536 	CH_8100B_8139D,

   537 	CH_8101,

   538 } chip_t;

   539 

   540 enum chip_flags {

   541 	HasHltClk	= (1 << 0),

   542 	HasLWake	= (1 << 1),

   543 };

   544 

   545 #define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \

   546 	(b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)

   547 #define HW_REVID_MASK	HW_REVID(1, 1, 1, 1, 1, 1, 1)

   548 

   549 /* directly indexed by chip_t, above */

   550 static const struct {

   551 	const char *name;

   552 	u32 version; /* from RTL8139C/RTL8139D docs */

   553 	u32 flags;

   554 } rtl_chip_info[] = {

   555 	{ "RTL-8139",

   556 	  HW_REVID(1, 0, 0, 0, 0, 0, 0),

   557 	  HasHltClk,

   558 	},

   559 

   560 	{ "RTL-8139 rev K",

   561 	  HW_REVID(1, 1, 0, 0, 0, 0, 0),

   562 	  HasHltClk,

   563 	},

   564 

   565 	{ "RTL-8139A",

   566 	  HW_REVID(1, 1, 1, 0, 0, 0, 0),

   567 	  HasHltClk, /* XXX undocumented? */

   568 	},

   569 

   570 	{ "RTL-8139A rev G",

   571 	  HW_REVID(1, 1, 1, 0, 0, 1, 0),

   572 	  HasHltClk, /* XXX undocumented? */

   573 	},

   574 

   575 	{ "RTL-8139B",

   576 	  HW_REVID(1, 1, 1, 1, 0, 0, 0),

   577 	  HasLWake,

   578 	},

   579 

   580 	{ "RTL-8130",

   581 	  HW_REVID(1, 1, 1, 1, 1, 0, 0),

   582 	  HasLWake,

   583 	},

   584 

   585 	{ "RTL-8139C",

   586 	  HW_REVID(1, 1, 1, 0, 1, 0, 0),

   587 	  HasLWake,

   588 	},

   589 

   590 	{ "RTL-8100",

   591 	  HW_REVID(1, 1, 1, 1, 0, 1, 0),

   592  	  HasLWake,

   593  	},

   594 

   595 	{ "RTL-8100B/8139D",

   596 	  HW_REVID(1, 1, 1, 0, 1, 0, 1),

   597 	  HasHltClk /* XXX undocumented? */

   598 	| HasLWake,

   599 	},

   600 

   601 	{ "RTL-8101",

   602 	  HW_REVID(1, 1, 1, 0, 1, 1, 1),

   603 	  HasLWake,

   604 	},

   605 };

   606 

   607 struct rtl_extra_stats {

   608 	unsigned long early_rx;

   609 	unsigned long tx_buf_mapped;

   610 	unsigned long tx_timeouts;

   611 	unsigned long rx_lost_in_ring;

   612 };

   613 

   614 struct rtl8139_private {

   615 	void __iomem		*mmio_addr;

   616 	int			drv_flags;

   617 	struct pci_dev		*pci_dev;

   618 	u32			msg_enable;

   619 	struct napi_struct	napi;

   620 	struct net_device	*dev;

   621 

   622 	unsigned char		*rx_ring;

   623 	unsigned int		cur_rx;	/* RX buf index of next pkt */

   624 	dma_addr_t		rx_ring_dma;

   625 

   626 	unsigned int		tx_flag;

   627 	unsigned long		cur_tx;

   628 	unsigned long		dirty_tx;

   629 	unsigned char		*tx_buf[NUM_TX_DESC];	/* Tx bounce buffers */

   630 	unsigned char		*tx_bufs;	/* Tx bounce buffer region. */

   631 	dma_addr_t		tx_bufs_dma;

   632 

   633 	signed char		phys[4];	/* MII device addresses. */

   634 

   635 				/* Twister tune state. */

   636 	char			twistie, twist_row, twist_col;

   637 

   638 	unsigned int		watchdog_fired : 1;

   639 	unsigned int		default_port : 4; /* Last dev->if_port value. */

   640 	unsigned int		have_thread : 1;

   641 

   642 	spinlock_t		lock;

   643 	spinlock_t		rx_lock;

   644 

   645 	chip_t			chipset;

   646 	u32			rx_config;

   647 	struct rtl_extra_stats	xstats;

   648 

   649 	struct delayed_work	thread;

   650 

   651 	struct mii_if_info	mii;

   652 	unsigned int		regs_len;

   653 	unsigned long		fifo_copy_timeout;

   654 

   655 	ec_device_t *ecdev;

   656 };

   657 

   658 MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

   659 MODULE_DESCRIPTION("RealTek RTL-8139 EtherCAT driver");

   660 MODULE_LICENSE("GPL");

   661 MODULE_VERSION(EC_MASTER_VERSION);

   662 

   663 module_param(use_io, int, 0);

   664 MODULE_PARM_DESC(use_io, "Force use of I/O access mode. 0=MMIO 1=PIO");

   665 module_param(multicast_filter_limit, int, 0);

   666 module_param_array(media, int, NULL, 0);

   667 module_param_array(full_duplex, int, NULL, 0);

   668 module_param(debug, int, 0);

   669 MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");

   670 MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");

   671 MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");

   672 MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");

   673 

   674 void ec_poll(struct net_device *);

   675 

   676 static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);

   677 static int rtl8139_open (struct net_device *dev);

   678 static int mdio_read (struct net_device *dev, int phy_id, int location);

   679 static void mdio_write (struct net_device *dev, int phy_id, int location,

   680 			int val);

   681 static void rtl8139_start_thread(struct rtl8139_private *tp);

   682 static void rtl8139_tx_timeout (struct net_device *dev);

   683 static void rtl8139_init_ring (struct net_device *dev);

   684 static netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,

   685 				       struct net_device *dev);

   686 #ifdef CONFIG_NET_POLL_CONTROLLER

   687 static void rtl8139_poll_controller(struct net_device *dev);

   688 #endif

   689 static int rtl8139_set_mac_address(struct net_device *dev, void *p);

   690 static int rtl8139_poll(struct napi_struct *napi, int budget);

   691 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance);

   692 static int rtl8139_close (struct net_device *dev);

   693 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);

   694 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);

   695 static void rtl8139_set_rx_mode (struct net_device *dev);

   696 static void __set_rx_mode (struct net_device *dev);

   697 static void rtl8139_hw_start (struct net_device *dev);

   698 static void rtl8139_thread (struct work_struct *work);

   699 static void rtl8139_tx_timeout_task(struct work_struct *work);

   700 static const struct ethtool_ops rtl8139_ethtool_ops;

   701 

   702 /* write MMIO register, with flush */

   703 /* Flush avoids rtl8139 bug w/ posted MMIO writes */

   704 #define RTL_W8_F(reg, val8)	do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)

   705 #define RTL_W16_F(reg, val16)	do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)

   706 #define RTL_W32_F(reg, val32)	do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)

   707 

   708 /* write MMIO register */

   709 #define RTL_W8(reg, val8)	iowrite8 ((val8), ioaddr + (reg))

   710 #define RTL_W16(reg, val16)	iowrite16 ((val16), ioaddr + (reg))

   711 #define RTL_W32(reg, val32)	iowrite32 ((val32), ioaddr + (reg))

   712 

   713 /* read MMIO register */

   714 #define RTL_R8(reg)		ioread8 (ioaddr + (reg))

   715 #define RTL_R16(reg)		ioread16 (ioaddr + (reg))

   716 #define RTL_R32(reg)		ioread32 (ioaddr + (reg))

   717 

   718 

   719 static const u16 rtl8139_intr_mask =

   720 	PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |

   721 	TxErr | TxOK | RxErr | RxOK;

   722 

   723 static const u16 rtl8139_norx_intr_mask =

   724 	PCIErr | PCSTimeout | RxUnderrun |

   725 	TxErr | TxOK | RxErr ;

   726 

   727 #if RX_BUF_IDX == 0

   728 static const unsigned int rtl8139_rx_config =

   729 	RxCfgRcv8K | RxNoWrap |

   730 	(RX_FIFO_THRESH << RxCfgFIFOShift) |

   731 	(RX_DMA_BURST << RxCfgDMAShift);

   732 #elif RX_BUF_IDX == 1

   733 static const unsigned int rtl8139_rx_config =

   734 	RxCfgRcv16K | RxNoWrap |

   735 	(RX_FIFO_THRESH << RxCfgFIFOShift) |

   736 	(RX_DMA_BURST << RxCfgDMAShift);

   737 #elif RX_BUF_IDX == 2

   738 static const unsigned int rtl8139_rx_config =

   739 	RxCfgRcv32K | RxNoWrap |

   740 	(RX_FIFO_THRESH << RxCfgFIFOShift) |

   741 	(RX_DMA_BURST << RxCfgDMAShift);

   742 #elif RX_BUF_IDX == 3

   743 static const unsigned int rtl8139_rx_config =

   744 	RxCfgRcv64K |

   745 	(RX_FIFO_THRESH << RxCfgFIFOShift) |

   746 	(RX_DMA_BURST << RxCfgDMAShift);

   747 #else

   748 #error "Invalid configuration for 8139_RXBUF_IDX"

   749 #endif

   750 

   751 static const unsigned int rtl8139_tx_config =

   752 	TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);

   753 

   754 static void __rtl8139_cleanup_dev (struct net_device *dev)

   755 {

   756 	struct rtl8139_private *tp = netdev_priv(dev);

   757 	struct pci_dev *pdev;

   758 

   759 	assert (dev != NULL);

   760 	assert (tp->pci_dev != NULL);

   761 	pdev = tp->pci_dev;

   762 

   763 	if (tp->mmio_addr)

   764 		pci_iounmap (pdev, tp->mmio_addr);

   765 

   766 	/* it's ok to call this even if we have no regions to free */

   767 	pci_release_regions (pdev);

   768 

   769 	free_netdev(dev);

   770 	pci_set_drvdata (pdev, NULL);

   771 }

   772 

   773 

   774 static void rtl8139_chip_reset (void __iomem *ioaddr)

   775 {

   776 	int i;

   777 

   778 	/* Soft reset the chip. */

   779 	RTL_W8 (ChipCmd, CmdReset);

   780 

   781 	/* Check that the chip has finished the reset. */

   782 	for (i = 1000; i > 0; i--) {

   783 		barrier();

   784 		if ((RTL_R8 (ChipCmd) & CmdReset) == 0)

   785 			break;

   786 		udelay (10);

   787 	}

   788 }

   789 

   790 

   791 static __devinit struct net_device * rtl8139_init_board (struct pci_dev *pdev)

   792 {

   793 	void __iomem *ioaddr;

   794 	struct net_device *dev;

   795 	struct rtl8139_private *tp;

   796 	u8 tmp8;

   797 	int rc, disable_dev_on_err = 0;

   798 	unsigned int i;

   799 	unsigned long pio_start, pio_end __attribute__ ((unused)), pio_flags,

   800                   pio_len;

   801 	unsigned long mmio_start __attribute__ ((unused)),

   802                   mmio_end __attribute__ ((unused)), mmio_flags, mmio_len;

   803 	u32 version;

   804 

   805 	assert (pdev != NULL);

   806 

   807 	/* dev and priv zeroed in alloc_etherdev */

   808 	dev = alloc_etherdev (sizeof (*tp));

   809 	if (dev == NULL) {

   810 		dev_err(&pdev->dev, "Unable to alloc new net device\n");

   811 		return ERR_PTR(-ENOMEM);

   812 	}

   813 	SET_NETDEV_DEV(dev, &pdev->dev);

   814 

   815 	tp = netdev_priv(dev);

   816 	tp->pci_dev = pdev;

   817 

   818 	/* enable device (incl. PCI PM wakeup and hotplug setup) */

   819 	rc = pci_enable_device (pdev);

   820 	if (rc)

   821 		goto err_out;

   822 

   823 	pio_start = pci_resource_start (pdev, 0);

   824 	pio_end = pci_resource_end (pdev, 0);

   825 	pio_flags = pci_resource_flags (pdev, 0);

   826 	pio_len = pci_resource_len (pdev, 0);

   827 

   828 	mmio_start = pci_resource_start (pdev, 1);

   829 	mmio_end = pci_resource_end (pdev, 1);

   830 	mmio_flags = pci_resource_flags (pdev, 1);

   831 	mmio_len = pci_resource_len (pdev, 1);

   832 

   833 	/* set this immediately, we need to know before

   834 	 * we talk to the chip directly */

   835 	pr_debug("PIO region size == 0x%02lX\n", pio_len);

   836 	pr_debug("MMIO region size == 0x%02lX\n", mmio_len);

   837 

   838 retry:

   839 	if (use_io) {

   840 		/* make sure PCI base addr 0 is PIO */

   841 		if (!(pio_flags & IORESOURCE_IO)) {

   842 			dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");

   843 			rc = -ENODEV;

   844 			goto err_out;

   845 		}

   846 		/* check for weird/broken PCI region reporting */

   847 		if (pio_len < RTL_MIN_IO_SIZE) {

   848 			dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n");

   849 			rc = -ENODEV;

   850 			goto err_out;

   851 		}

   852 	} else {

   853 		/* make sure PCI base addr 1 is MMIO */

   854 		if (!(mmio_flags & IORESOURCE_MEM)) {

   855 			dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");

   856 			rc = -ENODEV;

   857 			goto err_out;

   858 		}

   859 		if (mmio_len < RTL_MIN_IO_SIZE) {

   860 			dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n");

   861 			rc = -ENODEV;

   862 			goto err_out;

   863 		}

   864 	}

   865 

   866 	rc = pci_request_regions (pdev, DRV_NAME);

   867 	if (rc)

   868 		goto err_out;

   869 	disable_dev_on_err = 1;

   870 

   871 	/* enable PCI bus-mastering */

   872 	pci_set_master (pdev);

   873 

   874 	if (use_io) {

   875 		ioaddr = pci_iomap(pdev, 0, 0);

   876 		if (!ioaddr) {

   877 			dev_err(&pdev->dev, "cannot map PIO, aborting\n");

   878 			rc = -EIO;

   879 			goto err_out;

   880 		}

   881 		dev->base_addr = pio_start;

   882 		tp->regs_len = pio_len;

   883 	} else {

   884 		/* ioremap MMIO region */

   885 		ioaddr = pci_iomap(pdev, 1, 0);

   886 		if (ioaddr == NULL) {

   887 			dev_err(&pdev->dev, "cannot remap MMIO, trying PIO\n");

   888 			pci_release_regions(pdev);

   889 			use_io = 1;

   890 			goto retry;

   891 		}

   892 		dev->base_addr = (long) ioaddr;

   893 		tp->regs_len = mmio_len;

   894 	}

   895 	tp->mmio_addr = ioaddr;

   896 

   897 	/* Bring old chips out of low-power mode. */

   898 	RTL_W8 (HltClk, 'R');

   899 

   900 	/* check for missing/broken hardware */

   901 	if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {

   902 		dev_err(&pdev->dev, "Chip not responding, ignoring board\n");

   903 		rc = -EIO;

   904 		goto err_out;

   905 	}

   906 

   907 	/* identify chip attached to board */

   908 	version = RTL_R32 (TxConfig) & HW_REVID_MASK;

   909 	for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)

   910 		if (version == rtl_chip_info[i].version) {

   911 			tp->chipset = i;

   912 			goto match;

   913 		}

   914 

   915 	/* if unknown chip, assume array element #0, original RTL-8139 in this case */

   916 	i = 0;

   917 	dev_dbg(&pdev->dev, "unknown chip version, assuming RTL-8139\n");

   918 	dev_dbg(&pdev->dev, "TxConfig = 0x%x\n", RTL_R32 (TxConfig));

   919 	tp->chipset = 0;

   920 

   921 match:

   922 	pr_debug("chipset id (%d) == index %d, '%s'\n",

   923 		 version, i, rtl_chip_info[i].name);

   924 

   925 	if (tp->chipset >= CH_8139B) {

   926 		u8 new_tmp8 = tmp8 = RTL_R8 (Config1);

   927 		pr_debug("PCI PM wakeup\n");

   928 		if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&

   929 		    (tmp8 & LWAKE))

   930 			new_tmp8 &= ~LWAKE;

   931 		new_tmp8 |= Cfg1_PM_Enable;

   932 		if (new_tmp8 != tmp8) {

   933 			RTL_W8 (Cfg9346, Cfg9346_Unlock);

   934 			RTL_W8 (Config1, tmp8);

   935 			RTL_W8 (Cfg9346, Cfg9346_Lock);

   936 		}

   937 		if (rtl_chip_info[tp->chipset].flags & HasLWake) {

   938 			tmp8 = RTL_R8 (Config4);

   939 			if (tmp8 & LWPTN) {

   940 				RTL_W8 (Cfg9346, Cfg9346_Unlock);

   941 				RTL_W8 (Config4, tmp8 & ~LWPTN);

   942 				RTL_W8 (Cfg9346, Cfg9346_Lock);

   943 			}

   944 		}

   945 	} else {

   946 		pr_debug("Old chip wakeup\n");

   947 		tmp8 = RTL_R8 (Config1);

   948 		tmp8 &= ~(SLEEP | PWRDN);

   949 		RTL_W8 (Config1, tmp8);

   950 	}

   951 

   952 	rtl8139_chip_reset (ioaddr);

   953 

   954 	return dev;

   955 

   956 err_out:

   957 	__rtl8139_cleanup_dev (dev);

   958 	if (disable_dev_on_err)

   959 		pci_disable_device (pdev);

   960 	return ERR_PTR(rc);

   961 }

   962 

   963 static const struct net_device_ops rtl8139_netdev_ops = {

   964 	.ndo_open		= rtl8139_open,

   965 	.ndo_stop		= rtl8139_close,

   966 	.ndo_get_stats		= rtl8139_get_stats,

   967 	.ndo_change_mtu		= eth_change_mtu,

   968 	.ndo_validate_addr	= eth_validate_addr,

   969 	.ndo_set_mac_address 	= rtl8139_set_mac_address,

   970 	.ndo_start_xmit		= rtl8139_start_xmit,

   971 	.ndo_set_rx_mode	= rtl8139_set_rx_mode,

   972 	.ndo_do_ioctl		= netdev_ioctl,

   973 	.ndo_tx_timeout		= rtl8139_tx_timeout,

   974 #ifdef CONFIG_NET_POLL_CONTROLLER

   975 	.ndo_poll_controller	= rtl8139_poll_controller,

   976 #endif

   977 };

   978 

   979 static int __devinit rtl8139_init_one (struct pci_dev *pdev,

   980 				       const struct pci_device_id *ent)

   981 {

   982 	struct net_device *dev = NULL;

   983 	struct rtl8139_private *tp;

   984 	int i, addr_len, option;

   985 	void __iomem *ioaddr;

   986 	static int board_idx = -1;

   987 

   988 	assert (pdev != NULL);

   989 	assert (ent != NULL);

   990 

   991 	board_idx++;

   992 

   993 	/* when we're built into the kernel, the driver version message

   994 	 * is only printed if at least one 8139 board has been found

   995 	 */

   996 #ifndef MODULE

   997 	{

   998 		static int printed_version;

   999 		if (!printed_version++)

  1000 			pr_info(RTL8139_DRIVER_NAME "\n");

  1001 	}

  1002 #endif

  1003 

  1004 	if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&

  1005 	    pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->revision >= 0x20) {

  1006 		dev_info(&pdev->dev,

  1007 			   "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip, use 8139cp\n",

  1008 		       	   pdev->vendor, pdev->device, pdev->revision);

  1009 		return -ENODEV;

  1010 	}

  1011 

  1012 	if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&

  1013 	    pdev->device == PCI_DEVICE_ID_REALTEK_8139 &&

  1014 	    pdev->subsystem_vendor == PCI_VENDOR_ID_ATHEROS &&

  1015 	    pdev->subsystem_device == PCI_DEVICE_ID_REALTEK_8139) {

  1016 		pr_info("OQO Model 2 detected. Forcing PIO\n");

  1017 		use_io = 1;

  1018 	}

  1019 

  1020 	dev = rtl8139_init_board (pdev);

  1021 	if (IS_ERR(dev))

  1022 		return PTR_ERR(dev);

  1023 

  1024 	assert (dev != NULL);

  1025 	tp = netdev_priv(dev);

  1026 	tp->dev = dev;

  1027 

  1028 	ioaddr = tp->mmio_addr;

  1029 	assert (ioaddr != NULL);

  1030 

  1031 	addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;

  1032 	for (i = 0; i < 3; i++)

  1033 		((__le16 *) (dev->dev_addr))[i] =

  1034 		    cpu_to_le16(read_eeprom (ioaddr, i + 7, addr_len));

  1035 	memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);

  1036 

  1037 	/* The Rtl8139-specific entries in the device structure. */

  1038 	dev->netdev_ops = &rtl8139_netdev_ops;

  1039 	dev->ethtool_ops = &rtl8139_ethtool_ops;

  1040 	dev->watchdog_timeo = TX_TIMEOUT;

  1041 	netif_napi_add(dev, &tp->napi, rtl8139_poll, 64);

  1042 

  1043 	/* note: the hardware is not capable of sg/csum/highdma, however

  1044 	 * through the use of skb_copy_and_csum_dev we enable these

  1045 	 * features

  1046 	 */

  1047 	dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;

  1048 	dev->vlan_features = dev->features;

  1049 

  1050 	dev->irq = pdev->irq;

  1051 

  1052 	/* tp zeroed and aligned in alloc_etherdev */

  1053 	tp = netdev_priv(dev);

  1054 

  1055 	/* note: tp->chipset set in rtl8139_init_board */

  1056 	tp->drv_flags = board_info[ent->driver_data].hw_flags;

  1057 	tp->mmio_addr = ioaddr;

  1058 	tp->msg_enable =

  1059 		(debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));

  1060 	spin_lock_init (&tp->lock);

  1061 	spin_lock_init (&tp->rx_lock);

  1062 	INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);

  1063 	tp->mii.dev = dev;

  1064 	tp->mii.mdio_read = mdio_read;

  1065 	tp->mii.mdio_write = mdio_write;

  1066 	tp->mii.phy_id_mask = 0x3f;

  1067 	tp->mii.reg_num_mask = 0x1f;

  1068 

  1069 	/* dev is fully set up and ready to use now */

  1070 	// offer device to EtherCAT master module

  1071 	tp->ecdev = ecdev_offer(dev, ec_poll, THIS_MODULE);

  1072 

  1073 	if (!tp->ecdev) {

  1074 		pr_debug("about to register device named %s (%p)...\n", dev->name, dev);

  1075 		i = register_netdev (dev);

  1076 		if (i) goto err_out;

  1077 	}

  1078 

  1079 	pci_set_drvdata (pdev, dev);

  1080 

  1081 	pr_info("%s: %s at 0x%lx, %pM, IRQ %d\n",

  1082 		dev->name,

  1083 		board_info[ent->driver_data].name,

  1084 		dev->base_addr,

  1085 		dev->dev_addr,

  1086 		dev->irq);

  1087 

  1088 	pr_debug("%s:  Identified 8139 chip type '%s'\n",

  1089 		dev->name, rtl_chip_info[tp->chipset].name);

  1090 

  1091 	/* Find the connected MII xcvrs.

  1092 	   Doing this in open() would allow detecting external xcvrs later, but

  1093 	   takes too much time. */

  1094 #ifdef CONFIG_8139TOO_8129

  1095 	if (tp->drv_flags & HAS_MII_XCVR) {

  1096 		int phy, phy_idx = 0;

  1097 		for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {

  1098 			int mii_status = mdio_read(dev, phy, 1);

  1099 			if (mii_status != 0xffff  &&  mii_status != 0x0000) {

  1100 				u16 advertising = mdio_read(dev, phy, 4);

  1101 				tp->phys[phy_idx++] = phy;

  1102 				pr_info("%s: MII transceiver %d status 0x%4.4x advertising %4.4x.\n",

  1103 					   dev->name, phy, mii_status, advertising);

  1104 			}

  1105 		}

  1106 		if (phy_idx == 0) {

  1107 			pr_info("%s: No MII transceivers found! Assuming SYM transceiver.\n",

  1108 				   dev->name);

  1109 			tp->phys[0] = 32;

  1110 		}

  1111 	} else

  1112 #endif

  1113 		tp->phys[0] = 32;

  1114 	tp->mii.phy_id = tp->phys[0];

  1115 

  1116 	/* The lower four bits are the media type. */

  1117 	option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];

  1118 	if (option > 0) {

  1119 		tp->mii.full_duplex = (option & 0x210) ? 1 : 0;

  1120 		tp->default_port = option & 0xFF;

  1121 		if (tp->default_port)

  1122 			tp->mii.force_media = 1;

  1123 	}

  1124 	if (board_idx < MAX_UNITS  &&  full_duplex[board_idx] > 0)

  1125 		tp->mii.full_duplex = full_duplex[board_idx];

  1126 	if (tp->mii.full_duplex) {

  1127 		pr_info("%s: Media type forced to Full Duplex.\n", dev->name);

  1128 		/* Changing the MII-advertised media because might prevent

  1129 		   re-connection. */

  1130 		tp->mii.force_media = 1;

  1131 	}

  1132 	if (tp->default_port) {

  1133 		pr_info("  Forcing %dMbps %s-duplex operation.\n",

  1134 			   (option & 0x20 ? 100 : 10),

  1135 			   (option & 0x10 ? "full" : "half"));

  1136 		mdio_write(dev, tp->phys[0], 0,