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

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

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

    24

 *

    25

 *  vim: noexpandtab

    26

 *

    27

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

    28

    29

/**

    30

   \file

    31

   EtherCAT driver for e100-compatible NICs.

    32

*/

    33

    34

/* Former documentation: */

    35

    36

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

    37

    38

  Intel PRO/100 Linux driver

    39

  Copyright(c) 1999 - 2006 Intel Corporation.

    40

    41

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

    42

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

    43

  version 2, as published by the Free Software Foundation.

    44

    45

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

    46

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    47

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

    48

  more details.

    49

    50

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

    51

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

    52

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

    53

    54

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

    55

  the file called "COPYING".

    56

    57

  Contact Information:

    58

  Linux NICS <linux.nics@intel.com>

    59

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

    60

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

    61

    62

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

    63

    64

/*

    65

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

    66

 *

    67

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

    68

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

    69

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

    70

 *

    71

 *	References:

    72

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

    73

 *		Open Source Software Developers Manual,

    74

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

    75

 *

    76

 *

    77

 *	                      Theory of Operation

    78

 *

    79

 *	I.   General

    80

 *

    81

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

    82

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

    83

 *	82551, and 82562 devices.  82558 and greater controllers

    84

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

    85

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

    86

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

    87

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

    88

 *	mode and operates at 33Mhz PCI clock rate.

    89

 *

    90

 *	II.  Driver Operation

    91

 *

    92

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

    93

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

    94

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

    95

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

    96

 *	cmd_lock serializes accesses to the CSR command register.  cb_lock

    97

 *	protects the shared Command Block List (CBL).

    98

 *

    99

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

   100

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

   101

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

   102

 *	devices.

   103

 *

   104

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

   105

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

   106

 *	archs are supported.

   107

 *

   108

 *	III. Transmit

   109

 *

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

 *

   118

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

   119

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

   120

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

   121

 *

   122

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

   123

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

   124

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

   125

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

   126

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

   127

 *

   128

 * 	Hardware padding of short packets to minimum packet size is

   129

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

   130

 * 	with 00h.

   131

 *

   132

 *	IV.  Recieve

   133

 *

   134

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

   135

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

   136

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

   137

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

   138

 *	indicated.  The data buffer is aligned such that encapsulated

   139

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

   140

 *	mapped shared memory, and completion status is contained within

   141

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

   142

 *	view from software and hardware.

   143

 *

   144

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

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

 *	placed.

   153

 *

   154

 *	V.   Miscellaneous

   155

 *

   156

 * 	VLAN offloading of tagging, stripping and filtering is not

   157

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

   158

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

   159

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

   160

 * 	not supported (hardware limitation).

   161

 *

   162

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

   163

 *

   164

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

   165

 * 	testing/troubleshooting the development driver.

   166

 *

   167

 * 	TODO:

   168

 * 	o several entry points race with dev->close

   169

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

   170

 *

   171

 *	FIXES:

   172

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

   173

 *	- Stratus87247: protect MDI control register manipulations

   174

 */

   175

   176

#include <linux/module.h>

   177

#include <linux/moduleparam.h>

   178

#include <linux/kernel.h>

   179

#include <linux/types.h>

   180

#include <linux/slab.h>

   181

#include <linux/delay.h>

   182

#include <linux/init.h>

   183

#include <linux/pci.h>

   184

#include <linux/dma-mapping.h>

   185

#include <linux/netdevice.h>

   186

#include <linux/etherdevice.h>

   187

#include <linux/mii.h>

   188

#include <linux/if_vlan.h>

   189

#include <linux/skbuff.h>

   190

#include <linux/ethtool.h>

   191

#include <linux/string.h>

   192

#include <asm/unaligned.h>

   193

   194

// EtherCAT includes

   195

#include "../globals.h"

   196

#include "ecdev.h"

   197

   198

#define DRV_NAME		"ec_e100"

   199

   200

#define DRV_EXT			"-NAPI"

   201

#define DRV_VERSION		"3.5.23-k4"DRV_EXT

   202

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

   203

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

   204

#define PFX			DRV_NAME ": "

   205

   206

#define E100_WATCHDOG_PERIOD	(2 * HZ)

   207

#define E100_NAPI_WEIGHT	16

   208

   209

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   210

