1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2006 Intel Corporation.

     5

     6

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

     7

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

     8

  version 2, as published by the Free Software Foundation.

     9

    10

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

    11

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12

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

    13

  more details.

    14

    15

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

    16

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

    17

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

    18

    19

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

    20

  the file called "COPYING".

    21

    22

  Contact Information:

    23

  Linux NICS <linux.nics@intel.com>

    24

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

    25

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

    26

    27

  vim: noexpandtab

    28

    29

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

    30

    31

#include "e1000-2.6.26-ethercat.h"

    32

#include <net/ip6_checksum.h>

    33

    34

char e1000_driver_name[] = "ec_e1000";

    35

static char e1000_driver_string[] = "EtherCAT Intel(R) PRO/1000 Network Driver";

    36

#ifndef CONFIG_E1000_NAPI

    37

#define DRIVERNAPI

    38

#else

    39

#define DRIVERNAPI "-NAPI"

    40

#endif

    41

#define DRV_VERSION "7.3.20-k2"DRIVERNAPI

    42

const char e1000_driver_version[] = DRV_VERSION;

    43

static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";

    44

    45

/* e1000_pci_tbl - PCI Device ID Table

    46

 *

    47

 * Last entry must be all 0s

    48

 *

    49

 * Macro expands to...

    50

 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

    51

 */

    52

#ifdef CONFIG_E1000E_ENABLED

    53

  #define PCIE(x) 

    54

#else

    55

  #define PCIE(x) x,

    56

#endif

    57

    58

static struct pci_device_id e1000_pci_tbl[] = {

    59

	INTEL_E1000_ETHERNET_DEVICE(0x1000),

    60

	INTEL_E1000_ETHERNET_DEVICE(0x1001),

    61

	INTEL_E1000_ETHERNET_DEVICE(0x1004),

    62

	INTEL_E1000_ETHERNET_DEVICE(0x1008),

    63

	INTEL_E1000_ETHERNET_DEVICE(0x1009),

    64

	INTEL_E1000_ETHERNET_DEVICE(0x100C),

    65

	INTEL_E1000_ETHERNET_DEVICE(0x100D),

    66

	INTEL_E1000_ETHERNET_DEVICE(0x100E),

    67

	INTEL_E1000_ETHERNET_DEVICE(0x100F),

    68

	INTEL_E1000_ETHERNET_DEVICE(0x1010),

    69

	INTEL_E1000_ETHERNET_DEVICE(0x1011),

    70

	INTEL_E1000_ETHERNET_DEVICE(0x1012),

    71

	INTEL_E1000_ETHERNET_DEVICE(0x1013),

    72

	INTEL_E1000_ETHERNET_DEVICE(0x1014),

    73

	INTEL_E1000_ETHERNET_DEVICE(0x1015),

    74

	INTEL_E1000_ETHERNET_DEVICE(0x1016),

    75

	INTEL_E1000_ETHERNET_DEVICE(0x1017),

    76

	INTEL_E1000_ETHERNET_DEVICE(0x1018),

    77

	INTEL_E1000_ETHERNET_DEVICE(0x1019),

    78

	INTEL_E1000_ETHERNET_DEVICE(0x101A),

    79

	INTEL_E1000_ETHERNET_DEVICE(0x101D),

    80

	INTEL_E1000_ETHERNET_DEVICE(0x101E),

    81

	INTEL_E1000_ETHERNET_DEVICE(0x1026),

    82

	INTEL_E1000_ETHERNET_DEVICE(0x1027),

    83

	INTEL_E1000_ETHERNET_DEVICE(0x1028),

