1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

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

   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

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

 *	placed.

   158

 *

   159

 *	V.   Miscellaneous

   160

 *

   161

 * 	VLAN offloading of tagging, stripping and filtering is not

   162

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

   163

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

   164

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

   165

 * 	not supported (hardware limitation).

   166

 *

   167

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

   168

 *

   169

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

   170

 * 	testing/troubleshooting the development driver.

   171

 *

   172

 * 	TODO:

   173

 * 	o several entry points race with dev->close

   174

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

   175

 *

   176

 *	FIXES:

   177

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

   178

 *	- Stratus87247: protect MDI control register manipulations

   179

 */

   180

   181

#include <linux/module.h>

   182

#include <linux/moduleparam.h>

   183

#include <linux/kernel.h>

   184

#include <linux/types.h>

   185

#include <linux/slab.h>

   186

#include <linux/delay.h>

   187

#include <linux/init.h>

   188

#include <linux/pci.h>

   189

#include <linux/dma-mapping.h>

   190

#include <linux/netdevice.h>

   191

#include <linux/etherdevice.h>

   192

#include <linux/mii.h>

   193

#include <linux/if_vlan.h>

   194

#include <linux/skbuff.h>

   195

#include <linux/ethtool.h>

   196

#include <linux/string.h>

   197

#include <asm/unaligned.h>

   198

   199

// EtherCAT includes

   200

#include "../globals.h"

   201

#include "ecdev.h"

   202

   203

#define DRV_NAME		"ec_e100"

   204

   205

#define DRV_EXT			"-NAPI"

   206

#define DRV_VERSION		"3.5.23-k4"DRV_EXT

   207

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

   208

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

   209

#define PFX			DRV_NAME ": "

   210

   211

#define E100_WATCHDOG_PERIOD	(2 * HZ)

   212

#define E100_NAPI_WEIGHT	16

   213

   214

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   215

MODULE_AUTHOR(DRV_COPYRIGHT);

   216

MODULE_LICENSE("GPL");

   217

MODULE_VERSION(DRV_VERSION);

   218

   219

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   220

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

   221

MODULE_LICENSE("GPL");

   222

MODULE_VERSION(DRV_VERSION ", master " EC_MASTER_VERSION);

   223

   224

void e100_ec_poll(struct net_device *);

   225

   226

static int debug = 3;

   227

static int eeprom_bad_csum_allow = 0;

   228

static int use_io = 0;

   229

module_param(debug, int, 0);

   230

module_param(eeprom_bad_csum_allow, int, 0);

   231

module_param(use_io, int, 0);

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

		__FUNCTION__ , ## args))

   239

   240

#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\

   241

	PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \

   242

	PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }

   243

static struct pci_device_id e100_id_table[] = {

   244

	INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),

   245

	INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),

   246

	INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),

   247

	INTEL_8255X_ETHERNET_DEVICE(0x1032, 3),

   248

	INTEL_8255X_ETHERNET_DEVICE(0x1033, 3),

   249

	INTEL_8255X_ETHERNET_DEVICE(0x1034, 3),

   250

	INTEL_8255X_ETHERNET_DEVICE(0x1038, 3),

   251

	INTEL_8255X_ETHERNET_DEVICE(0x1039, 4),

   252

	INTEL_8255X_ETHERNET_DEVICE(0x103A, 4),

   253

	INTEL_8255X_ETHERNET_DEVICE(0x103B, 4),

   254

	INTEL_8255X_ETHERNET_DEVICE(0x103C, 4),

   255

	INTEL_8255X_ETHERNET_DEVICE(0x103D, 4),

   256

	INTEL_8255X_ETHERNET_DEVICE(0x103E, 4),

   257

	INTEL_8255X_ETHERNET_DEVICE(0x1050, 5),

   258

	INTEL_8255X_ETHERNET_DEVICE(0x1051, 5),

   259

	INTEL_8255X_ETHERNET_DEVICE(0x1052, 5),

   260

	INTEL_8255X_ETHERNET_DEVICE(0x1053, 5),

   261

	INTEL_8255X_ETHERNET_DEVICE(0x1054, 5),

   262

	INTEL_8255X_ETHERNET_DEVICE(0x1055, 5),

   263

	INTEL_8255X_ETHERNET_DEVICE(0x1056, 5),

   264

	INTEL_8255X_ETHERNET_DEVICE(0x1057, 5),

   265

	INTEL_8255X_ETHERNET_DEVICE(0x1059, 0),

   266

	INTEL_8255X_ETHERNET_DEVICE(0x1064, 6),

   267

	INTEL_8255X_ETHERNET_DEVICE(0x1065, 6),

   268

	INTEL_8255X_ETHERNET_DEVICE(0x1066, 6),

   269

	INTEL_8255X_ETHERNET_DEVICE(0x1067, 6),

   270

	INTEL_8255X_ETHERNET_DEVICE(0x1068, 6),

   271

	INTEL_8255X_ETHERNET_DEVICE(0x1069, 6),

   272

	INTEL_8255X_ETHERNET_DEVICE(0x106A, 6),

   273

	INTEL_8255X_ETHERNET_DEVICE(0x106B, 6),

   274

	INTEL_8255X_ETHERNET_DEVICE(0x1091, 7),

   275

	INTEL_8255X_ETHERNET_DEVICE(0x1092, 7),

   276

	INTEL_8255X_ETHERNET_DEVICE(0x1093, 7),

   277

	INTEL_8255X_ETHERNET_DEVICE(0x1094, 7),

   278

	INTEL_8255X_ETHERNET_DEVICE(0x1095, 7),

   279

	INTEL_8255X_ETHERNET_DEVICE(0x1209, 0),

   280

	INTEL_8255X_ETHERNET_DEVICE(0x1229, 0),

   281

	INTEL_8255X_ETHERNET_DEVICE(0x2449, 2),

   282

	INTEL_8255X_ETHERNET_DEVICE(0x2459, 2),

   283

	INTEL_8255X_ETHERNET_DEVICE(0x245D, 2),

   284

	INTEL_8255X_ETHERNET_DEVICE(0x27DC, 7),

   285

	{ 0, }

   286

};

   287

   288