MODULE_AUTHOR(DRV_COPYRIGHT);

   211

MODULE_LICENSE("GPL");

   212

MODULE_VERSION(DRV_VERSION);

   213

   214

MODULE_DESCRIPTION(DRV_DESCRIPTION);

   215

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

   216

MODULE_LICENSE("GPL");

   217

MODULE_VERSION(DRV_VERSION ", master " EC_MASTER_VERSION);

   218

   219

void e100_ec_poll(struct net_device *);

   220

   221

static int debug = 3;

   222

static int eeprom_bad_csum_allow = 0;

   223

static int use_io = 0;

   224

module_param(debug, int, 0);

   225

module_param(eeprom_bad_csum_allow, int, 0);

   226

module_param(use_io, int, 0);

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

		__FUNCTION__ , ## args))

   234

   235

#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\

   236

	PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \

   237

	PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }

   238

static struct pci_device_id e100_id_table[] = {

   239

	INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),

   240

	INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),

   241

	INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),

   242

	INTEL_8255X_ETHERNET_DEVICE(0x1032, 3),

   243

	INTEL_8255X_ETHERNET_DEVICE(0x1033, 3),

   244

	INTEL_8255X_ETHERNET_DEVICE(0x1034, 3),

   245

	INTEL_8255X_ETHERNET_DEVICE(0x1038, 3),

   246

	INTEL_8255X_ETHERNET_DEVICE(0x1039, 4),

   247

	INTEL_8255X_ETHERNET_DEVICE(0x103A, 4),

   248

	INTEL_8255X_ETHERNET_DEVICE(0x103B, 4),

   249

	INTEL_8255X_ETHERNET_DEVICE(0x103C, 4),

   250

	INTEL_8255X_ETHERNET_DEVICE(0x103D, 4),

   251

	INTEL_8255X_ETHERNET_DEVICE(0x103E, 4),

   252

	INTEL_8255X_ETHERNET_DEVICE(0x1050, 5),

   253

	INTEL_8255X_ETHERNET_DEVICE(0x1051, 5),

   254

	INTEL_8255X_ETHERNET_DEVICE(0x1052, 5),

   255

	INTEL_8255X_ETHERNET_DEVICE(0x1053, 5),

   256

	INTEL_8255X_ETHERNET_DEVICE(0x1054, 5),

   257

	INTEL_8255X_ETHERNET_DEVICE(0x1055, 5),

   258

	INTEL_8255X_ETHERNET_DEVICE(0x1056, 5),

   259

	INTEL_8255X_ETHERNET_DEVICE(0x1057, 5),

   260

	INTEL_8255X_ETHERNET_DEVICE(0x1059, 0),

   261

	INTEL_8255X_ETHERNET_DEVICE(0x1064, 6),

   262

	INTEL_8255X_ETHERNET_DEVICE(0x1065, 6),

   263

	INTEL_8255X_ETHERNET_DEVICE(0x1066, 6),

   264

	INTEL_8255X_ETHERNET_DEVICE(0x1067, 6),

   265

	INTEL_8255X_ETHERNET_DEVICE(0x1068, 6),

   266

	INTEL_8255X_ETHERNET_DEVICE(0x1069, 6),

   267

	INTEL_8255X_ETHERNET_DEVICE(0x106A, 6),

   268

	INTEL_8255X_ETHERNET_DEVICE(0x106B, 6),

   269

	INTEL_8255X_ETHERNET_DEVICE(0x1091, 7),

   270

	INTEL_8255X_ETHERNET_DEVICE(0x1092, 7),

   271

	INTEL_8255X_ETHERNET_DEVICE(0x1093, 7),

   272

	INTEL_8255X_ETHERNET_DEVICE(0x1094, 7),

   273

	INTEL_8255X_ETHERNET_DEVICE(0x1095, 7),

   274

	INTEL_8255X_ETHERNET_DEVICE(0x1209, 0),

   275

	INTEL_8255X_ETHERNET_DEVICE(0x1229, 0),

   276

	INTEL_8255X_ETHERNET_DEVICE(0x2449, 2),

   277

	INTEL_8255X_ETHERNET_DEVICE(0x2459, 2),

   278

	INTEL_8255X_ETHERNET_DEVICE(0x245D, 2),

   279

	INTEL_8255X_ETHERNET_DEVICE(0x27DC, 7),

   280

	{ 0, }

   281

};

   282

   283

