1

/* Intel(R) Gigabit Ethernet Linux driver

     2

 * Copyright(c) 2007-2014 Intel Corporation.

     3

 *

     4

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

     5

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

     6

 * version 2, as published by the Free Software Foundation.

     7

 *

     8

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

     9

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10

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

    11

 * more details.

    12

 *

    13

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

    14

 * this program; if not, see <http://www.gnu.org/licenses/>.

    15

 *

    16

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

    17

 * the file called "COPYING".

    18

 *

    19

 * Contact Information:

    20

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

    21

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

    22

 */

    23

    24

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

    25

    26

#include <linux/module.h>

    27

#include <linux/types.h>

    28

#include <linux/init.h>

    29

#include <linux/bitops.h>

    30

#include <linux/vmalloc.h>

    31

#include <linux/pagemap.h>

    32

#include <linux/netdevice.h>

    33

#include <linux/ipv6.h>

    34

#include <linux/slab.h>

    35

#include <net/checksum.h>

    36

#include <net/ip6_checksum.h>

    37

#include <linux/net_tstamp.h>

    38

#include <linux/mii.h>

    39

#include <linux/ethtool.h>

    40

#include <linux/if.h>

    41

#include <linux/if_vlan.h>

    42

#include <linux/pci.h>

    43

#include <linux/pci-aspm.h>

    44

#include <linux/delay.h>

    45

#include <linux/interrupt.h>

    46

#include <linux/ip.h>

    47

#include <linux/tcp.h>

    48

#include <linux/sctp.h>

    49

#include <linux/if_ether.h>

    50

#include <linux/aer.h>

    51

#include <linux/prefetch.h>

    52

#include <linux/pm_runtime.h>

    53

#ifdef CONFIG_IGB_DCA

    54

#include <linux/dca.h>

    55

#endif

    56

#include <linux/i2c.h>

    57

#include "igb.h"

    58

    59

#define MAJ 5

    60

#define MIN 2

    61

#define BUILD 15

    62

#define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \

    63

__stringify(BUILD) "-k"

    64

char igb_driver_name[] = "igb";

    65

char igb_driver_version[] = DRV_VERSION;

    66

static const char igb_driver_string[] =

    67

				"Intel(R) Gigabit Ethernet Network Driver";

    68

static const char igb_copyright[] =

    69

				"Copyright (c) 2007-2014 Intel Corporation.";

    70

    71

static const struct e1000_info *igb_info_tbl[] = {

    72

	[board_82575] = &e1000_82575_info,

    73

};

    74

    75

static const struct pci_device_id igb_pci_tbl[] = {

    76

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },

    77

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },

    78

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) },

    79

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), board_82575 },

    80

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), board_82575 },

    81

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), board_82575 },

    82

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), board_82575 },

    83

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), board_82575 },

    84

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), board_82575 },

    85

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), board_82575 },

    86

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_COPPER), board_82575 },

    87

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_FIBER), board_82575 },

    88

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SERDES), board_82575 },

    89

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SGMII), board_82575 },

    90

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER), board_82575 },

    91

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_FIBER), board_82575 },

    92

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_QUAD_FIBER), board_82575 },

    93

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SERDES), board_82575 },

    94

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SGMII), board_82575 },

    95

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER_DUAL), board_82575 },

    96

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SGMII), board_82575 },

    97

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SERDES), board_82575 },

    98

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_BACKPLANE), board_82575 },

    99

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SFP), board_82575 },

   100

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576), board_82575 },

   101

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS), board_82575 },

   102

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS_SERDES), board_82575 },

   103

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), board_82575 },

   104

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), board_82575 },

   105

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES_QUAD), board_82575 },

   106

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER_ET2), board_82575 },

   107

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), board_82575 },

   108

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), board_82575 },

   109

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), board_82575 },

   110

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575GB_QUAD_COPPER), board_82575 },

   111

	/* required last entry */

   112

	{0, }

   113

};

   114

   115

MODULE_DEVICE_TABLE(pci, igb_pci_tbl);

   116

   117

static int igb_setup_all_tx_resources(struct igb_adapter *);

   118

static int igb_setup_all_rx_resources(struct igb_adapter *);

   119

