1

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

     2

     3

     4

  Copyright(c) 1999 - 2006 Intel Corporation. All rights reserved.

     5

     6

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

     7

  under the terms of the GNU General Public License as published by the Free 

     8

  Software Foundation; either version 2 of the License, or (at your option) 

     9

  any later version.

    10

    11

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

    12

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

    13

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

    14

  more details.

    15

    16

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

    17

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

    18

  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

    20

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

    21

  file called LICENSE.

    22

    23

  Contact Information:

    24

  Linux NICS <linux.nics@intel.com>

    25

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

    26

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

    27

    28

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

    29

    30

#include "e1000-2.6.18-ethercat.h"

    31

    32

char e1000_driver_name[] = "ec_e1000";

    33

static char e1000_driver_string[] = "EtherCAT 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.1.9-k4"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(0x10B5),

   103

	INTEL_E1000_ETHERNET_DEVICE(0x10B9),

   104

	INTEL_E1000_ETHERNET_DEVICE(0x10BA),

   105

	INTEL_E1000_ETHERNET_DEVICE(0x10BB),

   106

	/* required last entry */

   107

	{0,}

   108

};

   109

   110

// do not auto-load driver

   111

// MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

   112

   113

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

   114

                                    struct e1000_tx_ring *txdr);

   115

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   116

                                    struct e1000_rx_ring *rxdr);

   117

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   118

                                    struct e1000_tx_ring *tx_ring);

   119

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   120

                                    struct e1000_rx_ring *rx_ring);

   121

   122

/* Local Function Prototypes */

   123

   124

static int e1000_init_module(void);

   125

static void e1000_exit_module(void);

   126

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

   127

static void __devexit e1000_remove(struct pci_dev *pdev);

   128

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   129

static int e1000_sw_init(struct e1000_adapter *adapter);

   130

static int e1000_open(struct net_device *netdev);

   131

static int e1000_close(struct net_device *netdev);

   132

static void e1000_configure_tx(struct e1000_adapter *adapter);

   133

static void e1000_configure_rx(struct e1000_adapter *adapter);

   134

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   135

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   136

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   137

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   138

                                struct e1000_tx_ring *tx_ring);

   139

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   140

                                struct e1000_rx_ring *rx_ring);

   141

static void e1000_set_multi(struct net_device *netdev);

   142

static void e1000_update_phy_info(unsigned long data);

   143

static void e1000_watchdog(unsigned long data);

   144

static void e1000_82547_tx_fifo_stall(unsigned long data);

   145

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

   146

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

   147

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

   148

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

   149

void ec_poll(struct net_device *);

   150

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

   151

static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,

   152

                                    struct e1000_tx_ring *tx_ring);

   153

#ifdef CONFIG_E1000_NAPI

   154

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

   155

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,

   156

                                    struct e1000_rx_ring *rx_ring,

   157

                                    int *work_done, int work_to_do);

   158

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   159

                                       struct e1000_rx_ring *rx_ring,

   160

                                       int *work_done, int work_to_do);

   161

#else

   162

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,

   163

                                    struct e1000_rx_ring *rx_ring);

   164

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   165

                                       struct e1000_rx_ring *rx_ring);

   166

#endif

   167

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   168

                                   struct e1000_rx_ring *rx_ring,

   169

				   int cleaned_count);

   170

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   171

                                      struct e1000_rx_ring *rx_ring,

   172

				      int cleaned_count);

   173

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

   174

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

   175

			   int cmd);

   176

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   177

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   178

static void e1000_tx_timeout(struct net_device *dev);

   179

static void e1000_reset_task(struct net_device *dev);

   180

static void e1000_smartspeed(struct e1000_adapter *adapter);

   181

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   182

                                       struct sk_buff *skb);

   183

   184

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

   185

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

   186

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

   187

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   188

   189

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

   190

#ifdef CONFIG_PM

   191

static int e1000_resume(struct pci_dev *pdev);

   192

#endif

   193

static void e1000_shutdown(struct pci_dev *pdev);

   194

   195

#ifdef CONFIG_NET_POLL_CONTROLLER

   196

/* for netdump / net console */

   197

static void e1000_netpoll (struct net_device *netdev);

   198

#endif

   199

   200

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   201

                     pci_channel_state_t state);

   202

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   203

static void e1000_io_resume(struct pci_dev *pdev);

   204

   205

static struct pci_error_handlers e1000_err_handler = {

   206

	.error_detected = e1000_io_error_detected,

   207

	.slot_reset = e1000_io_slot_reset,

   208

	.resume = e1000_io_resume,

   209

};

   210

   211

static struct pci_driver e1000_driver = {

   212

	.name     = e1000_driver_name,

   213

	.id_table = e1000_pci_tbl,

   214

	.probe    = e1000_probe,

   215

	.remove   = __devexit_p(e1000_remove),

   216

	/* Power Managment Hooks */

   217

	.suspend  = e1000_suspend,

   218

#ifdef CONFIG_PM

   219

	.resume   = e1000_resume,

   220

#endif

   221

	.shutdown = e1000_shutdown,

   222

	.err_handler = &e1000_err_handler

   223

};

   224

   225

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

   226

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

   227

MODULE_LICENSE("GPL");

   228

MODULE_VERSION(DRV_VERSION);

   229

   230

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   231

module_param(debug, int, 0);

   232

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

   233

   234

/**

   235

 * e1000_init_module - Driver Registration Routine

   236

 *

   237

 * e1000_init_module is the first routine called when the driver is

   238

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

   239

 **/

   240

   241

static int __init

   242

e1000_init_module(void)

   243

{

   244

	int ret;

   245

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

   246

	       e1000_driver_string, e1000_driver_version);

   247

   248

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

   249

   250

	ret = pci_module_init(&e1000_driver);

   251

   252

	return ret;

   253

}

   254

   255

module_init(e1000_init_module);

   256

   257

/**

   258

 * e1000_exit_module - Driver Exit Cleanup Routine

   259

 *

   260

 * e1000_exit_module is called just before the driver is removed

   261

 * from memory.

   262

 **/

   263

   264

static void __exit

   265

e1000_exit_module(void)

   266

{

   267

	pci_unregister_driver(&e1000_driver);

   268

}

   269

   270

module_exit(e1000_exit_module);

   271

   272

static int e1000_request_irq(struct e1000_adapter *adapter) // not called when EtherCAT

   273

{

   274

	struct net_device *netdev = adapter->netdev;

   275

	int flags, err = 0;

   276

   277

	flags = IRQF_SHARED;

   278

#ifdef CONFIG_PCI_MSI

   279

	if (adapter->hw.mac_type > e1000_82547_rev_2) {

   280

		adapter->have_msi = TRUE;

   281

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

   282

			DPRINTK(PROBE, ERR,

   283

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

   284

			adapter->have_msi = FALSE;

   285

		}

   286

	}

   287

	if (adapter->have_msi)

   288

		flags &= ~IRQF_SHARED;

   289

#endif

   290

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

   291

	                       netdev->name, netdev)))

   292

		DPRINTK(PROBE, ERR,

   293

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

   294

   295

	return err;

   296

}

   297

   298

static void e1000_free_irq(struct e1000_adapter *adapter) // not called when EtherCAT

   299

{

   300

	struct net_device *netdev = adapter->netdev;

   301

   302

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

   303

   304

#ifdef CONFIG_PCI_MSI

   305

	if (adapter->have_msi)

   306

		pci_disable_msi(adapter->pdev);

   307

#endif

   308

}

   309

   310

/**

   311

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   312

 * @adapter: board private structure

   313

 **/

   314

   315

static void

   316

e1000_irq_disable(struct e1000_adapter *adapter)

   317

{

   318

	atomic_inc(&adapter->irq_sem);

   319

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

   320

	E1000_WRITE_FLUSH(&adapter->hw);

   321

	synchronize_irq(adapter->pdev->irq);

   322

}

   323

   324

/**

   325

 * e1000_irq_enable - Enable default interrupt generation settings

   326

 * @adapter: board private structure

   327

 **/

   328

   329

static void

   330

e1000_irq_enable(struct e1000_adapter *adapter)

   331

{

   332

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

   333

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

   334

		E1000_WRITE_FLUSH(&adapter->hw);

   335

	}

   336

}

   337

   338

static void

   339

e1000_update_mng_vlan(struct e1000_adapter *adapter)

   340

{

   341

	struct net_device *netdev = adapter->netdev;

   342

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

   343

	uint16_t old_vid = adapter->mng_vlan_id;

   344

	if (adapter->vlgrp) {

   345

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

   346

			if (adapter->hw.mng_cookie.status &

   347

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   348

				e1000_vlan_rx_add_vid(netdev, vid);

   349

				adapter->mng_vlan_id = vid;

   350

			} else

   351

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   352

   353

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

   354

					(vid != old_vid) &&

   355

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

   356

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   357

		} else

   358

			adapter->mng_vlan_id = vid;

   359

	}

   360

}

   361

   362

/**

   363

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

   364

 * @adapter: address of board private structure

   365

 *

   366

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

   367

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

   368

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

   369

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

   370

 *

   371

 **/

   372

   373

static void

   374

e1000_release_hw_control(struct e1000_adapter *adapter)

   375

{

   376

	uint32_t ctrl_ext;

   377

	uint32_t swsm;

   378

	uint32_t extcnf;

   379

   380

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

   381

	switch (adapter->hw.mac_type) {

   382

	case e1000_82571:

   383

	case e1000_82572:

   384

	case e1000_80003es2lan:

   385

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

   386

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   387

				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);

   388

		break;

   389

	case e1000_82573:

   390

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

   391

		E1000_WRITE_REG(&adapter->hw, SWSM,

   392

				swsm & ~E1000_SWSM_DRV_LOAD);

   393

	case e1000_ich8lan:

   394

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

   395

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   396

				extcnf & ~E1000_CTRL_EXT_DRV_LOAD);

   397

		break;

   398

	default:

   399

		break;

   400

	}

   401

}

   402

   403

