1

/******************************************************************************

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2007  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

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

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

    15

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

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

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

    20

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

    21

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

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

 *  vim: noexpandtab

    33

 *

    34

 *****************************************************************************/

    35

    36

/**

    37

   \file

    38

   EtherCAT driver for e100-compatible NICs.

    39

*/

    40

    41

/* Former documentation: */

    42

    43

/*******************************************************************************

    44

    45

  Intel PRO/100 Linux driver

    46

  Copyright(c) 1999 - 2006 Intel Corporation.

    47

    48

  This program is free software; you can redistribute it and/or modify it

    49

  under the terms and conditions of the GNU General Public License,

    50

  version 2, as published by the Free Software Foundation.

    51

    52

  This program is distributed in the hope it will be useful, but WITHOUT

    53

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    54

  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    55

  more details.

    56

    57

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

    58

  this program; if not, write to the Free Software Foundation, Inc.,

    59

  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

    60

    61

  The full GNU General Public License is included in this distribution in

    62

  the file called "COPYING".

    63

    64

  Contact Information:

    65

  Linux NICS <linux.nics@intel.com>

    66

  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    67

  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    68

    69

*******************************************************************************/

    70

    71

/*

    72

 *	e100.c: Intel(R) PRO/100 ethernet driver

    73

 *

    74

 *	(Re)written 2003 by scott.feldman@intel.com.  Based loosely on

    75

 *	original e100 driver, but better described as a munging of

    76

 *	e100, e1000, eepro100, tg3, 8139cp, and other drivers.

    77

 *

    78

 *	References:

    79

 *		Intel 8255x 10/100 Mbps Ethernet Controller Family,

    80

 *		Open Source Software Developers Manual,

    81

 *		http://sourceforge.net/projects/e1000

    82

 *

    83

 *

    84

 *	                      Theory of Operation

    85

 *

    86

 *	I.   General

    87

 *

    88

 *	The driver supports Intel(R) 10/100 Mbps PCI Fast Ethernet

    89

 *	controller family, which includes the 82557, 82558, 82559, 82550,

    90

 *	82551, and 82562 devices.  82558 and greater controllers

    91

 *	integrate the Intel 82555 PHY.  The controllers are used in

    92

 *	server and client network interface cards, as well as in

    93

 *	LAN-On-Motherboard (LOM), CardBus, MiniPCI, and ICHx

    94

 *	configurations.  8255x supports a 32-bit linear addressing

    95

 *	mode and operates at 33Mhz PCI clock rate.

    96

 *

    97

 *	II.  Driver Operation

    98

 *

    99

 *	Memory-mapped mode is used exclusively to access the device's

   100

 *	shared-memory structure, the Control/Status Registers (CSR). All

   101

 *	setup, configuration, and control of the device, including queuing

   102

 *	of Tx, Rx, and configuration commands is through the CSR.

   103

 *	cmd_lock serializes accesses to the CSR command register.  cb_lock

   104

 *	protects the shared Command Block List (CBL).

   105

 *

   106

 *	8255x is highly MII-compliant and all access to the PHY go

   107

 *	through the Management Data Interface (MDI).  Consequently, the

   108

 *	driver leverages the mii.c library shared with other MII-compliant

   109

 *	devices.

   110

 *

   111

 *	Big- and Little-Endian byte order as well as 32- and 64-bit

   112

 *	archs are supported.  Weak-ordered memory and non-cache-coherent

   113

 *	archs are supported.

   114

 *

   115

 *	III. Transmit

   116

 *

   117

 *	A Tx skb is mapped and hangs off of a TCB.  TCBs are linked

   118

 *	together in a fixed-size ring (CBL) thus forming the flexible mode

   119

 *	memory structure.  A TCB marked with the suspend-bit indicates

   120

 *	the end of the ring.  The last TCB processed suspends the

   121

 *	controller, and the controller can be restarted by issue a CU

   122

 *	resume command to continue from the suspend point, or a CU start

   123

 *	command to start at a given position in the ring.

   124

 *

   125

 *	Non-Tx commands (config, multicast setup, etc) are linked

   126

 *	into the CBL ring along with Tx commands.  The common structure

   127

 *	used for both Tx and non-Tx commands is the Command Block (CB).

   128

 *

   129

 *	cb_to_use is the next CB to use for queuing a command; cb_to_clean

   130

 *	is the next CB to check for completion; cb_to_send is the first

   131

 *	CB to start on in case of a previous failure to resume.  CB clean

   132

 *	up happens in interrupt context in response to a CU interrupt.

   133

 *	cbs_avail keeps track of number of free CB resources available.

   134

 *

   135

 * 	Hardware padding of short packets to minimum packet size is

   136

 * 	enabled.  82557 pads with 7Eh, while the later controllers pad

   137

 * 	with 00h.

   138

 *

   139

 *	IV.  Receive

   140

 *

   141

 *	The Receive Frame Area (RFA) comprises a ring of Receive Frame

   142

 *	Descriptors (RFD) + data buffer, thus forming the simplified mode

   143

 *	memory structure.  Rx skbs are allocated to contain both the RFD

   144

 *	and the data buffer, but the RFD is pulled off before the skb is

   145

 *	indicated.  The data buffer is aligned such that encapsulated

   146

 *	protocol headers are u32-aligned.  Since the RFD is part of the

   147

 *	mapped shared memory, and completion status is contained within

   148

 *	the RFD, the RFD must be dma_sync'ed to maintain a consistent

   149

 *	view from software and hardware.

   150

 *

   151

 *	In order to keep updates to the RFD link field from colliding with

   152

 *	hardware writes to mark packets complete, we use the feature that

   153

 *	hardware will not write to a size 0 descriptor and mark the previous

   154

 *	packet as end-of-list (EL).   After updating the link, we remove EL

   155

 *	and only then restore the size such that hardware may use the

   156

 *	previous-to-end RFD.

   157

 *

   158

 *	Under typical operation, the  receive unit (RU) is start once,

   159

 *	and the controller happily fills RFDs as frames arrive.  If

   160

 *	replacement RFDs cannot be allocated, or the RU goes non-active,

   161

 *	the RU must be restarted.  Frame arrival generates an interrupt,

   162

 *	and Rx indication and re-allocation happen in the same context,

   163

 *	therefore no locking is required.  A software-generated interrupt

   164

 *	is generated from the watchdog to recover from a failed allocation

   165

 *	scenario where all Rx resources have been indicated and none re-

   166

 *	placed.

   167

 *

   168

 *	V.   Miscellaneous

   169

 *

   170

 * 	VLAN offloading of tagging, stripping and filtering is not

   171

 * 	supported, but driver will accommodate the extra 4-byte VLAN tag

   172

 * 	for processing by upper layers.  Tx/Rx Checksum offloading is not

   173

 * 	supported.  Tx Scatter/Gather is not supported.  Jumbo Frames is

   174

 * 	not supported (hardware limitation).

   175

 *

   176

 * 	MagicPacket(tm) WoL support is enabled/disabled via ethtool.

   177

 *

   178

 * 	Thanks to JC (jchapman@katalix.com) for helping with

   179

 * 	testing/troubleshooting the development driver.

   180

 *

   181

 * 	TODO:

   182

 * 	o several entry points race with dev->close

   183

 * 	o check for tx-no-resources/stop Q races with tx clean/wake Q

   184

 *

   185

 *	FIXES:

   186

 * 2005/12/02 - Michael O'Donnell <Michael.ODonnell at stratus dot com>

   187

 *	- Stratus87247: protect MDI control register manipulations

   188

 */

   189

   190