// prevent from being loaded automatically

   284

//MODULE_DEVICE_TABLE(pci, e100_id_table);

   285

   286

enum mac {

   287

	mac_82557_D100_A  = 0,

   288

	mac_82557_D100_B  = 1,

   289

	mac_82557_D100_C  = 2,

   290

	mac_82558_D101_A4 = 4,

   291

	mac_82558_D101_B0 = 5,

   292

	mac_82559_D101M   = 8,

   293

	mac_82559_D101S   = 9,

   294

	mac_82550_D102    = 12,

   295

	mac_82550_D102_C  = 13,

   296

	mac_82551_E       = 14,

   297

	mac_82551_F       = 15,

   298

	mac_82551_10      = 16,

   299

	mac_unknown       = 0xFF,

   300

};

   301

   302

enum phy {

   303

	phy_100a     = 0x000003E0,

   304

	phy_100c     = 0x035002A8,

   305

	phy_82555_tx = 0x015002A8,

   306

	phy_nsc_tx   = 0x5C002000,

   307

	phy_82562_et = 0x033002A8,

   308

	phy_82562_em = 0x032002A8,

   309

	phy_82562_ek = 0x031002A8,

   310

	phy_82562_eh = 0x017002A8,

   311

	phy_unknown  = 0xFFFFFFFF,

   312

};

   313

   314

/* CSR (Control/Status Registers) */

   315

struct csr {

   316

	struct {

   317

		u8 status;

   318

		u8 stat_ack;

   319

		u8 cmd_lo;

   320

		u8 cmd_hi;

   321

		u32 gen_ptr;

   322

	} scb;

   323

	u32 port;

   324

	u16 flash_ctrl;

   325

	u8 eeprom_ctrl_lo;

   326

	u8 eeprom_ctrl_hi;

   327

	u32 mdi_ctrl;

   328

	u32 rx_dma_count;

   329

};

   330

   331

enum scb_status {

   332

	rus_ready        = 0x10,

   333

	rus_mask         = 0x3C,

   334

};

   335

   336

enum ru_state  {

   337

	RU_SUSPENDED = 0,

   338

	RU_RUNNING	 = 1,

   339

	RU_UNINITIALIZED = -1,

   340

};

   341

   342

enum scb_stat_ack {

   343

	stat_ack_not_ours    = 0x00,

   344

	stat_ack_sw_gen      = 0x04,

   345

	stat_ack_rnr         = 0x10,

   346

	stat_ack_cu_idle     = 0x20,

   347

	stat_ack_frame_rx    = 0x40,

   348

	stat_ack_cu_cmd_done = 0x80,

   349

	stat_ack_not_present = 0xFF,

   350

	stat_ack_rx = (stat_ack_sw_gen | stat_ack_rnr | stat_ack_frame_rx),

   351

	stat_ack_tx = (stat_ack_cu_idle | stat_ack_cu_cmd_done),

   352

};

   353

   354

enum scb_cmd_hi {

   355

	irq_mask_none = 0x00,

   356

	irq_mask_all  = 0x01,

   357

	irq_sw_gen    = 0x02,

   358

};

   359

   360

enum scb_cmd_lo {

   361

	cuc_nop        = 0x00,

   362

	ruc_start      = 0x01,

   363

	ruc_load_base  = 0x06,

   364

	cuc_start      = 0x10,

   365

	cuc_resume     = 0x20,

   366

	cuc_dump_addr  = 0x40,

   367

	cuc_dump_stats = 0x50,

   368

	cuc_load_base  = 0x60,

   369

	cuc_dump_reset = 0x70,

   370

};

   371

   372

enum cuc_dump {

   373

	cuc_dump_complete       = 0x0000A005,

   374

	cuc_dump_reset_complete = 0x0000A007,

   375

};

   376

   377

enum port {

   378

	software_reset  = 0x0000,

   379

	selftest        = 0x0001,

   380

	selective_reset = 0x0002,

   381

};

   382

   383

enum eeprom_ctrl_lo {

   384

	eesk = 0x01,

   385

	eecs = 0x02,

   386

