1

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

     2

     3

     4

  Copyright(c) 1999 - 2005 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

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

    26

    27

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

    28

    29

#include "e1000.h"

    30

    31

/* Change Log

    32

 * 6.0.58       4/20/05

    33

 *   o Accepted ethtool cleanup patch from Stephen Hemminger 

    34

 * 6.0.44+	2/15/05

    35

 *   o applied Anton's patch to resolve tx hang in hardware

    36

 *   o Applied Andrew Mortons patch - e1000 stops working after resume

    37

 */

    38

    39

char e1000_driver_name[] = "e1000";

    40

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

    41

#ifndef CONFIG_E1000_NAPI

    42

#define DRIVERNAPI

    43

#else

    44

#define DRIVERNAPI "-NAPI"

    45

#endif

    46

#define DRV_VERSION		"6.0.60-k2"DRIVERNAPI

    47

char e1000_driver_version[] = DRV_VERSION;

    48

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

    49

    50

/* e1000_pci_tbl - PCI Device ID Table

    51

 *

    52

 * Last entry must be all 0s

    53

 *

    54

 * Macro expands to...

    55

 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

    56

 */

    57

static struct pci_device_id e1000_pci_tbl[] = {

    58

	INTEL_E1000_ETHERNET_DEVICE(0x1000),

    59

	INTEL_E1000_ETHERNET_DEVICE(0x1001),

    60

	INTEL_E1000_ETHERNET_DEVICE(0x1004),

    61

	INTEL_E1000_ETHERNET_DEVICE(0x1008),

    62

	INTEL_E1000_ETHERNET_DEVICE(0x1009),

    63

	INTEL_E1000_ETHERNET_DEVICE(0x100C),

    64

	INTEL_E1000_ETHERNET_DEVICE(0x100D),

    65

	INTEL_E1000_ETHERNET_DEVICE(0x100E),

    66

	INTEL_E1000_ETHERNET_DEVICE(0x100F),

    67

	INTEL_E1000_ETHERNET_DEVICE(0x1010),

    68

	INTEL_E1000_ETHERNET_DEVICE(0x1011),

    69

	INTEL_E1000_ETHERNET_DEVICE(0x1012),

    70

	INTEL_E1000_ETHERNET_DEVICE(0x1013),

    71

	INTEL_E1000_ETHERNET_DEVICE(0x1014),

    72

	INTEL_E1000_ETHERNET_DEVICE(0x1015),

    73

	INTEL_E1000_ETHERNET_DEVICE(0x1016),

    74

	INTEL_E1000_ETHERNET_DEVICE(0x1017),

    75

	INTEL_E1000_ETHERNET_DEVICE(0x1018),

    76

	INTEL_E1000_ETHERNET_DEVICE(0x1019),

    77

	INTEL_E1000_ETHERNET_DEVICE(0x101A),

    78

	INTEL_E1000_ETHERNET_DEVICE(0x101D),

    79

	INTEL_E1000_ETHERNET_DEVICE(0x101E),

    80

	INTEL_E1000_ETHERNET_DEVICE(0x1026),

    81

	INTEL_E1000_ETHERNET_DEVICE(0x1027),

    82

	INTEL_E1000_ETHERNET_DEVICE(0x1028),

    83

	INTEL_E1000_ETHERNET_DEVICE(0x1075),

    84

	INTEL_E1000_ETHERNET_DEVICE(0x1076),

    85

	INTEL_E1000_ETHERNET_DEVICE(0x1077),

    86

	INTEL_E1000_ETHERNET_DEVICE(0x1078),

    87

	INTEL_E1000_ETHERNET_DEVICE(0x1079),

    88

	INTEL_E1000_ETHERNET_DEVICE(0x107A),

    89

	INTEL_E1000_ETHERNET_DEVICE(0x107B),

    90

	INTEL_E1000_ETHERNET_DEVICE(0x107C),

    91

	INTEL_E1000_ETHERNET_DEVICE(0x108A),

    92

	INTEL_E1000_ETHERNET_DEVICE(0x108B),

    93

	INTEL_E1000_ETHERNET_DEVICE(0x108C),

    94

	INTEL_E1000_ETHERNET_DEVICE(0x1099),

    95

	/* required last entry */

    96

	{0,}

    97

};

    98

    99

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

   100

   101

int e1000_up(struct e1000_adapter *adapter);

   102

void e1000_down(struct e1000_adapter *adapter);

   103

void e1000_reset(struct e1000_adapter *adapter);

   104

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

   105

int e1000_setup_tx_resources(struct e1000_adapter *adapter);

   106

int e1000_setup_rx_resources(struct e1000_adapter *adapter);

   107

void e1000_free_tx_resources(struct e1000_adapter *adapter);

   108

void e1000_free_rx_resources(struct e1000_adapter *adapter);

   109