// prevent from being loaded automatically

   289

//MODULE_DEVICE_TABLE(pci, e100_id_table);

   290

   291

enum mac {

   292

	mac_82557_D100_A  = 0,

   293

	mac_82557_D100_B  = 1,

   294

	mac_82557_D100_C  = 2,

   295

	mac_82558_D101_A4 = 4,

   296

	mac_82558_D101_B0 = 5,

   297

	mac_82559_D101M   = 8,

   298

	mac_82559_D101S   = 9,

   299

	mac_82550_D102    = 12,

   300

	mac_82550_D102_C  = 13,

   301

	mac_82551_E       = 14,

   302

	mac_82551_F       = 15,

   303

	mac_82551_10      = 16,

   304

	mac_unknown       = 0xFF,

   305

};

   306

   307

enum phy {

   308

	phy_100a     = 0x000003E0,

   309

	phy_100c     = 0x035002A8,

   310

	phy_82555_tx = 0x015002A8,

   311

	phy_nsc_tx   = 0x5C002000,

   312

	phy_82562_et = 0x033002A8,

   313

	phy_82562_em = 0x032002A8,

   314

	phy_82562_ek = 0x031002A8,

   315

	phy_82562_eh = 0x017002A8,

   316

	phy_unknown  = 0xFFFFFFFF,

   317

};

   318

   319

/* CSR (Control/Status Registers) */

   320

struct csr {

   321

	struct {

   322

		u8 status;

   323

		u8 stat_ack;

   324

		u8 cmd_lo;

   325

		u8 cmd_hi;

   326

		u32 gen_ptr;

   327

	} scb;

   328

	u32 port;

   329

	u16 flash_ctrl;

   330

	u8 eeprom_ctrl_lo;

   331

	u8 eeprom_ctrl_hi;

   332

	u32 mdi_ctrl;

   333

	u32 rx_dma_count;

   334

};

   335

   336

enum scb_status {

   337

	rus_ready        = 0x10,

   338

	rus_mask         = 0x3C,

   339

};

   340

   341

enum ru_state  {

   342

	RU_SUSPENDED = 0,

   343

	RU_RUNNING	 = 1,

   344

	RU_UNINITIALIZED = -1,

   345

};

   346

   347

enum scb_stat_ack {

   348

	stat_ack_not_ours    = 0x00,

   349

	stat_ack_sw_gen      = 0x04,

   350

	stat_ack_rnr         = 0x10,

   351

	stat_ack_cu_idle     = 0x20,

   352

	stat_ack_frame_rx    = 0x40,

   353

	stat_ack_cu_cmd_done = 0x80,

   354

	stat_ack_not_present = 0xFF,

   355

	stat_ack_rx = (stat_ack_sw_gen | stat_ack_rnr | stat_ack_frame_rx),

   356

	stat_ack_tx = (stat_ack_cu_idle | stat_ack_cu_cmd_done),

   357

};

   358

   359

enum scb_cmd_hi {

   360

	irq_mask_none = 0x00,

   361

	irq_mask_all  = 0x01,

   362

	irq_sw_gen    = 0x02,

   363

};

   364

   365

enum scb_cmd_lo {

   366

	cuc_nop        = 0x00,

   367

	ruc_start      = 0x01,

   368

	ruc_load_base  = 0x06,

   369

	cuc_start      = 0x10,

   370

	cuc_resume     = 0x20,

   371