    84

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x1049))

    85

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x104A))

    86

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x104B))

    87

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x104C))

    88

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x104D))

    89

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x105E))

    90

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x105F))

    91

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x1060))

    92

	INTEL_E1000_ETHERNET_DEVICE(0x1075),

    93

	INTEL_E1000_ETHERNET_DEVICE(0x1076),

    94

	INTEL_E1000_ETHERNET_DEVICE(0x1077),

    95

	INTEL_E1000_ETHERNET_DEVICE(0x1078),

    96

	INTEL_E1000_ETHERNET_DEVICE(0x1079),

    97

	INTEL_E1000_ETHERNET_DEVICE(0x107A),

    98

	INTEL_E1000_ETHERNET_DEVICE(0x107B),

    99

	INTEL_E1000_ETHERNET_DEVICE(0x107C),

   100

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x107D))

   101

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x107E))

   102

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x107F))

   103

	INTEL_E1000_ETHERNET_DEVICE(0x108A),

   104

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x108B))

   105

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x108C))

   106

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x1096))

   107

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x1098))

   108

	INTEL_E1000_ETHERNET_DEVICE(0x1099),

   109

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x109A))

   110

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10A4))

   111

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10A5))

   112

	INTEL_E1000_ETHERNET_DEVICE(0x10B5),

   113

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10B9))

   114

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10BA))

   115

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10BB))

   116

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10BC))

   117

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10C4))

   118

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10C5))

   119

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10D5))

   120

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10D9))

   121

PCIE(	INTEL_E1000_ETHERNET_DEVICE(0x10DA))

   122

	/* required last entry */

   123

	{0,}

   124

};

   125

   126

// do not auto-load driver

   127

// MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

   128

   129

int e1000_up(struct e1000_adapter *adapter);

   130

void e1000_down(struct e1000_adapter *adapter);

   131

void e1000_reinit_locked(struct e1000_adapter *adapter);

   132

void e1000_reset(struct e1000_adapter *adapter);

   133

int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);

   134

int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

   135

int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

   136

void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

   137

void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

   138

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

   139

                             struct e1000_tx_ring *txdr);

   140

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   141

                             struct e1000_rx_ring *rxdr);

   142

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   143

                             struct e1000_tx_ring *tx_ring);

   144

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   145

                             struct e1000_rx_ring *rx_ring);

   146

void e1000_update_stats(struct e1000_adapter *adapter);

   147

   148

static int e1000_init_module(void);

   149

static void e1000_exit_module(void);

   150

static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);

   151

static void __devexit e1000_remove(struct pci_dev *pdev);

   152

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   153

static int e1000_sw_init(struct e1000_adapter *adapter);

   154

static int e1000_open(struct net_device *netdev);

   155

static int e1000_close(struct net_device *netdev);

   156

static void e1000_configure_tx(struct e1000_adapter *adapter);

   157

static void e1000_configure_rx(struct e1000_adapter *adapter);

   158

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   159

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   160

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   161

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   162

                                struct e1000_tx_ring *tx_ring);

   163

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   164

                                struct e1000_rx_ring *rx_ring);

   165

static void e1000_set_rx_mode(struct net_device *netdev);

   166

static void e1000_update_phy_info(unsigned long data);

   167

static void e1000_watchdog(unsigned long data);

   168

static void e1000_82547_tx_fifo_stall(unsigned long data);

   169

static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);

   170

static struct net_device_stats * e1000_get_stats(struct net_device *netdev);

   171

static int e1000_change_mtu(struct net_device *netdev, int new_mtu);

   172

static int e1000_set_mac(struct net_device *netdev, void *p);

   173

void ec_poll(struct net_device *);

   174

static irqreturn_t e1000_intr(int irq, void *data);

   175

static irqreturn_t e1000_intr_msi(int irq, void *data);

   176

static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,

   177

			       struct e1000_tx_ring *tx_ring);

   178

#ifdef CONFIG_E1000_NAPI

   179

static int e1000_clean(struct napi_struct *napi, int budget);

   180

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   181

			       struct e1000_rx_ring *rx_ring,

   182

			       int *work_done, int work_to_do);

   183

static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   184

				  struct e1000_rx_ring *rx_ring,

   185

				  int *work_done, int work_to_do);

   186

#else

   187

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   188

			       struct e1000_rx_ring *rx_ring);

   189

static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   190

				  struct e1000_rx_ring *rx_ring);

   191