static void igb_free_all_tx_resources(struct igb_adapter *);

   120

static void igb_free_all_rx_resources(struct igb_adapter *);

   121

static void igb_setup_mrqc(struct igb_adapter *);

   122

static int igb_probe(struct pci_dev *, const struct pci_device_id *);

   123

static void igb_remove(struct pci_dev *pdev);

   124

static int igb_sw_init(struct igb_adapter *);

   125

static int igb_open(struct net_device *);

   126

static int igb_close(struct net_device *);

   127

static void igb_configure(struct igb_adapter *);

   128

static void igb_configure_tx(struct igb_adapter *);

   129

static void igb_configure_rx(struct igb_adapter *);

   130

static void igb_clean_all_tx_rings(struct igb_adapter *);

   131

static void igb_clean_all_rx_rings(struct igb_adapter *);

   132

static void igb_clean_tx_ring(struct igb_ring *);

   133

static void igb_clean_rx_ring(struct igb_ring *);

   134

static void igb_set_rx_mode(struct net_device *);

   135

static void igb_update_phy_info(unsigned long);

   136

static void igb_watchdog(unsigned long);

   137

static void igb_watchdog_task(struct work_struct *);

   138

static netdev_tx_t igb_xmit_frame(struct sk_buff *skb, struct net_device *);

   139

static struct rtnl_link_stats64 *igb_get_stats64(struct net_device *dev,

   140

					  struct rtnl_link_stats64 *stats);

   141

static int igb_change_mtu(struct net_device *, int);

   142

static int igb_set_mac(struct net_device *, void *);

   143

static void igb_set_uta(struct igb_adapter *adapter);

   144

static irqreturn_t igb_intr(int irq, void *);

   145

static irqreturn_t igb_intr_msi(int irq, void *);

   146

static irqreturn_t igb_msix_other(int irq, void *);

   147

static irqreturn_t igb_msix_ring(int irq, void *);

   148

#ifdef CONFIG_IGB_DCA

   149

static void igb_update_dca(struct igb_q_vector *);

   150

static void igb_setup_dca(struct igb_adapter *);

   151

#endif /* CONFIG_IGB_DCA */

   152

static int igb_poll(struct napi_struct *, int);

   153

static bool igb_clean_tx_irq(struct igb_q_vector *);

   154

static bool igb_clean_rx_irq(struct igb_q_vector *, int);

   155

static int igb_ioctl(struct net_device *, struct ifreq *, int cmd);

   156

static void igb_tx_timeout(struct net_device *);

   157

static void igb_reset_task(struct work_struct *);

   158

static void igb_vlan_mode(struct net_device *netdev,

   159

			  netdev_features_t features);

   160

static int igb_vlan_rx_add_vid(struct net_device *, __be16, u16);

   161

static int igb_vlan_rx_kill_vid(struct net_device *, __be16, u16);

   162

static void igb_restore_vlan(struct igb_adapter *);

   163

static void igb_rar_set_qsel(struct igb_adapter *, u8 *, u32 , u8);

   164

static void igb_ping_all_vfs(struct igb_adapter *);

   165

static void igb_msg_task(struct igb_adapter *);

   166

static void igb_vmm_control(struct igb_adapter *);

   167

static int igb_set_vf_mac(struct igb_adapter *, int, unsigned char *);

   168

static void igb_restore_vf_multicasts(struct igb_adapter *adapter);

   169

static int igb_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac);

   170

static int igb_ndo_set_vf_vlan(struct net_device *netdev,

   171

			       int vf, u16 vlan, u8 qos);

   172

static int igb_ndo_set_vf_bw(struct net_device *, int, int, int);

   173

static int igb_ndo_set_vf_spoofchk(struct net_device *netdev, int vf,

   174

				   bool setting);

   175

static int igb_ndo_get_vf_config(struct net_device *netdev, int vf,

   176

				 struct ifla_vf_info *ivi);

   177

static void igb_check_vf_rate_limit(struct igb_adapter *);

   178

   179

#ifdef CONFIG_PCI_IOV

   180

static int igb_vf_configure(struct igb_adapter *adapter, int vf);

   181