	cuc_dump_addr  = 0x40,

   372

	cuc_dump_stats = 0x50,

   373

	cuc_load_base  = 0x60,

   374

	cuc_dump_reset = 0x70,

   375

};

   376

   377

enum cuc_dump {

   378

	cuc_dump_complete       = 0x0000A005,

   379

	cuc_dump_reset_complete = 0x0000A007,

   380

};

   381

   382

enum port {

   383

	software_reset  = 0x0000,

   384

	selftest        = 0x0001,

   385

	selective_reset = 0x0002,

   386

};

   387

   388

enum eeprom_ctrl_lo {

   389

	eesk = 0x01,

   390

	eecs = 0x02,

   391

	eedi = 0x04,

   392

	eedo = 0x08,

   393

};

   394

   395

enum mdi_ctrl {

   396

	mdi_write = 0x04000000,

   397

	mdi_read  = 0x08000000,

   398

	mdi_ready = 0x10000000,

   399

};

   400

   401

enum eeprom_op {

   402

	op_write = 0x05,

   403

	op_read  = 0x06,

   404

	op_ewds  = 0x10,

   405

	op_ewen  = 0x13,

   406

};

   407

   408

enum eeprom_offsets {

   409

	eeprom_cnfg_mdix  = 0x03,

   410

	eeprom_id         = 0x0A,

   411

	eeprom_config_asf = 0x0D,

   412

	eeprom_smbus_addr = 0x90,

   413

};

   414

   415

enum eeprom_cnfg_mdix {

   416

	eeprom_mdix_enabled = 0x0080,

   417

};

   418

   419

enum eeprom_id {

   420

	eeprom_id_wol = 0x0020,

   421

};

   422

   423

enum eeprom_config_asf {

   424

	eeprom_asf = 0x8000,

   425

	eeprom_gcl = 0x4000,

   426

};

   427

   428

enum cb_status {

   429

	cb_complete = 0x8000,

   430

	cb_ok       = 0x2000,

   431

};

   432

   433

enum cb_command {

   434

	cb_nop    = 0x0000,

   435

	cb_iaaddr = 0x0001,

   436

	cb_config = 0x0002,

   437

	cb_multi  = 0x0003,

   438

	cb_tx     = 0x0004,

   439

	cb_ucode  = 0x0005,

   440

	cb_dump   = 0x0006,

   441

	cb_tx_sf  = 0x0008,

   442

	cb_cid    = 0x1f00,

   443

	cb_i      = 0x2000,

   444

	cb_s      = 0x4000,

   445

	cb_el     = 0x8000,

   446

};

   447

   448

struct rfd {

   449

	u16 status;

   450

	u16 command;

   451

	u32 link;

   452

	u32 rbd;

   453

	u16 actual_size;

   454

	u16 size;

   455

};

   456

   457

struct rx {

   458

	struct rx *next, *prev;

   459

	struct sk_buff *skb;

   460

	dma_addr_t dma_addr;

   461

};

   462

   463

#if defined(__BIG_ENDIAN_BITFIELD)

   464

#define X(a,b)	b,a

   465

#else

   466

#define X(a,b)	a,b

   467

#endif

   468

struct config {

   469

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

   470

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

   471

/*2*/	u8 adaptive_ifs;

   472

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

   473

	   term_write_cache_line:1), pad3:4);

   474

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

   475

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

   476

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

   477

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

   478

	   rx_discard_overruns:1), rx_save_bad_frames:1);

   479

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

   480

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

   481

	   tx_dynamic_tbd:1);

   482

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

   483

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

   484

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

   485

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

   486

	   loopback:2);

   487

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

   488

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

   489

/*13*/	u8 ip_addr_lo;

   490

/*14*/	u8 ip_addr_hi;

   491

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

   492

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

   493

	   pad15_2:1), crs_or_cdt:1);

   494

/*16*/	u8 fc_delay_lo;

   495

/*17*/	u8 fc_delay_hi;

   496

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

   497

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

   498

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

   499

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

   500

	   full_duplex_force:1), full_duplex_pin:1);

   501

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

   502

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

   503

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

   504

	u8 pad_d102[9];

   505

};

   506

   507

#define E100_MAX_MULTICAST_ADDRS	64

   508

struct multi {

   509

	u16 count;

   510

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

   511

};

   512

   513

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

   514

#define UCODE_SIZE			134

   515

struct cb {

   516

	u16 status;

   517

	u16 command;

   518

	u32 link;

   519

	union {

   520

		u8 iaaddr[ETH_ALEN];

   521

		u32 ucode[UCODE_SIZE];

   522

		struct config config;

   523

		struct multi multi;

   524

		struct {

   525

			u32 tbd_array;

   526

			u16 tcb_byte_count;

   527

			u8 threshold;

   528

			u8 tbd_count;