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

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

    28

    29

#include "e1000.h"

    30

#include <net/ip6_checksum.h>

    31

    32

char e1000_driver_name[] = "e1000";

    33

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

    34

#ifndef CONFIG_E1000_NAPI

    35

#define DRIVERNAPI

    36

#else

    37

#define DRIVERNAPI "-NAPI"

    38

#endif

    39

#define DRV_VERSION "7.3.15-k2"DRIVERNAPI

    40

char e1000_driver_version[] = DRV_VERSION;

    41

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

    42

    43

/* e1000_pci_tbl - PCI Device ID Table

    44

 *

    45

 * Last entry must be all 0s

    46

 *

    47

 * Macro expands to...

    48

 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

    49

 */

    50

static struct pci_device_id e1000_pci_tbl[] = {

    51

	INTEL_E1000_ETHERNET_DEVICE(0x1000),

    52

	INTEL_E1000_ETHERNET_DEVICE(0x1001),

    53

	INTEL_E1000_ETHERNET_DEVICE(0x1004),

    54

	INTEL_E1000_ETHERNET_DEVICE(0x1008),

    55

	INTEL_E1000_ETHERNET_DEVICE(0x1009),

    56

	INTEL_E1000_ETHERNET_DEVICE(0x100C),

    57

	INTEL_E1000_ETHERNET_DEVICE(0x100D),

    58

	INTEL_E1000_ETHERNET_DEVICE(0x100E),

    59

	INTEL_E1000_ETHERNET_DEVICE(0x100F),

    60

	INTEL_E1000_ETHERNET_DEVICE(0x1010),

    61

	INTEL_E1000_ETHERNET_DEVICE(0x1011),

    62

	INTEL_E1000_ETHERNET_DEVICE(0x1012),

    63

	INTEL_E1000_ETHERNET_DEVICE(0x1013),

    64

	INTEL_E1000_ETHERNET_DEVICE(0x1014),

    65

	INTEL_E1000_ETHERNET_DEVICE(0x1015),

    66

	INTEL_E1000_ETHERNET_DEVICE(0x1016),

    67

	INTEL_E1000_ETHERNET_DEVICE(0x1017),

    68

	INTEL_E1000_ETHERNET_DEVICE(0x1018),

    69

	INTEL_E1000_ETHERNET_DEVICE(0x1019),

    70

	INTEL_E1000_ETHERNET_DEVICE(0x101A),

    71

	INTEL_E1000_ETHERNET_DEVICE(0x101D),

    72

	INTEL_E1000_ETHERNET_DEVICE(0x101E),

    73

	INTEL_E1000_ETHERNET_DEVICE(0x1026),

    74

	INTEL_E1000_ETHERNET_DEVICE(0x1027),

    75

	INTEL_E1000_ETHERNET_DEVICE(0x1028),

    76

	INTEL_E1000_ETHERNET_DEVICE(0x1049),

    77

	INTEL_E1000_ETHERNET_DEVICE(0x104A),

    78

	INTEL_E1000_ETHERNET_DEVICE(0x104B),

    79

	INTEL_E1000_ETHERNET_DEVICE(0x104C),

    80

	INTEL_E1000_ETHERNET_DEVICE(0x104D),

    81

	INTEL_E1000_ETHERNET_DEVICE(0x105E),

    82

	INTEL_E1000_ETHERNET_DEVICE(0x105F),

    83

	INTEL_E1000_ETHERNET_DEVICE(0x1060),

    84

	INTEL_E1000_ETHERNET_DEVICE(0x1075),

    85

	INTEL_E1000_ETHERNET_DEVICE(0x1076),

    86

	INTEL_E1000_ETHERNET_DEVICE(0x1077),

    87

	INTEL_E1000_ETHERNET_DEVICE(0x1078),

    88

	INTEL_E1000_ETHERNET_DEVICE(0x1079),

    89

	INTEL_E1000_ETHERNET_DEVICE(0x107A),

    90

	INTEL_E1000_ETHERNET_DEVICE(0x107B),

    91

	INTEL_E1000_ETHERNET_DEVICE(0x107C),

    92

	INTEL_E1000_ETHERNET_DEVICE(0x107D),

    93

	INTEL_E1000_ETHERNET_DEVICE(0x107E),

    94

	INTEL_E1000_ETHERNET_DEVICE(0x107F),

    95

	INTEL_E1000_ETHERNET_DEVICE(0x108A),

    96

	INTEL_E1000_ETHERNET_DEVICE(0x108B),

    97

	INTEL_E1000_ETHERNET_DEVICE(0x108C),

    98

	INTEL_E1000_ETHERNET_DEVICE(0x1096),

    99

	INTEL_E1000_ETHERNET_DEVICE(0x1098),

   100