#endif

   192

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   193

                                   struct e1000_rx_ring *rx_ring,

   194

				   int cleaned_count);

   195

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   196

                                      struct e1000_rx_ring *rx_ring,

   197

				      int cleaned_count);

   198

static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);

   199

static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,

   200

			   int cmd);

   201

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   202

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   203

static void e1000_tx_timeout(struct net_device *dev);

   204

static void e1000_reset_task(struct work_struct *work);

   205

static void e1000_smartspeed(struct e1000_adapter *adapter);

   206

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   207

                                       struct sk_buff *skb);

   208

   209

static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);

   210

static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);

   211

static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);

   212

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   213

   214

static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);

   215

#ifdef CONFIG_PM

   216

static int e1000_resume(struct pci_dev *pdev);

   217

#endif

   218

static void e1000_shutdown(struct pci_dev *pdev);

   219

   220

#ifdef CONFIG_NET_POLL_CONTROLLER

   221

/* for netdump / net console */

   222

static void e1000_netpoll (struct net_device *netdev);

   223

#endif

   224

   225

#define COPYBREAK_DEFAULT 256

   226

static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;

   227

module_param(copybreak, uint, 0644);

   228

MODULE_PARM_DESC(copybreak,

   229

	"Maximum size of packet that is copied to a new buffer on receive");

   230

   231

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   232

                     pci_channel_state_t state);

   233

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   234

static void e1000_io_resume(struct pci_dev *pdev);

   235

   236

static struct pci_error_handlers e1000_err_handler = {

   237

	.error_detected = e1000_io_error_detected,

   238

	.slot_reset = e1000_io_slot_reset,

   239

	.resume = e1000_io_resume,

   240

};

   241

   242

static struct pci_driver e1000_driver = {

   243

	.name     = e1000_driver_name,

   244

	.id_table = e1000_pci_tbl,

   245

	.probe    = e1000_probe,

   246

	.remove   = __devexit_p(e1000_remove),

   247

#ifdef CONFIG_PM

   248

	/* Power Managment Hooks */

   249

	.suspend  = e1000_suspend,

   250

	.resume   = e1000_resume,

   251

#endif

   252

	.shutdown = e1000_shutdown,

   253

	.err_handler = &e1000_err_handler

   254

};

   255

   256

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

   257

MODULE_DESCRIPTION("EtherCAT-capable Intel(R) PRO/1000 Network Driver");

   258

MODULE_LICENSE("GPL");

   259

MODULE_VERSION(DRV_VERSION);

   260

   261

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   262

module_param(debug, int, 0);

   263

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

   264

   265

/**

   266

 * e1000_init_module - Driver Registration Routine

   267

 *

   268

 * e1000_init_module is the first routine called when the driver is

   269

 * loaded. All it does is register with the PCI subsystem.

   270

 **/

   271

   272

static int __init

   273

e1000_init_module(void)

   274

{

   275

	int ret;

   276

	printk(KERN_INFO "%s - version %s\n",

   277

	       e1000_driver_string, e1000_driver_version);

   278

   279

	printk(KERN_INFO "%s\n", e1000_copyright);

   280

   281

	ret = pci_register_driver(&e1000_driver);

   282

	if (copybreak != COPYBREAK_DEFAULT) {

   283

		if (copybreak == 0)

   284

			printk(KERN_INFO "e1000: copybreak disabled\n");

   285

		else

   286

			printk(KERN_INFO "e1000: copybreak enabled for "

   287

			       "packets <= %u bytes\n", copybreak);

   288

	}

   289

	return ret;

   290

}

   291

   292

module_init(e1000_init_module);

   293

   294

/**

   295

 * e1000_exit_module - Driver Exit Cleanup Routine

   296

 *

   297

 * e1000_exit_module is called just before the driver is removed

   298

 * from memory.

   299

 **/

   300

   301

static void __exit

   302

e1000_exit_module(void)

   303

{

   304

	pci_unregister_driver(&e1000_driver);

   305

}

   306

   307