#include <linux/module.h>

   191

#include <linux/moduleparam.h>

   192

#include <linux/kernel.h>

   193

#include <linux/types.h>

   194

#include <linux/slab.h>

   195

#include <linux/delay.h>

   196

#include <linux/init.h>

   197

#include <linux/pci.h>

   198

#include <linux/dma-mapping.h>

   199

#include <linux/netdevice.h>

   200

#include <linux/etherdevice.h>

   201

#include <linux/mii.h>

   202

#include <linux/if_vlan.h>

   203

#include <linux/skbuff.h>

   204

#include <linux/ethtool.h>

   205

#include <linux/string.h>

   206

#include <asm/unaligned.h>

   207

   208

// EtherCAT includes

   209

#include "../globals.h"

   210

#include "ecdev.h"

   211

   212

#define DRV_NAME		"ec_e100"

   213

   214

#define DRV_EXT			"-NAPI"

   215

#define DRV_VERSION		"3.5.23-k4"DRV_EXT

   216

#define DRV_DESCRIPTION		"Intel(R) PRO/100 Network Driver"

   217

#define DRV_COPYRIGHT		"Copyright(c) 1999-2006 Intel Corporation"

   218

#define PFX			DRV_NAME ": "

   219

   220

#define E100_WATCHDOG_PERIOD	(2 * HZ)

   221