/**

   404

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

   405

 * @adapter: address of board private structure

   406

 *

   407

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

   408

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

   409

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

   410

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

   411

 *

   412

 **/

   413

   414

static void

   415

e1000_get_hw_control(struct e1000_adapter *adapter)

   416

{

   417

	uint32_t ctrl_ext;

   418

	uint32_t swsm;

   419

	uint32_t extcnf;

   420

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

   421

	switch (adapter->hw.mac_type) {

   422

	case e1000_82571:

   423

	case e1000_82572:

   424

	case e1000_80003es2lan:

   425

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

   426

		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,

   427

				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);

   428

		break;

   429

	case e1000_82573:

   430

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

   431

		E1000_WRITE_REG(&adapter->hw, SWSM,

   432

				swsm | E1000_SWSM_DRV_LOAD);

   433

		break;

   434

	case e1000_ich8lan:

   435

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

   436

		E1000_WRITE_REG(&adapter->hw, EXTCNF_CTRL,

   437

				extcnf | E1000_EXTCNF_CTRL_SWFLAG);

   438

		break;

   439

	default:

   440

		break;

   441

	}

   442

}

   443

   444

int

   445

e1000_up(struct e1000_adapter *adapter)

   446

{

   447

	struct net_device *netdev = adapter->netdev;

   448

	int i;

   449

   450

	/* hardware has been reset, we need to reload some things */

   451

   452

	e1000_set_multi(netdev);

   453

   454

	e1000_restore_vlan(adapter);

   455

   456

	e1000_configure_tx(adapter);

   457

	e1000_setup_rctl(adapter);

   458

	e1000_configure_rx(adapter);

   459

	/* call E1000_DESC_UNUSED which always leaves

   460

	 * at least 1 descriptor unused to make sure

   461

	 * next_to_use != next_to_clean */

   462

	for (i = 0; i < adapter->num_rx_queues; i++) {

   463

		struct e1000_rx_ring *ring = &adapter->rx_ring[i];

   464

		adapter->alloc_rx_buf(adapter, ring,

   465

		                      E1000_DESC_UNUSED(ring));

   466

	}

   467

   468

	adapter->tx_queue_len = netdev->tx_queue_len;

   469

   470

	mod_timer(&adapter->watchdog_timer, jiffies);

   471

   472

#ifdef CONFIG_E1000_NAPI

   473

	if (!adapter->ecdev) netif_poll_enable(netdev);

   474

#endif

   475

	e1000_irq_enable(adapter);

   476

   477

	return 0;

   478

}

   479

   480

/**

   481

 * e1000_power_up_phy - restore link in case the phy was powered down

   482

 * @adapter: address of board private structure

   483

 *

   484

 * The phy may be powered down to save power and turn off link when the

   485

 * driver is unloaded and wake on lan is not enabled (among others)

   486

 * *** this routine MUST be followed by a call to e1000_reset ***

   487

 *

   488

 **/

   489

   490

static void e1000_power_up_phy(struct e1000_adapter *adapter)

   491

{

   492

	uint16_t mii_reg = 0;

   493

   494

	/* Just clear the power down bit to wake the phy back up */

   495

	if (adapter->hw.media_type == e1000_media_type_copper) {

   496

		/* according to the manual, the phy will retain its

   497

		 * settings across a power-down/up cycle */

   498

		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);

   499

		mii_reg &= ~MII_CR_POWER_DOWN;

   500

		e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);

   501

	}

   502

}

   503

   504

static void e1000_power_down_phy(struct e1000_adapter *adapter)

   505

{

   506

	boolean_t mng_mode_enabled = (adapter->hw.mac_type >= e1000_82571) &&

   507

	                              e1000_check_mng_mode(&adapter->hw);

   508

	/* Power down the PHY so no link is implied when interface is down

   509

	 * The PHY cannot be powered down if any of the following is TRUE

   510

	 * (a) WoL is enabled

   511

	 * (b) AMT is active

   512

	 * (c) SoL/IDER session is active */

   513

	if (!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&

   514

	    adapter->hw.mac_type != e1000_ich8lan &&

   515

	    adapter->hw.media_type == e1000_media_type_copper &&

   516

	    !(E1000_READ_REG(&adapter->hw, MANC) & E1000_MANC_SMBUS_EN) &&

   517

	    !mng_mode_enabled &&

   518

	    !e1000_check_phy_reset_block(&adapter->hw)) {

   519

		uint16_t mii_reg = 0;

   520

		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);

   521

		mii_reg |= MII_CR_POWER_DOWN;

   522

		e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);

   523

		mdelay(1);

   524

	}

   525

}

   526

   527

void

   528

e1000_down(struct e1000_adapter *adapter)

   529

{