1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

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

 *  vim: noexpandtab

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT driver for e100-compatible NICs.

    37

*/

    38

    39

/* Former documentation: */

    40

    41

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

    42

    43

  Intel PRO/100 Linux driver

    44

  Copyright(c) 1999 - 2006 Intel Corporation.

    45

    46

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

    47

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

    48

  version 2, as published by the Free Software Foundation.

    49

    50

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

    51

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    52

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

    53

  more details.

    54

    55

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

    56

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

    57

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

    58

    59

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

    60

  the file called "COPYING".

    61

    62

  Contact Information:

    63

  Linux NICS <linux.nics@intel.com>

    64

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

    65

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

    66

    67

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

    68

    69

/*

    70

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

    71

 *

    72

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

    73

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

    74

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

    75

 *

    76

 *	References:

    77

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

    78

 *		Open Source Software Developers Manual,

    79

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

    80

 *

    81

 *

    82

 *	                      Theory of Operation

    83

 *

    84

 *	I.   General

    85

 *

    86

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

    87

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

    88

 *	82551, and 82562 devices.  82558 and greater controllers

    89

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

    90

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

    91

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

    92

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

    93

 *	mode and operates at 33Mhz PCI clock rate.

    94

 *

    95

 *	II.  Driver Operation

    96

 *

    97

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

    98

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

    99

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

   100

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

   101

 *	cmd_lock serializes accesses to the CSR command register.  cb_lock

   102

 *	protects the shared Command Block List (CBL).

   103

 *

   104

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

   105

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

   106

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

   107

 *	devices.

   108

 *

   109

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

   110

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

   111

 *	archs are supported.

   112

 *

   113

 *	III. Transmit

   114

 *

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

 *

   123

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

   124

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

   125

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

   126

 *

   127

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

   128

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

   129

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

   130

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

   131

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

   132

 *

   133

 * 	Hardware padding of short packets to minimum packet size is

   134

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

   135

 * 	with 00h.

   136

 *

   137

 *	IV.  Receive

   138

 *

   139

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

   140

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

   141

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

   142

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

   143

 *	indicated.  The data buffer is aligned such that encapsulated

   144

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

   145

 *	mapped shared memory, and completion status is contained within

   146

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

   147

 *	view from software and hardware.

   148

 *

   149

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

   150

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

   151

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

   152

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

   153

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

   154

 *	previous-to-end RFD.

   155

 *

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

 *	placed.

   165

 *

   166

 *	V.   Miscellaneous

   167

 *

   168

 * 	VLAN offloading of tagging, stripping and filtering is not

   169

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

   170

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

   171

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

   172

 * 	not supported (hardware limitation).

   173

 *

   174

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

   175

 *

   176

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

   177

 * 	testing/troubleshooting the development driver.

   178

 *

   179

 * 	TODO:

   180

 * 	o several entry points race with dev->close

   181

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

   182

 *

   183

 *	FIXES:

   184

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

   185

 *	- Stratus87247: protect MDI control register manipulations

   186

 * 2009/06/01 - Andreas Mohr <andi at lisas dot de>

   187

 *      - add clean lowlevel I/O emulation for cards with MII-lacking PHYs

   188

 */

   189

   190

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

   191

   192

#include <linux/module.h>

   193

#include <linux/moduleparam.h>

   194

#include <linux/kernel.h>

   195

#include <linux/types.h>

   196

#include <linux/sched.h>

   197

#include <linux/slab.h>

   198

#include <linux/delay.h>

   199

#include <linux/init.h>

   200

#include <linux/pci.h>

   201

#include <linux/dma-mapping.h>

   202

#include <linux/dmapool.h>

   203

#include <linux/netdevice.h>

   204

#include <linux/etherdevice.h>

   205

#include <linux/mii.h>

   206

#include <linux/if_vlan.h>

   207

#include <linux/skbuff.h>

   208

#include <linux/ethtool.h>

   209

#include <linux/string.h>

   210

#include <linux/firmware.h>

   211

#include <linux/rtnetlink.h>

   212

#include <asm/unaligned.h>

   213

   214

// EtherCAT includes

   215

#include "../globals.h"

   216

#include "ecdev.h"

   217

   218

#define DRV_NAME		"ec_e100"

   219

#define DRV_EXT			"-NAPI"

   220

#define DRV_VERSION		"3.5.24-k2"DRV_EXT

   221

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

   222

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

   223

   224

#define E100_WATCHDOG_PERIOD	(2 * HZ)

   225

#define E100_NAPI_WEIGHT	16

   226

   227

#define FIRMWARE_D101M		"e100/d101m_ucode.bin"

   228

#define FIRMWARE_D101S		"e100/d101s_ucode.bin"

   229

#define FIRMWARE_D102E		"e100/d102e_ucode.bin"

   230

   231

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   232

MODULE_AUTHOR(DRV_COPYRIGHT);

   233

MODULE_LICENSE("GPL");

   234

MODULE_VERSION(DRV_VERSION);

   235

MODULE_FIRMWARE(FIRMWARE_D101M);

   236

MODULE_FIRMWARE(FIRMWARE_D101S);

   237

MODULE_FIRMWARE(FIRMWARE_D102E);

   238

   239

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   240

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

   241

MODULE_LICENSE("GPL");

   242

MODULE_VERSION(DRV_VERSION ", master " EC_MASTER_VERSION);

   243

   244

void e100_ec_poll(struct net_device *);

   245

   246

static int debug = 3;

   247

static int eeprom_bad_csum_allow = 0;

   248

static int use_io = 0;

   249

module_param(debug, int, 0);

   250

module_param(eeprom_bad_csum_allow, int, 0);

   251

module_param(use_io, int, 0);

   252

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

   253

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

   254

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

   255

   256

#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\

   257

	PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \

   258

	PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }

   259

static DEFINE_PCI_DEVICE_TABLE(e100_id_table) = {

   260

	INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),

   261

	INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),

   262

	INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),

   263

	INTEL_8255X_ETHERNET_DEVICE(0x1032, 3),

   264

	INTEL_8255X_ETHERNET_DEVICE(0x1033, 3),

   265

	INTEL_8255X_ETHERNET_DEVICE(0x1034, 3),

   266

	INTEL_8255X_ETHERNET_DEVICE(0x1038, 3),

   267

	INTEL_8255X_ETHERNET_DEVICE(0x1039, 4),

   268

	INTEL_8255X_ETHERNET_DEVICE(0x103A, 4),

   269

	INTEL_8255X_ETHERNET_DEVICE(0x103B, 4),

   270

	INTEL_8255X_ETHERNET_DEVICE(0x103C, 4),

   271

	INTEL_8255X_ETHERNET_DEVICE(0x103D, 4),

   272

	INTEL_8255X_ETHERNET_DEVICE(0x103E, 4),

   273

	INTEL_8255X_ETHERNET_DEVICE(0x1050, 5),

   274

	INTEL_8255X_ETHERNET_DEVICE(0x1051, 5),

   275

	INTEL_8255X_ETHERNET_DEVICE(0x1052, 5),

   276

	INTEL_8255X_ETHERNET_DEVICE(0x1053, 5),

   277

	INTEL_8255X_ETHERNET_DEVICE(0x1054, 5),

   278

	INTEL_8255X_ETHERNET_DEVICE(0x1055, 5),

   279

	INTEL_8255X_ETHERNET_DEVICE(0x1056, 5),

   280

	INTEL_8255X_ETHERNET_DEVICE(0x1057, 5),

   281

	INTEL_8255X_ETHERNET_DEVICE(0x1059, 0),

   282

	INTEL_8255X_ETHERNET_DEVICE(0x1064, 6),

   283

	INTEL_8255X_ETHERNET_DEVICE(0x1065, 6),

   284

	INTEL_8255X_ETHERNET_DEVICE(0x1066, 6),

   285

	INTEL_8255X_ETHERNET_DEVICE(0x1067, 6),

   286

	INTEL_8255X_ETHERNET_DEVICE(0x1068, 6),

   287

	INTEL_8255X_ETHERNET_DEVICE(0x1069, 6),

   288

	INTEL_8255X_ETHERNET_DEVICE(0x106A, 6),

   289

	INTEL_8255X_ETHERNET_DEVICE(0x106B, 6),

   290

	INTEL_8255X_ETHERNET_DEVICE(0x1091, 7),

   291

	INTEL_8255X_ETHERNET_DEVICE(0x1092, 7),

   292

	INTEL_8255X_ETHERNET_DEVICE(0x1093, 7),

   293

	INTEL_8255X_ETHERNET_DEVICE(0x1094, 7),

   294

	INTEL_8255X_ETHERNET_DEVICE(0x1095, 7),

   295

	INTEL_8255X_ETHERNET_DEVICE(0x10fe, 7),

   296

	INTEL_8255X_ETHERNET_DEVICE(0x1209, 0),

   297

	INTEL_8255X_ETHERNET_DEVICE(0x1229, 0),

   298

	INTEL_8255X_ETHERNET_DEVICE(0x2449, 2),

   299

	INTEL_8255X_ETHERNET_DEVICE(0x2459, 2),

   300

	INTEL_8255X_ETHERNET_DEVICE(0x245D, 2),

   301

	INTEL_8255X_ETHERNET_DEVICE(0x27DC, 7),

   302

	{ 0, }

   303

};

   304

   305

// prevent from being loaded automatically

   306

//MODULE_DEVICE_TABLE(pci, e100_id_table);

   307

   308

enum mac {

   309

	mac_82557_D100_A  = 0,

   310

	mac_82557_D100_B  = 1,

   311

	mac_82557_D100_C  = 2,

   312

	mac_82558_D101_A4 = 4,

   313

	mac_82558_D101_B0 = 5,

   314

	mac_82559_D101M   = 8,

   315

	mac_82559_D101S   = 9,

   316

	mac_82550_D102    = 12,

   317

	mac_82550_D102_C  = 13,

   318

	mac_82551_E       = 14,

   319

	mac_82551_F       = 15,

   320

	mac_82551_10      = 16,

   321

	mac_unknown       = 0xFF,

   322

};

   323

   324

enum phy {

   325

	phy_100a     = 0x000003E0,

   326

	phy_100c     = 0x035002A8,

   327

	phy_82555_tx = 0x015002A8,

   328

	phy_nsc_tx   = 0x5C002000,

   329

	phy_82562_et = 0x033002A8,

   330

	phy_82562_em = 0x032002A8,

   331

	phy_82562_ek = 0x031002A8,

   332

	phy_82562_eh = 0x017002A8,

   333

	phy_82552_v  = 0xd061004d,

   334

	phy_unknown  = 0xFFFFFFFF,

   335

};

   336

   337

/* CSR (Control/Status Registers) */

   338

struct csr {

   339

	struct {

   340

		u8 status;

   341

		u8 stat_ack;

   342

		u8 cmd_lo;

   343

		u8 cmd_hi;

   344

		u32 gen_ptr;

   345

	} scb;

   346

	u32 port;

   347

	u16 flash_ctrl;

   348

	u8 eeprom_ctrl_lo;

   349

	u8 eeprom_ctrl_hi;

   350

	u32 mdi_ctrl;

   351

	u32 rx_dma_count;

   352

};

   353

   354

enum scb_status {

   355

	rus_no_res       = 0x08,

   356

	rus_ready        = 0x10,

   357

	rus_mask         = 0x3C,

   358

};

   359

   360

enum ru_state  {

   361

	RU_SUSPENDED = 0,

   362

	RU_RUNNING	 = 1,

   363

	RU_UNINITIALIZED = -1,

   364

};

   365

   366

enum scb_stat_ack {

   367

	stat_ack_not_ours    = 0x00,

   368

	stat_ack_sw_gen      = 0x04,

   369

	stat_ack_rnr         = 0x10,

   370

	stat_ack_cu_idle     = 0x20,

   371

	stat_ack_frame_rx    = 0x40,

   372

	stat_ack_cu_cmd_done = 0x80,

   373

	stat_ack_not_present = 0xFF,

   374

	stat_ack_rx = (stat_ack_sw_gen | stat_ack_rnr | stat_ack_frame_rx),

   375

	stat_ack_tx = (stat_ack_cu_idle | stat_ack_cu_cmd_done),

   376

};

   377

   378

enum scb_cmd_hi {

   379

	irq_mask_none = 0x00,

   380

	irq_mask_all  = 0x01,

   381

	irq_sw_gen    = 0x02,

   382

};

   383

   384

enum scb_cmd_lo {

   385

	cuc_nop        = 0x00,

   386

	ruc_start      = 0x01,

   387

	ruc_load_base  = 0x06,

   388

	cuc_start      = 0x10,

   389

	cuc_resume     = 0x20,

   390

	cuc_dump_addr  = 0x40,

   391

	cuc_dump_stats = 0x50,

   392

	cuc_load_base  = 0x60,

   393

	cuc_dump_reset = 0x70,

   394

};

   395

   396

enum cuc_dump {

   397

	cuc_dump_complete       = 0x0000A005,

   398

	cuc_dump_reset_complete = 0x0000A007,

   399

};

   400

   401

enum port {

   402

	software_reset  = 0x0000,

   403

	selftest        = 0x0001,

   404

	selective_reset = 0x0002,

   405

};

   406

   407

enum eeprom_ctrl_lo {

   408

	eesk = 0x01,

   409

	eecs = 0x02,

   410

	eedi = 0x04,

   411

	eedo = 0x08,

   412

};

   413

   414

enum mdi_ctrl {

   415

	mdi_write = 0x04000000,

   416

	mdi_read  = 0x08000000,

   417

	mdi_ready = 0x10000000,

   418

};

   419

   420

enum eeprom_op {

   421

	op_write = 0x05,

   422

	op_read  = 0x06,

   423

	op_ewds  = 0x10,

   424

	op_ewen  = 0x13,

   425

};

   426

   427

enum eeprom_offsets {

   428

	eeprom_cnfg_mdix  = 0x03,

   429

	eeprom_phy_iface  = 0x06,

   430

	eeprom_id         = 0x0A,

   431

	eeprom_config_asf = 0x0D,

   432

	eeprom_smbus_addr = 0x90,

   433

};

   434

   435

enum eeprom_cnfg_mdix {

   436

	eeprom_mdix_enabled = 0x0080,

   437

};

   438

   439

enum eeprom_phy_iface {

   440

	NoSuchPhy = 0,

   441

	I82553AB,

   442

	I82553C,

   443

	I82503,

   444

	DP83840,

   445

	S80C240,

   446

	S80C24,

   447

	I82555,

   448

	DP83840A = 10,

   449

};

   450

   451

enum eeprom_id {

   452

	eeprom_id_wol = 0x0020,

   453

};

   454

   455

enum eeprom_config_asf {

   456

	eeprom_asf = 0x8000,

   457

	eeprom_gcl = 0x4000,

   458

};

   459

   460

enum cb_status {

   461

	cb_complete = 0x8000,

   462

	cb_ok       = 0x2000,

   463

};

   464

   465

enum cb_command {

   466

	cb_nop    = 0x0000,

   467

	cb_iaaddr = 0x0001,

   468

	cb_config = 0x0002,

   469

	cb_multi  = 0x0003,

   470

	cb_tx     = 0x0004,

   471

	cb_ucode  = 0x0005,

   472

	cb_dump   = 0x0006,

   473

	cb_tx_sf  = 0x0008,

   474

	cb_cid    = 0x1f00,

   475

	cb_i      = 0x2000,

   476

	cb_s      = 0x4000,

   477

	cb_el     = 0x8000,

   478

};

   479

   480

struct rfd {

   481

	__le16 status;

   482

	__le16 command;

   483

	__le32 link;

   484

	__le32 rbd;

   485

	__le16 actual_size;

   486

	__le16 size;

   487

};

   488

   489

struct rx {

   490

	struct rx *next, *prev;

   491

	struct sk_buff *skb;

   492

	dma_addr_t dma_addr;

   493

};

   494

   495

#if defined(__BIG_ENDIAN_BITFIELD)

   496

#define X(a,b)	b,a

   497

#else

   498

#define X(a,b)	a,b

   499

#endif

   500

struct config {

   501

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

   502

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

   503

/*2*/	u8 adaptive_ifs;

   504

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

   505

	   term_write_cache_line:1), pad3:4);

   506

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

   507

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

   508

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

   509

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

   510

	   rx_discard_overruns:1), rx_save_bad_frames:1);

   511

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

   512

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

   513

	   tx_dynamic_tbd:1);

   514

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

   515

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

   516

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

   517

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

   518

	   loopback:2);

   519

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

   520

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

   521

/*13*/	u8 ip_addr_lo;

   522

/*14*/	u8 ip_addr_hi;

   523

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

   524

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

   525

	   pad15_2:1), crs_or_cdt:1);

   526

/*16*/	u8 fc_delay_lo;

   527

/*17*/	u8 fc_delay_hi;

   528

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

   529

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