module_exit(e1000_exit_module);

   308

   309

static int e1000_request_irq(struct e1000_adapter *adapter)

   310

{

   311

	struct net_device *netdev = adapter->netdev;

   312

	irq_handler_t handler = e1000_intr;

   313

	int irq_flags = IRQF_SHARED;

   314

	int err;

   315

   316

	if (adapter->ecdev)

   317

		return 0;

   318

   319

	if (adapter->hw.mac_type >= e1000_82571) {

   320

		adapter->have_msi = !pci_enable_msi(adapter->pdev);

   321

		if (adapter->have_msi) {

   322

			handler = e1000_intr_msi;

   323

			irq_flags = 0;

   324

		}

   325

	}

   326

   327

	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,

   328

	                  netdev);

   329

	if (err) {

   330

		if (adapter->have_msi)

   331

			pci_disable_msi(adapter->pdev);

   332

		DPRINTK(PROBE, ERR,

   333

		        "Unable to allocate interrupt Error: %d\n", err);

   334

	}

   335

   336

	return err;

   337

}

   338

   339

static void e1000_free_irq(struct e1000_adapter *adapter)

   340

{

   341

	struct net_device *netdev = adapter->netdev;

   342

   343

	if (adapter->ecdev)

   344

		return;

   345

   346

	free_irq(adapter->pdev->irq, netdev);

   347

   348

	if (adapter->have_msi)

   349

		pci_disable_msi(adapter->pdev);

   350

}

   351

   352

/**

   353

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   354

 * @adapter: board private structure

   355

 **/

   356

   357

static void

   358

e1000_irq_disable(struct e1000_adapter *adapter)

   359

{

   360

	if (adapter->ecdev)

   361

		return;

   362

   363

	E1000_WRITE_REG(&adapter->hw, IMC, ~0);

   364

	E1000_WRITE_FLUSH(&adapter->hw);

   365

	synchronize_irq(adapter->pdev->irq);

   366

}

   367

   368

/**

   369

 * e1000_irq_enable - Enable default interrupt generation settings

   370

 * @adapter: board private structure

   371

 **/

   372

   373

static void

   374

e1000_irq_enable(struct e1000_adapter *adapter)

   375

{

   376

	if (adapter->ecdev)

   377

		return;

   378

   379

	E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);

   380

	E1000_WRITE_FLUSH(&adapter->hw);

   381

}

   382

   383

static void

   384

e1000_update_mng_vlan(struct e1000_adapter *adapter)

   385

{

   386

	struct net_device *netdev = adapter->netdev;

   387

	u16 vid = adapter->hw.mng_cookie.vlan_id;

   388

	u16 old_vid = adapter->mng_vlan_id;

   389

	if (adapter->vlgrp) {

   390

		if (!vlan_group_get_device(adapter->vlgrp, vid)) {

   391

			if (adapter->hw.mng_cookie.status &

   392

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   393

				e1000_vlan_rx_add_vid(netdev, vid);

   394

				adapter->mng_vlan_id = vid;

   395

			} else

   396

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   397

   398

			if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&

   399

					(vid != old_vid) &&

   400

			    !vlan_group_get_device(adapter->vlgrp, old_vid))

   401

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   402

		} else

   403

			adapter->mng_vlan_id = vid;

   404

	}

   405

}

   406

   407

/**

   408

 * e1000_release_hw_control - release control of the h/w to f/w

   409

 * @adapter: address of board private structure

   410

 *

   411

 * e1000_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.

   412

 * For ASF and Pass Through versions of f/w this means that the

   413

 * driver is no longer loaded. For AMT version (only with 82573) i

   414

 * of the f/w this means that the network i/f is closed.

   415

 *

   416

 **/

   417

   418

static void

   419

e1000_release_hw_control(struct e1000_adapter *adapter)

   420