static int igb_pci_enable_sriov(struct pci_dev *dev, int num_vfs);

   182

#endif

   183

   184

#ifdef CONFIG_PM

   185

#ifdef CONFIG_PM_SLEEP

   186

static int igb_suspend(struct device *);

   187

#endif

   188

static int igb_resume(struct device *);

   189

#ifdef CONFIG_PM_RUNTIME

   190

static int igb_runtime_suspend(struct device *dev);

   191

static int igb_runtime_resume(struct device *dev);

   192

static int igb_runtime_idle(struct device *dev);

   193

#endif

   194

static const struct dev_pm_ops igb_pm_ops = {

   195

	SET_SYSTEM_SLEEP_PM_OPS(igb_suspend, igb_resume)

   196

	SET_RUNTIME_PM_OPS(igb_runtime_suspend, igb_runtime_resume,

   197

			igb_runtime_idle)

   198

};

   199

#endif

   200

static void igb_shutdown(struct pci_dev *);

   201

static int igb_pci_sriov_configure(struct pci_dev *dev, int num_vfs);

   202

#ifdef CONFIG_IGB_DCA

   203

static int igb_notify_dca(struct notifier_block *, unsigned long, void *);

   204

static struct notifier_block dca_notifier = {

   205

	.notifier_call	= igb_notify_dca,

   206

	.next		= NULL,

   207

	.priority	= 0

   208

};

   209

#endif

   210

#ifdef CONFIG_NET_POLL_CONTROLLER

   211

/* for netdump / net console */

   212

static void igb_netpoll(struct net_device *);

   213

#endif

   214

#ifdef CONFIG_PCI_IOV

   215

static unsigned int max_vfs;

   216

module_param(max_vfs, uint, 0);

   217

MODULE_PARM_DESC(max_vfs, "Maximum number of virtual functions to allocate per physical function");

   218

#endif /* CONFIG_PCI_IOV */

   219

   220

static pci_ers_result_t igb_io_error_detected(struct pci_dev *,

   221

		     pci_channel_state_t);

   222

static pci_ers_result_t igb_io_slot_reset(struct pci_dev *);

   223

static void igb_io_resume(struct pci_dev *);

   224

   225

static const struct pci_error_handlers igb_err_handler = {

   226

	.error_detected = igb_io_error_detected,

   227

	.slot_reset = igb_io_slot_reset,

   228

	.resume = igb_io_resume,

   229

};

   230

   231

static void igb_init_dmac(struct igb_adapter *adapter, u32 pba);

   232

   233

static struct pci_driver igb_driver = {

   234

	.name     = igb_driver_name,

   235

	.id_table = igb_pci_tbl,

   236

	.probe    = igb_probe,

   237

	.remove   = igb_remove,

   238

#ifdef CONFIG_PM

   239

	.driver.pm = &igb_pm_ops,

   240

#endif

   241

	.shutdown = igb_shutdown,

   242

	.sriov_configure = igb_pci_sriov_configure,

   243

	.err_handler = &igb_err_handler

   244

};

   245

   246

MODULE_AUTHOR("Intel Corporation, <e1000-devel@lists.sourceforge.net>");

   247

MODULE_DESCRIPTION("Intel(R) Gigabit Ethernet Network Driver");

   248

MODULE_LICENSE("GPL");

   249

MODULE_VERSION(DRV_VERSION);

   250

   251

#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)

   252

static int debug = -1;

   253

module_param(debug, int, 0);

   254

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

   255

   256

struct igb_reg_info {

   257

	u32 ofs;

   258

	char *name;

   259

};

   260

   261