#define E100_NAPI_WEIGHT	16

   222

   223

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   224

MODULE_AUTHOR(DRV_COPYRIGHT);

   225

MODULE_LICENSE("GPL");

   226

MODULE_VERSION(DRV_VERSION);

   227

   228

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   229

MODULE_AUTHOR("Mario Witkowski <mario.witkowski@w4systems.de>");

   230

MODULE_LICENSE("GPL");

   231

MODULE_VERSION(DRV_VERSION ", master " EC_MASTER_VERSION);

   232

   233

void e100_ec_poll(struct net_device *);

   234

   235

static int debug = 3;

   236

static int eeprom_bad_csum_allow = 0;

   237

static int use_io = 0;

   238

module_param(debug, int, 0);

   239

module_param(eeprom_bad_csum_allow, int, 0);

   240

module_param(use_io, int, 0);

   241

MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");

   242

MODULE_PARM_DESC(eeprom_bad_csum_allow, "Allow bad eeprom checksums");

   243

MODULE_PARM_DESC(use_io, "Force use of i/o access mode");

   244

#define DPRINTK(nlevel, klevel, fmt, args...) \

   245

	(void)((NETIF_MSG_##nlevel & nic->msg_enable) && \

   246

	printk(KERN_##klevel PFX "%s: %s: " fmt, nic->netdev->name, \

   247

		__FUNCTION__ , ## args))

   248

   249

#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\

   250

	PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \

   251

	PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }

   252

static struct pci_device_id e100_id_table[] = {

   253

	INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),

   254

	INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),

   255

	INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),

   256

	INTEL_8255X_ETHERNET_DEVICE(0x1032, 3),

   257

	INTEL_8255X_ETHERNET_DEVICE(0x1033, 3),

   258

	INTEL_8255X_ETHERNET_DEVICE(0x1034, 3),

   259

	INTEL_8255X_ETHERNET_DEVICE(0x1038, 3),

   260

	INTEL_8255X_ETHERNET_DEVICE(0x1039, 4),

   261

	INTEL_8255X_ETHERNET_DEVICE(0x103A, 4),

   262

	INTEL_8255X_ETHERNET_DEVICE(0x103B, 4),

   263

	INTEL_8255X_ETHERNET_DEVICE(0x103C, 4),

   264

	INTEL_8255X_ETHERNET_DEVICE(0x103D, 4),

   265

	INTEL_8255X_ETHERNET_DEVICE(0x103E, 4),

   266

	INTEL_8255X_ETHERNET_DEVICE(0x1050, 5),

   267

	INTEL_8255X_ETHERNET_DEVICE(0x1051, 5),

   268

	INTEL_8255X_ETHERNET_DEVICE(0x1052, 5),

   269

	INTEL_8255X_ETHERNET_DEVICE(0x1053, 5),

   270

	INTEL_8255X_ETHERNET_DEVICE(0x1054, 5),

   271

	INTEL_8255X_ETHERNET_DEVICE(0x1055, 5),

   272

	INTEL_8255X_ETHERNET_DEVICE(0x1056, 5),

   273

	INTEL_8255X_ETHERNET_DEVICE(0x1057, 5),

   274

	INTEL_8255X_ETHERNET_DEVICE(0x1059, 0),

   275

	INTEL_8255X_ETHERNET_DEVICE(0x1064, 6),

   276

	INTEL_8255X_ETHERNET_DEVICE(0x1065, 6),

   277

	INTEL_8255X_ETHERNET_DEVICE(0x1066, 6),

   278

	INTEL_8255X_ETHERNET_DEVICE(0x1067, 6),

   279

	INTEL_8255X_ETHERNET_DEVICE(0x1068, 6),

   280

	INTEL_8255X_ETHERNET_DEVICE(0x1069, 6),

   281

	INTEL_8255X_ETHERNET_DEVICE(0x106A, 6),

   282

	INTEL_8255X_ETHERNET_DEVICE(0x106B, 6),

   283

	INTEL_8255X_ETHERNET_DEVICE(0x1091, 7),

   284

	INTEL_8255X_ETHERNET_DEVICE(0x1092, 7),

   285

	INTEL_8255X_ETHERNET_DEVICE(0x1093, 7),

   286

	INTEL_8255X_ETHERNET_DEVICE(0x1094, 7),

   287

	INTEL_8255X_ETHERNET_DEVICE(0x1095, 7),

   288

	INTEL_8255X_ETHERNET_DEVICE(0x1209, 0),

   289

	INTEL_8255X_ETHERNET_DEVICE(0x1229, 0),

   290

	INTEL_8255X_ETHERNET_DEVICE(0x2449, 2),

   291

	INTEL_8255X_ETHERNET_DEVICE(0x2459, 2),

   292

	INTEL_8255X_ETHERNET_DEVICE(0x245D, 2),

   293

	INTEL_8255X_ETHERNET_DEVICE(0x27DC, 7),

   294

	{ 0, }

   295

};

   296

   297

// prevent from being loaded automatically

   298

//MODULE_DEVICE_TABLE(pci, e100_id_table);

   299

   300

enum mac {

   301

	mac_82557_D100_A  = 0,

   302

	mac_82557_D100_B  = 1,

   303

	mac_82557_D100_C  = 2,

   304

	mac_82558_D101_A4 = 4,

   305

	mac_82558_D101_B0 = 5,

   306

	mac_82559_D101M   = 8,

   307

	mac_82559_D101S   = 9,

   308

	mac_82550_D102    = 12,

   309

	mac_82550_D102_C  = 13,

   310

	mac_82551_E       = 14,

   311

	mac_82551_F       = 15,

   312

	mac_82551_10      = 16,

   313

	mac_unknown       = 0xFF,

   314

};

   315

   316

enum phy {

   317

	phy_100a     = 0x000003E0,

   318

	phy_100c     = 0x035002A8,

   319

	phy_82555_tx = 0x015002A8,

   320

	phy_nsc_tx   = 0x5C002000,

   321

	phy_82562_et = 0x033002A8,

   322

	phy_82562_em = 0x032002A8,

   323

	phy_82562_ek = 0x031002A8,

   324

	phy_82562_eh = 0x017002A8,

   325

	phy_unknown  = 0xFFFFFFFF,

   326

};

   327

   328

/* CSR (Control/Status Registers) */

   329

struct csr {

   330

	struct {

   331

		u8 status;

   332

		u8 stat_ack;

   333

		u8 cmd_lo;

   334

		u8 cmd_hi;

   335

		u32 gen_ptr;

   336

	} scb;

   337

	u32 port;

   338

	u16 flash_ctrl;

   339

	u8 eeprom_ctrl_lo;

   340

	u8 eeprom_ctrl_hi;

   341

	u32 mdi_ctrl;

   342

	u32 rx_dma_count;

   343

};

   344

   345

enum scb_status {

   346

	rus_no_res       = 0x08,

   347

	rus_ready        = 0x10,

   348

	rus_mask         = 0x3C,

   349

};

   350

   351

enum ru_state  {

   352

	RU_SUSPENDED = 0,

   353

	RU_RUNNING	 = 1,

   354

	RU_UNINITIALIZED = -1,