	eedi = 0x04,

   387

	eedo = 0x08,

   388

};

   389

   390

enum mdi_ctrl {

   391

	mdi_write = 0x04000000,

   392

	mdi_read  = 0x08000000,

   393

	mdi_ready = 0x10000000,

   394

};

   395

   396

enum eeprom_op {

   397

	op_write = 0x05,

   398

	op_read  = 0x06,

   399

	op_ewds  = 0x10,

   400

	op_ewen  = 0x13,

   401

};

   402

   403

enum eeprom_offsets {

   404

	eeprom_cnfg_mdix  = 0x03,

   405

	eeprom_id         = 0x0A,

   406

	eeprom_config_asf = 0x0D,

   407

	eeprom_smbus_addr = 0x90,

   408

};

   409

   410

enum eeprom_cnfg_mdix {

   411

	eeprom_mdix_enabled = 0x0080,

   412

};

   413

   414

enum eeprom_id {

   415

	eeprom_id_wol = 0x0020,

   416

};

   417

   418

enum eeprom_config_asf {

   419

	eeprom_asf = 0x8000,

   420

	eeprom_gcl = 0x4000,

   421

};

   422

   423

enum cb_status {

   424

	cb_complete = 0x8000,

   425

	cb_ok       = 0x2000,

   426

};

   427

   428

enum cb_command {

   429

	cb_nop    = 0x0000,

   430

	cb_iaaddr = 0x0001,

   431

	cb_config = 0x0002,

   432

	cb_multi  = 0x0003,

   433

	cb_tx     = 0x0004,

   434

	cb_ucode  = 0x0005,

   435

	cb_dump   = 0x0006,

   436

	cb_tx_sf  = 0x0008,

   437

	cb_cid    = 0x1f00,

   438

	cb_i      = 0x2000,

   439

	cb_s      = 0x4000,

   440

	cb_el     = 0x8000,

   441

};

   442

   443

struct rfd {

   444

	u16 status;

   445

	u16 command;

   446

	u32 link;

   447

	u32 rbd;

   448

	u16 actual_size;

   449

	u16 size;

   450

};

   451

   452

struct rx {

   453

	struct rx *next, *prev;

   454

	struct sk_buff *skb;

   455

	dma_addr_t dma_addr;

   456

};

   457

   458

#if defined(__BIG_ENDIAN_BITFIELD)

   459

#define X(a,b)	b,a

   460

#else

   461

#define X(a,b)	a,b

   462

#endif

   463

struct config {

   464

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

   465

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

   466

/*2*/	u8 adaptive_ifs;

   467

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

   468

	   term_write_cache_line:1), pad3:4);

   469

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

   470

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

   471

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

   472

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

   473

	   rx_discard_overruns:1), rx_save_bad_frames:1);

   474

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

   475

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

   476

	   tx_dynamic_tbd:1);

   477

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

   478

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

   479

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

   480

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

   481

	   loopback:2);

   482

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

   483

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

   484

/*13*/	u8 ip_addr_lo;

   485

/*14*/	u8 ip_addr_hi;

   486

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

   487

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

   488

	   pad15_2:1), crs_or_cdt:1);

   489

/*16*/	u8 fc_delay_lo;

   490

/*17*/	u8 fc_delay_hi;

   491

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

   492

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

   493

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

   494

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

   495

	   full_duplex_force:1), full_duplex_pin:1);

   496

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

   497

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

   498

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

   499

	u8 pad_d102[9];

   500

};

   501

   502

#define E100_MAX_MULTICAST_ADDRS	64

   503

struct multi {

   504

	u16 count;

   505

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

   506

};

   507

   508

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

   509

#define UCODE_SIZE			134

   510

struct cb {

   511

	u16 status;

   512

	u16 command;

   513

	u32 link;

   514

	union {

   515

		u8 iaaddr[ETH_ALEN];

   516

		u32 ucode[UCODE_SIZE];

   517

		struct config config;

   518

		struct multi multi;

   519

		struct {

   520

			u32 tbd_array;

   521

			u16 tcb_byte_count;

   522

			u8 threshold;

   523

			u8 tbd_count;

   524

			struct {

   525

				u32 buf_addr;

   526

				u16 size;

   527

				u16 eol;

   528

			} tbd;