	INTEL_E1000_ETHERNET_DEVICE(0x1099),

   101

	INTEL_E1000_ETHERNET_DEVICE(0x109A),

   102

	INTEL_E1000_ETHERNET_DEVICE(0x10A4),

   103

	INTEL_E1000_ETHERNET_DEVICE(0x10B5),

   104

	INTEL_E1000_ETHERNET_DEVICE(0x10B9),

   105

	INTEL_E1000_ETHERNET_DEVICE(0x10BA),

   106

	INTEL_E1000_ETHERNET_DEVICE(0x10BB),

   107

	INTEL_E1000_ETHERNET_DEVICE(0x10BC),

   108

	INTEL_E1000_ETHERNET_DEVICE(0x10C4),

   109

	INTEL_E1000_ETHERNET_DEVICE(0x10C5),

   110

	/* required last entry */

   111

	{0,}

   112

};

   113

   114

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

   115

   116

int e1000_up(struct e1000_adapter *adapter);

   117

void e1000_down(struct e1000_adapter *adapter);

   118

void e1000_reinit_locked(struct e1000_adapter *adapter);

   119

void e1000_reset(struct e1000_adapter *adapter);

   120

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

   121

int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

   122

int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

   123

void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

   124

void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

   125

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

   126

                             struct e1000_tx_ring *txdr);

   127

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   128

                             struct e1000_rx_ring *rxdr);

   129

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   130

                             struct e1000_tx_ring *tx_ring);

   131

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   132

                             struct e1000_rx_ring *rx_ring);

   133

void e1000_update_stats(struct e1000_adapter *adapter);

   134

   135

static int e1000_init_module(void);

   136

static void e1000_exit_module(void);

   137

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

   138

static void __devexit e1000_remove(struct pci_dev *pdev);

   139

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   140

static int e1000_sw_init(struct e1000_adapter *adapter);

   141

static int e1000_open(struct net_device *netdev);

   142

static int e1000_close(struct net_device *netdev);

   143

static void e1000_configure_tx(struct e1000_adapter *adapter);

   144

static void e1000_configure_rx(struct e1000_adapter *adapter);

   145

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   146

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   147

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   148

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   149

                                struct e1000_tx_ring *tx_ring);

   150

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   151

                                struct e1000_rx_ring *rx_ring);

   152

static void e1000_set_multi(struct net_device *netdev);

   153

static void e1000_update_phy_info(unsigned long data);

   154

static void e1000_watchdog(unsigned long data);

   155

static void e1000_82547_tx_fifo_stall(unsigned long data);

   156

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

   157

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

   158

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

   159

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

   160

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

   161

#ifdef CONFIG_PCI_MSI

   162

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

   163

#endif

   164

static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,

   165

                                    struct e1000_tx_ring *tx_ring);

   166

#ifdef CONFIG_E1000_NAPI

   167

static int e1000_clean(struct net_device *poll_dev, int *budget);

   168

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,

   169

                                    struct e1000_rx_ring *rx_ring,

   170

                                    int *work_done, int work_to_do);

   171

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   172

                                       struct e1000_rx_ring *rx_ring,

   173

                                       int *work_done, int work_to_do);

   174

#else

   175

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,

   176

                                    struct e1000_rx_ring *rx_ring);

   177

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   178

                                       struct e1000_rx_ring *rx_ring);

   179

#endif

   180

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   181

                                   struct e1000_rx_ring *rx_ring,

   182

				   int cleaned_count);

   183

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   184

                                      struct e1000_rx_ring *rx_ring,

   185

				      int cleaned_count);

   186

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

   187

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

   188

			   int cmd);

   189

void e1000_set_ethtool_ops(struct net_device *netdev);

   190

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   191

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   192

static void e1000_tx_timeout(struct net_device *dev);

   193

static void e1000_reset_task(struct work_struct *work);

   194

static void e1000_smartspeed(struct e1000_adapter *adapter);

   195

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   196

                                       struct sk_buff *skb);

   197

   198

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

   199

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

   200

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

   201

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   202

   203

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

   204

#ifdef CONFIG_PM

   205

static int e1000_resume(struct pci_dev *pdev);

   206

#endif

   207

static void e1000_shutdown(struct pci_dev *pdev);

   208

   209

#ifdef CONFIG_NET_POLL_CONTROLLER

   210

/* for netdump / net console */

   211

static void e1000_netpoll (struct net_device *netdev);

   212

#endif

   213

   214

extern void e1000_check_options(struct e1000_adapter *adapter);

   215

   216

#define COPYBREAK_DEFAULT 256

   217

static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;

   218

module_param(copybreak, uint, 0644);

   219

MODULE_PARM_DESC(copybreak,

   220

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

   221

   222

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   223

                     pci_channel_state_t state);

   224

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   225