   355

};

   356

   357

enum scb_stat_ack {

   358

	stat_ack_not_ours    = 0x00,

   359

	stat_ack_sw_gen      = 0x04,

   360

	stat_ack_rnr         = 0x10,

   361

	stat_ack_cu_idle     = 0x20,

   362

	stat_ack_frame_rx    = 0x40,

   363

	stat_ack_cu_cmd_done = 0x80,

   364

	stat_ack_not_present = 0xFF,

   365

	stat_ack_rx = (stat_ack_sw_gen | stat_ack_rnr | stat_ack_frame_rx),

   366

	stat_ack_tx = (stat_ack_cu_idle | stat_ack_cu_cmd_done),

   367

};

   368

   369

enum scb_cmd_hi {

   370

	irq_mask_none = 0x00,

   371

	irq_mask_all  = 0x01,

   372

	irq_sw_gen    = 0x02,

   373

};

   374

   375

enum scb_cmd_lo {

   376

	cuc_nop        = 0x00,

   377

	ruc_start      = 0x01,

   378

	ruc_load_base  = 0x06,

   379

	cuc_start      = 0x10,

   380

	cuc_resume     = 0x20,

   381

	cuc_dump_addr  = 0x40,

   382

	cuc_dump_stats = 0x50,

   383

	cuc_load_base  = 0x60,

   384

	cuc_dump_reset = 0x70,

   385

};

   386

   387

enum cuc_dump {

   388

	cuc_dump_complete       = 0x0000A005,

   389

	cuc_dump_reset_complete = 0x0000A007,

   390

};

   391

   392

enum port {

   393

	software_reset  = 0x0000,

   394

	selftest        = 0x0001,

   395

	selective_reset = 0x0002,

   396

};

   397

   398

enum eeprom_ctrl_lo {

   399

	eesk = 0x01,

   400

	eecs = 0x02,

   401

	eedi = 0x04,

   402

	eedo = 0x08,

   403

};

   404

   405

enum mdi_ctrl {

   406

	mdi_write = 0x04000000,

   407

	mdi_read  = 0x08000000,

   408

	mdi_ready = 0x10000000,

   409

};

   410

   411

enum eeprom_op {

   412

	op_write = 0x05,

   413

	op_read  = 0x06,

   414

	op_ewds  = 0x10,

   415

	op_ewen  = 0x13,

   416

};

   417

   418

enum eeprom_offsets {

   419

	eeprom_cnfg_mdix  = 0x03,

   420

	eeprom_id         = 0x0A,

   421

	eeprom_config_asf = 0x0D,

   422

	eeprom_smbus_addr = 0x90,

   423

};

   424

   425

enum eeprom_cnfg_mdix {

   426

	eeprom_mdix_enabled = 0x0080,

   427

};

   428

   429

enum eeprom_id {

   430

	eeprom_id_wol = 0x0020,

   431

};

   432

   433

enum eeprom_config_asf {

   434

	eeprom_asf = 0x8000,

   435

	eeprom_gcl = 0x4000,

   436

};

   437

   438

enum cb_status {

   439

	cb_complete = 0x8000,

   440

	cb_ok       = 0x2000,

   441

};

   442

   443

enum cb_command {

   444

	cb_nop    = 0x0000,

   445

	cb_iaaddr = 0x0001,

   446

	cb_config = 0x0002,

   447

	cb_multi  = 0x0003,

   448

	cb_tx     = 0x0004,

   449

	cb_ucode  = 0x0005,

   450

	cb_dump   = 0x0006,

   451

	cb_tx_sf  = 0x0008,

   452

	cb_cid    = 0x1f00,

   453

	cb_i      = 0x2000,

   454

	cb_s      = 0x4000,

   455

	cb_el     = 0x8000,

   456

};

   457

   458

struct rfd {

   459

	__le16 status;

   460

	__le16 command;

   461

	__le32 link;

   462

	__le32 rbd;

   463

	__le16 actual_size;

   464

	__le16 size;

   465

};

   466

   467

struct rx {

   468

	struct rx *next, *prev;