static const struct igb_reg_info igb_reg_info_tbl[] = {

   262

   263

	/* General Registers */

   264

	{E1000_CTRL, "CTRL"},

   265

	{E1000_STATUS, "STATUS"},

   266

	{E1000_CTRL_EXT, "CTRL_EXT"},

   267

   268

	/* Interrupt Registers */

   269

	{E1000_ICR, "ICR"},

   270

   271

	/* RX Registers */

   272

	{E1000_RCTL, "RCTL"},

   273

	{E1000_RDLEN(0), "RDLEN"},

   274

	{E1000_RDH(0), "RDH"},

   275

	{E1000_RDT(0), "RDT"},

   276

	{E1000_RXDCTL(0), "RXDCTL"},

   277

	{E1000_RDBAL(0), "RDBAL"},

   278

	{E1000_RDBAH(0), "RDBAH"},

   279

   280

	/* TX Registers */

   281

	{E1000_TCTL, "TCTL"},

   282

	{E1000_TDBAL(0), "TDBAL"},

   283

	{E1000_TDBAH(0), "TDBAH"},

   284

	{E1000_TDLEN(0), "TDLEN"},

   285

	{E1000_TDH(0), "TDH"},

   286

	{E1000_TDT(0), "TDT"},

   287

	{E1000_TXDCTL(0), "TXDCTL"},

   288

	{E1000_TDFH, "TDFH"},

   289

	{E1000_TDFT, "TDFT"},

   290

	{E1000_TDFHS, "TDFHS"},

   291

	{E1000_TDFPC, "TDFPC"},

   292

   293

	/* List Terminator */

   294

	{}

   295

};

   296

   297

/* igb_regdump - register printout routine */

   298

static void igb_regdump(struct e1000_hw *hw, struct igb_reg_info *reginfo)

   299

{

   300

	int n = 0;

   301

	char rname[16];

   302

	u32 regs[8];

   303

   304

	switch (reginfo->ofs) {

   305

	case E1000_RDLEN(0):

   306

		for (n = 0; n < 4; n++)

   307

			regs[n] = rd32(E1000_RDLEN(n));

   308

		break;

   309

	case E1000_RDH(0):

   310

		for (n = 0; n < 4; n++)

   311

			regs[n] = rd32(E1000_RDH(n));

   312

		break;

   313

	case E1000_RDT(0):

   314

		for (n = 0; n < 4; n++)

   315

			regs[n] = rd32(E1000_RDT(n));

   316

		break;

   317

	case E1000_RXDCTL(0):

   318

		for (n = 0; n < 4; n++)

   319

			regs[n] = rd32(E1000_RXDCTL(n));

   320

		break;

   321

	case E1000_RDBAL(0):

   322

		for (n = 0; n < 4; n++)

   323

			regs[n] = rd32(E1000_RDBAL(n));

   324

		break;

   325

	case E1000_RDBAH(0):

   326

		for (n = 0; n < 4; n++)

   327

			regs[n] = rd32(E1000_RDBAH(n));

   328

		break;

   329

	case E1000_TDBAL(0):

   330

		for (n = 0; n < 4; n++)

   331

			regs[n] = rd32(E1000_RDBAL(n));

   332

		break;

   333

	case E1000_TDBAH(0):

   334

		for (n = 0; n < 4; n++)

   335

			regs[n] = rd32(E1000_TDBAH(n));

   336

		break;

   337

	case E1000_TDLEN(0):

   338

		for (n = 0; n < 4; n++)

   339

			regs[n] = rd32(E1000_TDLEN(n));

   340

		break;

   341

	case E1000_TDH(0):

   342

		for (n = 0; n < 4; n++)

   343

			regs[n] = rd32(E1000_TDH(n));

   344

		break;

   345

	case E1000_TDT(0):

   346

		for (n = 0; n < 4; n++)

   347

			regs[n] = rd32(E1000_TDT(n));

   348

		break;

   349

	case E1000_TXDCTL(0):

   350

		for (n = 0; n < 4; n++)

   351

			regs[n] = rd32(E1000_TXDCTL(n));

   352

		break;

   353

	default:

   354

		pr_info("%-15s %08x\n", reginfo->name, rd32(reginfo->ofs));

   355

		return;

   356

	}

   357

   358

	snprintf(rname, 16, "%s%s", reginfo->name, "[0-3]");

   359

	pr_info("%-15s %08x %08x %08x %08x\n", rname, regs[0], regs[1],

   360

		regs[2], regs[3]);

   361

}

   362

   363

/* igb_dump - Print registers, Tx-rings and Rx-rings */

   364

static void igb_dump(struct igb_adapter *adapter)

   365

{

   366

	struct net_device *netdev = adapter->netdev;

   367

	struct e1000_hw *hw = &adapter->hw;

   368

	struct igb_reg_info *reginfo;

   369

	struct igb_ring *tx_ring;

   370

	union e1000_adv_tx_desc *tx_desc;

   371

	struct my_u0 { u64 a; u64 b; } *u0;

   372

	struct igb_ring *rx_ring;

   373

	union e1000_adv_rx_desc *rx_desc;

   374

	u32 staterr;

   375

	u16 i, n;

   376

   377

	if (!netif_msg_hw(adapter))

   378

		return;

   379

   380

	/* Print netdevice Info */

   381

	if (netdev) {

   382

		dev_info(&adapter->pdev->dev, "Net device Info\n");

   383

		pr_info("Device Name     state            trans_start      last_rx\n");

   384

		pr_info("%-15s %016lX %016lX %016lX\n", netdev->name,

   385

			netdev->state, netdev->trans_start, netdev->last_rx);

   386

	}

   387

   388

	/* Print Registers */

   389

	dev_info(&adapter->pdev->dev, "Register Dump\n");

   390

	pr_info(" Register Name   Value\n");

   391

	for (reginfo = (struct igb_reg_info *)igb_reg_info_tbl;

   392

	     reginfo->name; reginfo++) {

   393

		igb_regdump(hw, reginfo);

   394

	}

   395

   396

	/* Print TX Ring Summary */

   397

	if (!netdev || !netif_running(netdev))

   398

		goto exit;

   399

   400

	dev_info(&adapter->pdev->dev, "TX Rings Summary\n");

   401

	pr_info("Queue [NTU] [NTC] [bi(ntc)->dma  ] leng ntw timestamp\n");

   402

	for (n = 0; n < adapter->num_tx_queues; n++) {

   403

		struct igb_tx_buffer *buffer_info;

   404

		tx_ring = adapter->tx_ring[n];

   405

		buffer_info = &tx_ring->tx_buffer_info[tx_ring->next_to_clean];

   406

		pr_info(" %5d %5X %5X %016llX %04X %p %016llX\n",

   407

			n, tx_ring->next_to_use, tx_ring->next_to_clean,

   408

			(u64)dma_unmap_addr(buffer_info, dma),

   409

			dma_unmap_len(buffer_info, len),

   410

			buffer_info->next_to_watch,

   411

			(u64)buffer_info->time_stamp);

   412

	}

   413

   414

	/* Print TX Rings */

   415

	if (!netif_msg_tx_done(adapter))

   416

		goto rx_ring_summary;

   417

   418

	dev_info(&adapter->pdev->dev, "TX Rings Dump\n");

   419

   420

	/* Transmit Descriptor Formats

   421

	 *

   422

	 * Advanced Transmit Descriptor

   423

	 *   +--------------------------------------------------------------+

   424

	 * 0 |         Buffer Address [63:0]                                |

   425

	 *   +--------------------------------------------------------------+

   426

	 * 8 | PAYLEN  | PORTS  |CC|IDX | STA | DCMD  |DTYP|MAC|RSV| DTALEN |

   427

	 *   +--------------------------------------------------------------+

   428

	 *   63      46 45    40 39 38 36 35 32 31   24             15       0

   429

	 */

   430

   431

	for (n = 0; n < adapter->num_tx_queues; n++) {

   432

		tx_ring = adapter->tx_ring[n];

   433

		pr_info("------------------------------------\n");

   434

		pr_info("TX QUEUE INDEX = %d\n", tx_ring->queue_index);

   435

		pr_info("------------------------------------\n");

   436

		pr_info("T [desc]     [address 63:0  ] [PlPOCIStDDM Ln] [bi->dma       ] leng  ntw timestamp        bi->skb\n");

   437

   438

		for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {

   439

			const char *next_desc;

   440

			struct igb_tx_buffer *buffer_info;

   441

			tx_desc = IGB_TX_DESC(tx_ring, i);

   442

			buffer_info = &tx_ring->tx_buffer_info[i];

   443

			u0 = (struct my_u0 *)tx_desc;

   444

			if (i == tx_ring->next_to_use &&

   445

			    i == tx_ring->next_to_clean)

   446

				next_desc = " NTC/U";

   447

			else if (i == tx_ring->next_to_use)

   448

				next_desc = " NTU";

   449

			else if (i == tx_ring->next_to_clean)

   450

				next_desc = " NTC";

   451

			else

   452

				next_desc = "";

   453

   454

			pr_info("T [0x%03X]    %016llX %016llX %016llX %04X  %p %016llX %p%s\n",

   455

				i, le64_to_cpu(u0->a),

   456

				le64_to_cpu(u0->b),

   457

				(u64)dma_unmap_addr(buffer_info, dma),

   458

				dma_unmap_len(buffer_info, len),

   459

				buffer_info->next_to_watch,

   460

				(u64)buffer_info->time_stamp,

   461

				buffer_info->skb, next_desc);

   462

   463

			if (netif_msg_pktdata(adapter) && buffer_info->skb)

   464

				print_hex_dump(KERN_INFO, "",

   465

					DUMP_PREFIX_ADDRESS,

   466

					16, 1, buffer_info->skb->data,

   467

					dma_unmap_len(buffer_info, len),

   468

					true);

   469

		}

   470

	}

   471

   472

	/* Print RX Rings Summary */

   473

rx_ring_summary:

   474

	dev_info(&adapter->pdev->dev, "RX Rings Summary\n");

   475

	pr_info("Queue [NTU] [NTC]\n");

   476

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

   477

		rx_ring = adapter->rx_ring[n];

   478

		pr_info(" %5d %5X %5X\n",

   479

			n, rx_ring->next_to_use, rx_ring->next_to_clean);

   480

	}

   481

   482

	/* Print RX Rings */

   483

	if (!netif_msg_rx_status(adapter))

   484

		goto exit;

   485

   486

	dev_info(&adapter->pdev->dev, "RX Rings Dump\n");

   487

   488

	/* Advanced Receive Descriptor (Read) Format

   489

	 *    63                                           1        0

   490

	 *    +-----------------------------------------------------+

   491

	 *  0 |       Packet Buffer Address [63:1]           |A0/NSE|

   492

	 *    +----------------------------------------------+------+

   493

	 *  8 |       Header Buffer Address [63:1]           |  DD  |

   494

	 *    +-----------------------------------------------------+

   495

	 *

   496

	 *

   497

	 * Advanced Receive Descriptor (Write-Back) Format

   498

	 *

   499

	 *   63       48 47    32 31  30      21 20 17 16   4 3     0

   500

	 *   +------------------------------------------------------+

   501

	 * 0 | Packet     IP     |SPH| HDR_LEN   | RSV|Packet|  RSS |

   502

	 *   | Checksum   Ident  |   |           |    | Type | Type |

   503

	 *   +------------------------------------------------------+

   504

	 * 8 | VLAN Tag | Length | Extended Error | Extended Status |

   505

	 *   +------------------------------------------------------+

   506

	 *   63       48 47    32 31            20 19               0

   507

	 */

   508

   509

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

   510

		rx_ring = adapter->rx_ring[n];

   511

		pr_info("------------------------------------\n");

   512

		pr_info("RX QUEUE INDEX = %d\n", rx_ring->queue_index);

   513

		pr_info("------------------------------------\n");

   514

		pr_info("R  [desc]      [ PktBuf     A0] [  HeadBuf   DD] [bi->dma       ] [bi->skb] <-- Adv Rx Read format\n");

   515

		pr_info("RWB[desc]      [PcsmIpSHl PtRs] [vl er S cks ln] ---------------- [bi->skb] <-- Adv Rx Write-Back format\n");

   516

   517

		for (i = 0; i < rx_ring->count; i++) {

   518

			const char *next_desc;

   519

			struct igb_rx_buffer *buffer_info;

   520

			buffer_info = &rx_ring->rx_buffer_info[i];

   521

			rx_desc = IGB_RX_DESC(rx_ring, i);

   522

			u0 = (struct my_u0 *)rx_desc;

   523

			staterr = le32_to_cpu(rx_desc->wb.upper.status_error);

   524

   525

			if (i == rx_ring->next_to_use)

   526

				next_desc = " NTU";

   527

			else if (i == rx_ring->next_to_clean)

   528

				next_desc = " NTC";

   529

			else