static void e1000_io_resume(struct pci_dev *pdev);

   226

   227

static struct pci_error_handlers e1000_err_handler = {

   228

	.error_detected = e1000_io_error_detected,

   229

	.slot_reset = e1000_io_slot_reset,

   230

	.resume = e1000_io_resume,

   231

};

   232

   233

static struct pci_driver e1000_driver = {

   234

	.name     = e1000_driver_name,

   235

	.id_table = e1000_pci_tbl,

   236

	.probe    = e1000_probe,

   237

	.remove   = __devexit_p(e1000_remove),

   238

#ifdef CONFIG_PM

   239

	/* Power Managment Hooks */

   240

	.suspend  = e1000_suspend,

   241

	.resume   = e1000_resume,

   242

#endif

   243

	.shutdown = e1000_shutdown,

   244

	.err_handler = &e1000_err_handler

   245

};

   246

   247

MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");

   248

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

   249

MODULE_LICENSE("GPL");

   250

MODULE_VERSION(DRV_VERSION);

   251

   252

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   253

module_param(debug, int, 0);

   254

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

   255

   256

/**

   257

 * e1000_init_module - Driver Registration Routine

   258

 *

   259

 * e1000_init_module is the first routine called when the driver is

   260

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

   261

 **/

   262

   263

static int __init

   264

e1000_init_module(void)

   265

{

   266

	int ret;

   267

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

   268

	       e1000_driver_string, e1000_driver_version);

   269

   270

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

   271

   272

	ret = pci_register_driver(&e1000_driver);

   273

	if (copybreak != COPYBREAK_DEFAULT) {

   274

		if (copybreak == 0)

   275

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

   276

		else

   277

			printk(KERN_INFO "e1000: copybreak enabled for "

   278

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

   279

	}

   280

	return ret;

   281

}

   282

   283

module_init(e1000_init_module);

   284

   285

/**

   286

 * e1000_exit_module - Driver Exit Cleanup Routine

   287

 *

   288

 * e1000_exit_module is called just before the driver is removed

   289

 * from memory.

   290

 **/

   291

   292

static void __exit

   293

e1000_exit_module(void)

   294

{

   295

	pci_unregister_driver(&e1000_driver);

   296

}

   297

   298

module_exit(e1000_exit_module);

   299

   300

static int e1000_request_irq(struct e1000_adapter *adapter)

   301

{

   302

	struct net_device *netdev = adapter->netdev;

   303

	int flags, err = 0;

   304

   305

	flags = IRQF_SHARED;

   306

#ifdef CONFIG_PCI_MSI

   307

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

   308

		adapter->have_msi = TRUE;

   309

		if ((err = pci_enable_msi(adapter->pdev))) {

   310

			DPRINTK(PROBE, ERR,

   311

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

   312

			adapter->have_msi = FALSE;

   313

		}

   314

	}

   315

	if (adapter->have_msi) {

   316

		flags &= ~IRQF_SHARED;

   317

		err = request_irq(adapter->pdev->irq, &e1000_intr_msi, flags,

   318

		                  netdev->name, netdev);

   319

		if (err)

   320

			DPRINTK(PROBE, ERR,

   321

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

   322

	} else

   323

#endif

   324

	if ((err = request_irq(adapter->pdev->irq, &e1000_intr, flags,

   325

	                       netdev->name, netdev)))

   326

		DPRINTK(PROBE, ERR,

   327

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

   328

   329

	return err;

   330

}

   331

   332

static void e1000_free_irq(struct e1000_adapter *adapter)

   333

{

   334

	struct net_device *netdev = adapter->netdev;

   335

   336

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

   337

   338

#ifdef CONFIG_PCI_MSI

   339

	if (adapter->have_msi)

   340

		pci_disable_msi(adapter->pdev);

   341

#endif

   342

}

   343

   344

/**

   345

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   346

 * @adapter: board private structure

   347

 **/

   348

   349

static void

   350

e1000_irq_disable(struct e1000_adapter *adapter)

   351

{

   352

	atomic_inc(&adapter->irq_sem);

   353

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

   354

	E1000_WRITE_FLUSH(&adapter->hw);

   355

	synchronize_irq(adapter->pdev->irq);

   356

}

   357

   358

/**

   359

 * e1000_irq_enable - Enable default interrupt generation settings

   360

 * @adapter: board private structure

   361

 **/

   362

   363

static void

   364

e1000_irq_enable(struct e1000_adapter *adapter)

   365

{

   366

	if (likely(atomic_dec_and_test(&adapter->irq_sem))) {

   367

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

   368

		E1000_WRITE_FLUSH(&adapter->hw);

   369

	}

   370

}

   371

   372

static void

   373

e1000_update_mng_vlan(struct e1000_adapter *adapter)

   374

{

   375

	struct net_device *netdev = adapter->netdev;

   376

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

   377

	uint16_t old_vid = adapter->mng_vlan_id;

   378

	if (adapter->vlgrp) {

   379

		if (!adapter->vlgrp->vlan_devices[vid]) {

   380

			if (adapter->hw.mng_cookie.status &

   381

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   382

				e1000_vlan_rx_add_vid(netdev, vid);

   383

				adapter->mng_vlan_id = vid;

   384

			} else

   385

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   386

   387

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

   388

					(vid != old_vid) &&

   389

					!adapter->vlgrp->vlan_devices[old_vid])

   390

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   391

		} else

   392

			adapter->mng_vlan_id = vid;

   393

	}

   394

}

   395

   396

/**

   397

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

   398

 * @adapter: address of board private structure

   399

 *

   400

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

   401

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

   402

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

   403

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

   404

 *

   405

 **/

   406

   407

static void

   408

e1000_release_hw_control(struct e1000_adapter *adapter)

   409

{

   410

	uint32_t ctrl_ext;

   411

	uint32_t swsm;

   412

	uint32_t extcnf;

   413

   414

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

   415

	switch (adapter->hw.mac_type) {

   416

	case e1000_82571:

   417

	case e1000_82572:

   418

	case e1000_80003es2lan:

   419

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

   420

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   421

				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);

   422

		break;

   423

	case e1000_82573:

   424

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

   425

		E1000_WRITE_REG(&adapter->hw, SWSM,

   426

				swsm & ~E1000_SWSM_DRV_LOAD);

   427

	case e1000_ich8lan:

   428

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

   429

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   430

				extcnf & ~E1000_CTRL_EXT_DRV_LOAD);

   431

		break;

   432

	default:

   433

		break;

   434

	}

   435

}

   436

   437