   469

	struct sk_buff *skb;

   470

	dma_addr_t dma_addr;

   471

};

   472

   473

#if defined(__BIG_ENDIAN_BITFIELD)

   474

#define X(a,b)	b,a

   475

#else

   476

#define X(a,b)	a,b

   477

#endif

   478

struct config {

   479

/*0*/	u8 X(byte_count:6, pad0:2);

   480

/*1*/	u8 X(X(rx_fifo_limit:4, tx_fifo_limit:3), pad1:1);

   481

/*2*/	u8 adaptive_ifs;

   482

/*3*/	u8 X(X(X(X(mwi_enable:1, type_enable:1), read_align_enable:1),

   483

	   term_write_cache_line:1), pad3:4);

   484

/*4*/	u8 X(rx_dma_max_count:7, pad4:1);

   485

/*5*/	u8 X(tx_dma_max_count:7, dma_max_count_enable:1);

   486

/*6*/	u8 X(X(X(X(X(X(X(late_scb_update:1, direct_rx_dma:1),

   487

	   tno_intr:1), cna_intr:1), standard_tcb:1), standard_stat_counter:1),

   488

	   rx_discard_overruns:1), rx_save_bad_frames:1);

   489

/*7*/	u8 X(X(X(X(X(rx_discard_short_frames:1, tx_underrun_retry:2),

   490

	   pad7:2), rx_extended_rfd:1), tx_two_frames_in_fifo:1),

   491

	   tx_dynamic_tbd:1);

   492

/*8*/	u8 X(X(mii_mode:1, pad8:6), csma_disabled:1);

   493

/*9*/	u8 X(X(X(X(X(rx_tcpudp_checksum:1, pad9:3), vlan_arp_tco:1),

   494

	   link_status_wake:1), arp_wake:1), mcmatch_wake:1);

   495

/*10*/	u8 X(X(X(pad10:3, no_source_addr_insertion:1), preamble_length:2),

   496

	   loopback:2);

   497

/*11*/	u8 X(linear_priority:3, pad11:5);

   498

/*12*/	u8 X(X(linear_priority_mode:1, pad12:3), ifs:4);

   499

/*13*/	u8 ip_addr_lo;

   500

/*14*/	u8 ip_addr_hi;

   501

/*15*/	u8 X(X(X(X(X(X(X(promiscuous_mode:1, broadcast_disabled:1),

   502

	   wait_after_win:1), pad15_1:1), ignore_ul_bit:1), crc_16_bit:1),

   503

	   pad15_2:1), crs_or_cdt:1);

   504

/*16*/	u8 fc_delay_lo;

   505

/*17*/	u8 fc_delay_hi;

   506

/*18*/	u8 X(X(X(X(X(rx_stripping:1, tx_padding:1), rx_crc_transfer:1),

   507

	   rx_long_ok:1), fc_priority_threshold:3), pad18:1);

   508

/*19*/	u8 X(X(X(X(X(X(X(addr_wake:1, magic_packet_disable:1),

   509

	   fc_disable:1), fc_restop:1), fc_restart:1), fc_reject:1),

   510

	   full_duplex_force:1), full_duplex_pin:1);

   511

/*20*/	u8 X(X(X(pad20_1:5, fc_priority_location:1), multi_ia:1), pad20_2:1);

   512

/*21*/	u8 X(X(pad21_1:3, multicast_all:1), pad21_2:4);

   513

/*22*/	u8 X(X(rx_d102_mode:1, rx_vlan_drop:1), pad22:6);

   514

	u8 pad_d102[9];

   515

};

   516

   517

#define E100_MAX_MULTICAST_ADDRS	64

   518

struct multi {

   519

	__le16 count;

   520

	u8 addr[E100_MAX_MULTICAST_ADDRS * ETH_ALEN + 2/*pad*/];

   521

};

   522

   523

/* Important: keep total struct u32-aligned */

   524

#define UCODE_SIZE			134

   525

struct cb {

   526

	__le16 status;

   527

	__le16 command;

   528

	__le32 link;

   529

	union {

   530