void e1000_update_stats(struct e1000_adapter *adapter);

   110

   111

/* Local Function Prototypes */

   112

   113

static int e1000_init_module(void);

   114

static void e1000_exit_module(void);

   115

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

   116

static void __devexit e1000_remove(struct pci_dev *pdev);

   117

static int e1000_sw_init(struct e1000_adapter *adapter);

   118

static int e1000_open(struct net_device *netdev);

   119

static int e1000_close(struct net_device *netdev);

   120

static void e1000_configure_tx(struct e1000_adapter *adapter);

   121

static void e1000_configure_rx(struct e1000_adapter *adapter);

   122

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   123

static void e1000_clean_tx_ring(struct e1000_adapter *adapter);

   124

static void e1000_clean_rx_ring(struct e1000_adapter *adapter);

   125

static void e1000_set_multi(struct net_device *netdev);

   126

static void e1000_update_phy_info(unsigned long data);

   127

static void e1000_watchdog(unsigned long data);

   128

static void e1000_watchdog_task(struct e1000_adapter *adapter);

   129

static void e1000_82547_tx_fifo_stall(unsigned long data);

   130

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

   131

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

   132

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

   133

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

   134

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

   135

static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter);

   136

#ifdef CONFIG_E1000_NAPI

   137

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

   138

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,

   139

                                    int *work_done, int work_to_do);

   140

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

   141

                                       int *work_done, int work_to_do);

   142

#else

   143

static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter);

   144

static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter);

   145

#endif

   146

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);

   147

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter);

   148

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

   149

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

   150

			   int cmd);

   151

void e1000_set_ethtool_ops(struct net_device *netdev);

   152

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   153

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   154

static void e1000_tx_timeout(struct net_device *dev);

   155

static void e1000_tx_timeout_task(struct net_device *dev);

   156

static void e1000_smartspeed(struct e1000_adapter *adapter);

   157

static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   158

					      struct sk_buff *skb);

   159

   160

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

   161

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

   162

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

   163

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   164

   165

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

   166

#ifdef CONFIG_PM

   167

static int e1000_resume(struct pci_dev *pdev);

   168

#endif

   169

   170

#ifdef CONFIG_NET_POLL_CONTROLLER

   171

/* for netdump / net console */

   172

static void e1000_netpoll (struct net_device *netdev);

   173

#endif

   174

   175

/* Exported from other modules */

   176

   177

extern void e1000_check_options(struct e1000_adapter *adapter);

   178

   179

static struct pci_driver e1000_driver = {

   180

	.name     = e1000_driver_name,

   181

	.id_table = e1000_pci_tbl,

   182

	.probe    = e1000_probe,

   183

	.remove   = __devexit_p(e1000_remove),

   184

	/* Power Managment Hooks */

   185

#ifdef CONFIG_PM

   186

	.suspend  = e1000_suspend,

   187

	.resume   = e1000_resume

   188

#endif

   189

};

   190

   191

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

   192

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

   193

MODULE_LICENSE("GPL");

   194

MODULE_VERSION(DRV_VERSION);

   195

   196

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   197

module_param(debug, int, 0);

   198

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

   199

   200

/**

   201

 * e1000_init_module - Driver Registration Routine

   202

 *

   203

 * e1000_init_module is the first routine called when the driver is

   204

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

   205

 **/

   206

   207

static int __init

   208

e1000_init_module(void)

   209

{

   210

	int ret;

   211

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

   212

	       e1000_driver_string, e1000_driver_version);

   213

   214

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

   215

   216

	ret = pci_module_init(&e1000_driver);

   217

   218

	return ret;

   219

}

   220

   221

module_init(e1000_init_module);

   222

   223

/**

   224

 * e1000_exit_module - Driver Exit Cleanup Routine

   225

 *

   226

 * e1000_exit_module is called just before the driver is removed

   227

 * from memory.

   228

 **/

   229

   230

static void __exit

   231

e1000_exit_module(void)

   232

{

   233

	pci_unregister_driver(&e1000_driver);

   234

}

   235

   236

module_exit(e1000_exit_module);

   237

   238

/**

   239

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   240

 * @adapter: board private structure

   241

 **/

   242

   243

static inline void

   244

e1000_irq_disable(struct e1000_adapter *adapter)

   245

{

   246

	atomic_inc(&adapter->irq_sem);

   247

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

   248

	E1000_WRITE_FLUSH(&adapter->hw);

   249

	synchronize_irq(adapter->pdev->irq);

   250

}

   251

   252

/**

   253

 * e1000_irq_enable - Enable default interrupt generation settings

   254

 * @adapter: board private structure

   255

 **/

   256

   257

static inline void

   258

e1000_irq_enable(struct e1000_adapter *adapter)

   259