/**

   438

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

   439

 * @adapter: address of board private structure

   440

 *

   441

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

   442

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

   443

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

   444

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

   445

 *

   446

 **/

   447

   448

static void

   449

e1000_get_hw_control(struct e1000_adapter *adapter)

   450

{

   451

	uint32_t ctrl_ext;

   452

	uint32_t swsm;

   453

	uint32_t extcnf;

   454

   455

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

   456

	switch (adapter->hw.mac_type) {

   457

	case e1000_82571:

   458

	case e1000_82572:

   459

	case e1000_80003es2lan:

   460

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

   461

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   462

				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);

   463

		break;

   464

	case e1000_82573:

   465

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

   466

		E1000_WRITE_REG(&adapter->hw, SWSM,

   467

				swsm | E1000_SWSM_DRV_LOAD);

   468

		break;

   469

	case e1000_ich8lan:

   470

		extcnf = E1000_READ_REG(&adapter->hw, EXTCNF_CTRL);

   471

		E1000_WRITE_REG(&adapter->hw, EXTCNF_CTRL,

   472

				extcnf | E1000_EXTCNF_CTRL_SWFLAG);

   473

		break;

   474

	default:

   475

		break;

   476

	}

   477

}

   478

   479

static void

   480

e1000_init_manageability(struct e1000_adapter *adapter)

   481

{

   482

	if (adapter->en_mng_pt) {

   483

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

   484

   485

		/* disable hardware interception of ARP */

   486

		manc &= ~(E1000_MANC_ARP_EN);

   487

   488

		/* enable receiving management packets to the host */

   489

		/* this will probably generate destination unreachable messages

   490

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

   491

		if (adapter->hw.has_manc2h) {

   492

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

   493

   494

			manc |= E1000_MANC_EN_MNG2HOST;

   495

#define E1000_MNG2HOST_PORT_623 (1 << 5)

   496

#define E1000_MNG2HOST_PORT_664 (1 << 6)

   497

			manc2h |= E1000_MNG2HOST_PORT_623;

   498

			manc2h |= E1000_MNG2HOST_PORT_664;

   499

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

   500

		}

   501

   502

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

   503

	}

   504

}

   505

   506

static void

   507

e1000_release_manageability(struct e1000_adapter *adapter)

   508

{

   509

	if (adapter->en_mng_pt) {

   510

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

   511

   512

		/* re-enable hardware interception of ARP */

   513

		manc |= E1000_MANC_ARP_EN;

   514

   515

		if (adapter->hw.has_manc2h)

   516

			manc &= ~E1000_MANC_EN_MNG2HOST;

   517

   518

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

   519

		 * MANC has an enable disable that gates MANC2H */

   520

   521

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

   522

	}

   523

}

   524

   525

int

   526

e1000_up(struct e1000_adapter *adapter)

   527

{

   528

	struct net_device *netdev = adapter->netdev;

   529

	int i;

   530