{

   421

	u32 ctrl_ext;

   422

	u32 swsm;

   423

   424

	/* Let firmware taken over control of h/w */

   425

	switch (adapter->hw.mac_type) {

   426

	case e1000_82573:

   427

		swsm = E1000_READ_REG(&adapter->hw, SWSM);

   428

		E1000_WRITE_REG(&adapter->hw, SWSM,

   429

				swsm & ~E1000_SWSM_DRV_LOAD);

   430

		break;

   431

	case e1000_82571:

   432

	case e1000_82572:

   433

	case e1000_80003es2lan:

   434

	case e1000_ich8lan:

   435

		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);

   436

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   437

				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);

   438

		break;

   439

	default:

   440

		break;

   441

	}

   442

}

   443

   444

/**

   445

 * e1000_get_hw_control - get control of the h/w from f/w

   446

 * @adapter: address of board private structure

   447

 *

   448

 * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.

   449

 * For ASF and Pass Through versions of f/w this means that

   450

 * the driver is loaded. For AMT version (only with 82573)

   451

 * of the f/w this means that the network i/f is open.

   452

 *

   453

 **/

   454

   455

static void

   456

e1000_get_hw_control(struct e1000_adapter *adapter)

   457

{

   458

	u32 ctrl_ext;

   459

	u32 swsm;

   460

   461

	/* Let firmware know the driver has taken over */

   462

	switch (adapter->hw.mac_type) {

   463

	case e1000_82573:

   464

		swsm = E1000_READ_REG(&adapter->hw, SWSM);

   465

		E1000_WRITE_REG(&adapter->hw, SWSM,

   466

				swsm | E1000_SWSM_DRV_LOAD);

   467

		break;

   468

	case e1000_82571:

   469

	case e1000_82572:

   470

	case e1000_80003es2lan:

   471

	case e1000_ich8lan:

   472

		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);

   473

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   474

				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);

   475

		break;

   476

	default:

   477

		break;

   478

	}

   479

}

   480

   481

static void

   482

e1000_init_manageability(struct e1000_adapter *adapter)

   483

{

   484

	if (adapter->en_mng_pt) {

   485

		u32 manc = E1000_READ_REG(&adapter->hw, MANC);

   486

   487

		/* disable hardware interception of ARP */

   488

		manc &= ~(E1000_MANC_ARP_EN);

   489

   490

		/* enable receiving management packets to the host */

   491

		/* this will probably generate destination unreachable messages

   492

		 * from the host OS, but the packets will be handled on SMBUS */

   493

		if (adapter->hw.has_manc2h) {

   494

			u32 manc2h = E1000_READ_REG(&adapter->hw, MANC2H);

   495

   496

			manc |= E1000_MANC_EN_MNG2HOST;

   497

#define E1000_MNG2HOST_PORT_623 (1 << 5)

   498

#define E1000_MNG2HOST_PORT_664 (1 << 6)

   499

			manc2h |= E1000_MNG2HOST_PORT_623;

   500

			manc2h |= E1000_MNG2HOST_PORT_664;

   501

			E1000_WRITE_REG(&adapter->hw, MANC2H, manc2h);

   502

		}

   503

   504

		E1000_WRITE_REG(&adapter->hw, MANC, manc);

   505

	}

   506

}

   507

   508

static void

   509

e1000_release_manageability(struct e1000_adapter *adapter)

   510

{

   511

	if (adapter->en_mng_pt) {

   512

		u32 manc = E1000_READ_REG(&adapter->hw, MANC);

   513

   514

		/* re-enable hardware interception of ARP */

   515

		manc |= E1000_MANC_ARP_EN;

   516

   517

		if (adapter->hw.has_manc2h)

   518

			manc &= ~E1000_MANC_EN_MNG2HOST;

   519

   520

		/* don't explicitly have to mess with MANC2H since

   521

		 * MANC has an enable disable that gates MANC2H */

   522

   523

		E1000_WRITE_REG(&adapter->hw, MANC, manc);

   524

	}

   525

}

   526

   527

/**

   528

 * e1000_configure - configure the hardware for RX and TX

   529

 * @adapter = private board structure