{

   260

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

   261

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

   262

		E1000_WRITE_FLUSH(&adapter->hw);

   263

	}

   264

}

   265

void

   266

e1000_update_mng_vlan(struct e1000_adapter *adapter)

   267

{

   268

	struct net_device *netdev = adapter->netdev;

   269

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

   270

	uint16_t old_vid = adapter->mng_vlan_id;

   271

	if(adapter->vlgrp) {

   272

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

   273

			if(adapter->hw.mng_cookie.status &

   274

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   275

				e1000_vlan_rx_add_vid(netdev, vid);

   276

				adapter->mng_vlan_id = vid;

   277

			} else

   278

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   279

   280

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

   281

					(vid != old_vid) && 

   282

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

   283

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   284

		}

   285

	}

   286

}

   287

   288

int

   289

e1000_up(struct e1000_adapter *adapter)

   290

{

   291

	struct net_device *netdev = adapter->netdev;

   292

	int err;

   293

   294

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

   295

   296

	/* Reset the PHY if it was previously powered down */

   297

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

   298

		uint16_t mii_reg;

   299

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

   300

		if(mii_reg & MII_CR_POWER_DOWN)

   301

			e1000_phy_reset(&adapter->hw);

   302

	}

   303

   304

	e1000_set_multi(netdev);

   305

   306

	e1000_restore_vlan(adapter);

   307

   308

	e1000_configure_tx(adapter);

   309

	e1000_setup_rctl(adapter);

   310

	e1000_configure_rx(adapter);

   311

	adapter->alloc_rx_buf(adapter);

   312

   313

#ifdef CONFIG_PCI_MSI

   314

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

   315

		adapter->have_msi = TRUE;

   316

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

   317

			DPRINTK(PROBE, ERR,

   318

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

   319

			adapter->have_msi = FALSE;

   320

		}

   321

	}

   322

#endif

   323

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

   324

		              SA_SHIRQ | SA_SAMPLE_RANDOM,

   325

		              netdev->name, netdev))) {

   326

		DPRINTK(PROBE, ERR,

   327

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

   328

		return err;

   329

	}

   330

   331

	mod_timer(&adapter->watchdog_timer, jiffies);

   332

   333

#ifdef CONFIG_E1000_NAPI

   334

	netif_poll_enable(netdev);

   335

#endif

   336

	e1000_irq_enable(adapter);

   337

   338

	return 0;

   339

}

   340

   341

void

   342

e1000_down(struct e1000_adapter *adapter)

   343

{

   344

	struct net_device *netdev = adapter->netdev;

   345

   346

	e1000_irq_disable(adapter);

   347

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

   348

#ifdef CONFIG_PCI_MSI

   349

	if(adapter->hw.mac_type > e1000_82547_rev_2 &&

   350

	   adapter->have_msi == TRUE)

   351

		pci_disable_msi(adapter->pdev);

   352

#endif

   353

	del_timer_sync(&adapter->tx_fifo_stall_timer);

   354

	del_timer_sync(&adapter->watchdog_timer);

   355

	del_timer_sync(&adapter->phy_info_timer);

   356

   357

#ifdef CONFIG_E1000_NAPI

   358

	netif_poll_disable(netdev);

   359

#endif

   360

	adapter->link_speed = 0;

   361

	adapter->link_duplex = 0;

   362

	netif_carrier_off(netdev);

   363

	netif_stop_queue(netdev);

   364

   365

	e1000_reset(adapter);

   366

	e1000_clean_tx_ring(adapter);

   367

	e1000_clean_rx_ring(adapter);

   368

   369

	/* If WoL is not enabled

   370

	 * and management mode is not IAMT

   371

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

   372

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

   373

	   adapter->hw.media_type == e1000_media_type_copper &&

   374

	   !e1000_check_mng_mode(&adapter->hw) &&

   375

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

   376

		uint16_t mii_reg;

   377

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

   378

		mii_reg |= MII_CR_POWER_DOWN;

   379

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

   380

		mdelay(1);

   381

	}

   382

}

   383

   384

void

   385

e1000_reset(struct e1000_adapter *adapter)

   386

{

   387

	struct net_device *netdev = adapter->netdev;

   388

	uint32_t pba, manc;

   389

	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;

   390

	uint16_t fc_low_water_mark = E1000_FC_LOW_DIFF;

   391

   392

	/* Repartition Pba for greater than 9k mtu

   393

	 * To take effect CTRL.RST is required.

   394

	 */

   395

   396

	switch (adapter->hw.mac_type) {

   397

	case e1000_82547:

   398

	case e1000_82547_rev_2:

   399

		pba = E1000_PBA_30K;

   400

		break;

   401

	case e1000_82573:

   402

		pba = E1000_PBA_12K;

   403

		break;

   404

	default:

   405

		pba = E1000_PBA_48K;

   406

		break;

   407

	}

   408

   409

	if((adapter->hw.mac_type != e1000_82573) &&

   410

	   (adapter->rx_buffer_len > E1000_RXBUFFER_8192)) {

   411

		pba -= 8; /* allocate more FIFO for Tx */

   412

		/* send an XOFF when there is enough space in the

   413

		 * Rx FIFO to hold one extra full size Rx packet 

   414

		*/

   415

		fc_high_water_mark = netdev->mtu + ENET_HEADER_SIZE + 

   416

					ETHERNET_FCS_SIZE + 1;

   417

		fc_low_water_mark = fc_high_water_mark + 8;

   418

	}

   419

   420

   421

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

   422

		adapter->tx_fifo_head = 0;

   423

		adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;

   424

		adapter->tx_fifo_size =

   425

			(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;

   426

		atomic_set(&adapter->tx_fifo_stall, 0);

   427

	}

   428

   429

	E1000_WRITE_REG(&adapter->hw, PBA, pba);

   430

   431

	/* flow control settings */

   432

	adapter->hw.fc_high_water = (pba << E1000_PBA_BYTES_SHIFT) -

   433

				    fc_high_water_mark;

   434

	adapter->hw.fc_low_water = (pba << E1000_PBA_BYTES_SHIFT) -

   435

				   fc_low_water_mark;

   436

	adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;

   437

	adapter->hw.fc_send_xon = 1;

   438

	adapter->hw.fc = adapter->hw.original_fc;

   439

   440

	/* Allow time for pending master requests to run */

   441

	e1000_reset_hw(&adapter->hw);

   442

	if(adapter->hw.mac_type >= e1000_82544)

   443

		E1000_WRITE_REG(&adapter->hw, WUC, 0);

   444

	if(e1000_init_hw(&adapter->hw))

   445

		DPRINTK(PROBE, ERR, "Hardware Error\n");

   446

	e1000_update_mng_vlan(adapter);

   447

	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */

   448

	E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);

   449

   450

	e1000_reset_adaptive(&adapter->hw);

   451

	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);

   452

	if (adapter->en_mng_pt) {

   453

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

   454

		manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);

   455

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

   456

	}

   457

}

   458

   459

/**

   460

 * e1000_probe - Device Initialization Routine

   461

 * @pdev: PCI device information struct

   462

 * @ent: entry in e1000_pci_tbl

   463

 *

   464

 * Returns 0 on success, negative on failure

   465

 *

   466

 * e1000_probe initializes an adapter identified by a pci_dev structure.

   467

 * The OS initialization, configuring of the adapter private structure,

   468

 * and a hardware reset occur.

   469

 **/

   470

   471

static int __devinit

   472

e1000_probe(struct pci_dev *pdev,

   473

            const struct pci_device_id *ent)

   474

{

   475

	struct net_device *netdev;

   476

	struct e1000_adapter *adapter;

   477

	unsigned long mmio_start, mmio_len;

   478

	uint32_t swsm;

   479

   480

	static int cards_found = 0;

   481

	int i, err, pci_using_dac;

   482

	uint16_t eeprom_data;

   483

	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;

   484

	if((err = pci_enable_device(pdev)))

   485

		return err;

   486

   487

	if(!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {

   488

		pci_using_dac = 1;

   489

	} else {

   490

		if((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {

   491

			E1000_ERR("No usable DMA configuration, aborting\n");

   492

			return err;

   493

		}

   494

		pci_using_dac = 0;

   495

	}

   496

   497

	if((err = pci_request_regions(pdev, e1000_driver_name)))

   498

		return err;

   499

   500

	pci_set_master(pdev);

   501

   502

	netdev = alloc_etherdev(sizeof(struct e1000_adapter));

   503

	if(!netdev) {

   504

		err = -ENOMEM;

   505

		goto err_alloc_etherdev;

   506

	}

   507

   508

	SET_MODULE_OWNER(netdev);

   509

	SET_NETDEV_DEV(netdev, &pdev->dev);

   510

   511

	pci_set_drvdata(pdev, netdev);

   512

	adapter = netdev_priv(netdev);

   513

	adapter->netdev = netdev;

   514

	adapter->pdev = pdev;

   515

	adapter->hw.back = adapter;

   516

	adapter->msg_enable = (1 << debug) - 1;

   517

   518

	mmio_start = pci_resource_start(pdev, BAR_0);

   519

	mmio_len = pci_resource_len(pdev, BAR_0);

   520

   521

	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);

   522

	if(!adapter->hw.hw_addr) {

   523

		err = -EIO;

   524

		goto err_ioremap;

   525

	}

   526

   527

	for(i = BAR_1; i <= BAR_5; i++) {

   528

		if(pci_resource_len(pdev, i) == 0)

   529

			continue;

   530

		if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {