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

 * vim: noexpandtab

    24

 */

    25

    26

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

    27

    28

#include <linux/module.h>

    29

#include <linux/types.h>

    30

#include <linux/init.h>

    31

#include <linux/bitops.h>

    32

#include <linux/vmalloc.h>

    33

#include <linux/pagemap.h>

    34

#include <linux/netdevice.h>

    35

#include <linux/ipv6.h>

    36

#include <linux/slab.h>

    37

#include <net/checksum.h>

    38

#include <net/ip6_checksum.h>

    39

#include <linux/net_tstamp.h>

    40

#include <linux/mii.h>

    41

#include <linux/ethtool.h>

    42

#include <linux/if.h>

    43

#include <linux/if_vlan.h>

    44

#include <linux/pci.h>

    45

#include <linux/pci-aspm.h>

    46

#include <linux/delay.h>

    47

#include <linux/interrupt.h>

    48

#include <linux/ip.h>

    49

#include <linux/tcp.h>

    50

#include <linux/sctp.h>

    51

#include <linux/if_ether.h>

    52

#include <linux/aer.h>

    53

#include <linux/prefetch.h>

    54

#include <linux/pm_runtime.h>

    55

#ifdef CONFIG_IGB_DCA

    56

#include <linux/dca.h>

    57

#endif

    58

#include <linux/i2c.h>

    59

#include "igb-3.18-ethercat.h"

    60

    61

#define MAJ 5

    62

#define MIN 2

    63

#define BUILD 15

    64

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

    65

__stringify(BUILD) "-k-EtherCAT"

    66

char igb_driver_name[] = "ec_igb";

    67

char igb_driver_version[] = DRV_VERSION;

    68

static const char igb_driver_string[] =

    69

	"Intel(R) Gigabit Ethernet Network Driver (EtherCAT-enabled)";

    70

static const char igb_copyright[] =

    71

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

    72

    73

static const struct e1000_info *igb_info_tbl[] = {

    74

	[board_82575] = &e1000_82575_info,

    75

};

    76

    77

static const struct pci_device_id igb_pci_tbl[] = {

    78

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },

    79

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },

    80

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) },

    81

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), board_82575 },

    82

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), board_82575 },

    83

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), board_82575 },

    84

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), board_82575 },

    85

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), board_82575 },

    86

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), board_82575 },

    87

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), board_82575 },

    88

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_COPPER), board_82575 },

    89

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_FIBER), board_82575 },

    90

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SERDES), board_82575 },

    91

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SGMII), board_82575 },

    92

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER), board_82575 },

    93

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_FIBER), board_82575 },

    94

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_QUAD_FIBER), board_82575 },

    95

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SERDES), board_82575 },

    96

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SGMII), board_82575 },

    97

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER_DUAL), board_82575 },

    98

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SGMII), board_82575 },

    99

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SERDES), board_82575 },

   100

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_BACKPLANE), board_82575 },

   101

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SFP), board_82575 },

   102

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576), board_82575 },

   103

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS), board_82575 },

   104

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS_SERDES), board_82575 },

   105

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), board_82575 },

   106

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), board_82575 },

   107

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES_QUAD), board_82575 },

   108

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER_ET2), board_82575 },

   109

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), board_82575 },

   110

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), board_82575 },

   111

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), board_82575 },

   112

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82575GB_QUAD_COPPER), board_82575 },

   113

	/* required last entry */

   114

	{0, }

   115

};

   116

   117

// MODULE_DEVICE_TABLE(pci, igb_pci_tbl);

   118

   119

static int igb_setup_all_tx_resources(struct igb_adapter *);

   120

static int igb_setup_all_rx_resources(struct igb_adapter *);

   121

static void igb_free_all_tx_resources(struct igb_adapter *);

   122

static void igb_free_all_rx_resources(struct igb_adapter *);

   123

static void igb_setup_mrqc(struct igb_adapter *);

   124

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

   125

static void igb_remove(struct pci_dev *pdev);

   126

static int igb_sw_init(struct igb_adapter *);

   127

static int igb_open(struct net_device *);

   128

static int igb_close(struct net_device *);

   129

static void igb_configure(struct igb_adapter *);

   130

static void igb_configure_tx(struct igb_adapter *);

   131

static void igb_configure_rx(struct igb_adapter *);

   132

static void igb_clean_all_tx_rings(struct igb_adapter *);

   133

static void igb_clean_all_rx_rings(struct igb_adapter *);

   134

static void igb_clean_tx_ring(struct igb_ring *);

   135

static void igb_clean_rx_ring(struct igb_ring *);

   136

static void igb_set_rx_mode(struct net_device *);

   137

static void igb_update_phy_info(unsigned long);

   138

static void igb_watchdog(unsigned long);

   139

static void igb_watchdog_task(struct work_struct *);

   140

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

   141

static struct rtnl_link_stats64 *igb_get_stats64(struct net_device *dev,

   142

					  struct rtnl_link_stats64 *stats);

   143

static int igb_change_mtu(struct net_device *, int);

   144

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

   145

static void igb_set_uta(struct igb_adapter *adapter);

   146

static irqreturn_t igb_intr(int irq, void *);

   147

static irqreturn_t igb_intr_msi(int irq, void *);

   148

static irqreturn_t igb_msix_other(int irq, void *);

   149

static irqreturn_t igb_msix_ring(int irq, void *);

   150

#ifdef CONFIG_IGB_DCA

   151

static void igb_update_dca(struct igb_q_vector *);

   152

static void igb_setup_dca(struct igb_adapter *);

   153

#endif /* CONFIG_IGB_DCA */

   154

static int igb_poll(struct napi_struct *, int);

   155

static bool igb_clean_tx_irq(struct igb_q_vector *);

   156

static bool igb_clean_rx_irq(struct igb_q_vector *, int);

   157

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

   158

static void igb_tx_timeout(struct net_device *);

   159

static void igb_reset_task(struct work_struct *);

   160

static void igb_vlan_mode(struct net_device *netdev,

   161

			  netdev_features_t features);

   162

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

   163

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

   164

static void igb_restore_vlan(struct igb_adapter *);

   165

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

   166

static void igb_ping_all_vfs(struct igb_adapter *);

   167

static void igb_msg_task(struct igb_adapter *);

   168

static void igb_vmm_control(struct igb_adapter *);

   169

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

   170

static void igb_restore_vf_multicasts(struct igb_adapter *adapter);

   171

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

   172

static int igb_ndo_set_vf_vlan(struct net_device *netdev,

   173

			       int vf, u16 vlan, u8 qos);

   174

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

   175

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

   176

				   bool setting);

   177

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

   178

				 struct ifla_vf_info *ivi);

   179

static void igb_check_vf_rate_limit(struct igb_adapter *);

   180

   181

#ifdef CONFIG_PCI_IOV

   182

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

   183

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

   184

#endif

   185

   186

#ifdef CONFIG_PM

   187

#ifdef CONFIG_PM_SLEEP

   188

static int igb_suspend(struct device *);

   189

#endif

   190

static int igb_resume(struct device *);

   191

#ifdef CONFIG_PM_RUNTIME

   192

static int igb_runtime_suspend(struct device *dev);

   193

static int igb_runtime_resume(struct device *dev);

   194

static int igb_runtime_idle(struct device *dev);

   195

#endif

   196

static const struct dev_pm_ops igb_pm_ops = {

   197

	SET_SYSTEM_SLEEP_PM_OPS(igb_suspend, igb_resume)

   198

	SET_RUNTIME_PM_OPS(igb_runtime_suspend, igb_runtime_resume,

   199

			igb_runtime_idle)

   200

};

   201

#endif

   202

static void igb_shutdown(struct pci_dev *);

   203

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

   204

#ifdef CONFIG_IGB_DCA

   205

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

   206

static struct notifier_block dca_notifier = {

   207

	.notifier_call	= igb_notify_dca,

   208

	.next		= NULL,

   209

	.priority	= 0

   210

};

   211

#endif

   212

#ifdef CONFIG_NET_POLL_CONTROLLER

   213

/* for netdump / net console */

   214

static void igb_netpoll(struct net_device *);

   215

#endif

   216

#ifdef CONFIG_PCI_IOV

   217

static unsigned int max_vfs;

   218

module_param(max_vfs, uint, 0);

   219

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

   220

#endif /* CONFIG_PCI_IOV */

   221

   222

static pci_ers_result_t igb_io_error_detected(struct pci_dev *,

   223

		     pci_channel_state_t);

   224

static pci_ers_result_t igb_io_slot_reset(struct pci_dev *);

   225

static void igb_io_resume(struct pci_dev *);

   226

   227

static const struct pci_error_handlers igb_err_handler = {

   228

	.error_detected = igb_io_error_detected,

   229

	.slot_reset = igb_io_slot_reset,

   230

	.resume = igb_io_resume,

   231

};

   232

   233

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

   234

   235

static struct pci_driver igb_driver = {

   236

	.name     = igb_driver_name,

   237

	.id_table = igb_pci_tbl,

   238

	.probe    = igb_probe,

   239

	.remove   = igb_remove,

   240

#ifdef CONFIG_PM

   241

	.driver.pm = &igb_pm_ops,

   242

#endif

   243

	.shutdown = igb_shutdown,

   244

	.sriov_configure = igb_pci_sriov_configure,

   245

	.err_handler = &igb_err_handler

   246

};

   247

   248

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

   249

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

   250

MODULE_LICENSE("GPL");

   251

MODULE_VERSION(DRV_VERSION);

   252

   253

#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)

   254

static int debug = -1;

   255

module_param(debug, int, 0);

   256

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

   257

   258

struct igb_reg_info {

   259

	u32 ofs;

   260

	char *name;

   261

};

   262

   263

static const struct igb_reg_info igb_reg_info_tbl[] = {

   264

   265

	/* General Registers */

   266

	{E1000_CTRL, "CTRL"},

   267

	{E1000_STATUS, "STATUS"},

   268

	{E1000_CTRL_EXT, "CTRL_EXT"},

   269

   270

	/* Interrupt Registers */

   271

	{E1000_ICR, "ICR"},

   272

   273

	/* RX Registers */

   274

	{E1000_RCTL, "RCTL"},

   275

	{E1000_RDLEN(0), "RDLEN"},

   276

	{E1000_RDH(0), "RDH"},

   277

	{E1000_RDT(0), "RDT"},

   278

	{E1000_RXDCTL(0), "RXDCTL"},

   279

	{E1000_RDBAL(0), "RDBAL"},

   280

	{E1000_RDBAH(0), "RDBAH"},

   281

   282

	/* TX Registers */

   283

	{E1000_TCTL, "TCTL"},

   284

	{E1000_TDBAL(0), "TDBAL"},

   285

	{E1000_TDBAH(0), "TDBAH"},

   286

	{E1000_TDLEN(0), "TDLEN"},

   287

	{E1000_TDH(0), "TDH"},

   288

	{E1000_TDT(0), "TDT"},

   289

	{E1000_TXDCTL(0), "TXDCTL"},

   290

	{E1000_TDFH, "TDFH"},

   291

	{E1000_TDFT, "TDFT"},

   292

	{E1000_TDFHS, "TDFHS"},

   293

	{E1000_TDFPC, "TDFPC"},

   294

   295

	/* List Terminator */

   296

	{}

   297

};

   298

   299

/* igb_regdump - register printout routine */

   300

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

   301

{

   302

	int n = 0;

   303

	char rname[16];

   304

	u32 regs[8];

   305

   306

	switch (reginfo->ofs) {

   307

	case E1000_RDLEN(0):

   308

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

   309

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

   310

		break;

   311

	case E1000_RDH(0):

   312

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

   313

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

   314

		break;

   315

	case E1000_RDT(0):

   316

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

   317

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

   318

		break;

   319

	case E1000_RXDCTL(0):

   320

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

   321

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

   322

		break;

   323

	case E1000_RDBAL(0):

   324

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

   325

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

   326

		break;

   327

	case E1000_RDBAH(0):

   328

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

   329

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

   330

		break;

   331

	case E1000_TDBAL(0):

   332

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

   333

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

   334

		break;

   335

	case E1000_TDBAH(0):

   336

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

   337

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

   338

		break;

   339

	case E1000_TDLEN(0):

   340

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

   341

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

   342

		break;

   343

	case E1000_TDH(0):

   344

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

   345

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

   346

		break;

   347

	case E1000_TDT(0):

   348

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

   349

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

   350

		break;

   351

	case E1000_TXDCTL(0):

   352

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

   353

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

   354

		break;

   355

	default:

   356

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

   357

		return;

   358

	}

   359

   360

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

   361

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

   362

		regs[2], regs[3]);

   363

}

   364

   365

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

   366

static void igb_dump(struct igb_adapter *adapter)

   367

{

   368

	struct net_device *netdev = adapter->netdev;

   369

	struct e1000_hw *hw = &adapter->hw;

   370

	struct igb_reg_info *reginfo;

   371

	struct igb_ring *tx_ring;

   372

	union e1000_adv_tx_desc *tx_desc;

   373

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

   374

	struct igb_ring *rx_ring;

   375

	union e1000_adv_rx_desc *rx_desc;

   376

	u32 staterr;

   377

	u16 i, n;

   378

   379

	if (!netif_msg_hw(adapter))

   380

		return;

   381

   382

	/* Print netdevice Info */

   383

	if (netdev) {

   384

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

   385

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

   386

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

   387

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

   388

	}

   389

   390

	/* Print Registers */

   391

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

   392

	pr_info(" Register Name   Value\n");

   393

	for (reginfo = (struct igb_reg_info *)igb_reg_info_tbl;

   394

	     reginfo->name; reginfo++) {

   395

		igb_regdump(hw, reginfo);

   396

	}

   397

   398

	/* Print TX Ring Summary */

   399

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

   400

		goto exit;

   401

   402

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

   403

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

   404

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

   405

		struct igb_tx_buffer *buffer_info;

   406

		tx_ring = adapter->tx_ring[n];

   407

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

   408

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

   409

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

   410

			(u64)dma_unmap_addr(buffer_info, dma),

   411

			dma_unmap_len(buffer_info, len),

   412

			buffer_info->next_to_watch,

   413

			(u64)buffer_info->time_stamp);

   414

	}

   415

   416

	/* Print TX Rings */

   417

	if (!netif_msg_tx_done(adapter))

   418

		goto rx_ring_summary;

   419

   420

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

   421

   422

	/* Transmit Descriptor Formats

   423

	 *

   424

	 * Advanced Transmit Descriptor

   425

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

   426

	 * 0 |         Buffer Address [63:0]                                |

   427

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

   428

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

   429

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

   430

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

   431

	 */

   432

   433

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

   434

		tx_ring = adapter->tx_ring[n];

   435

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

   436

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

   437

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

   438

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

   439

   440

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

   441

			const char *next_desc;

   442

			struct igb_tx_buffer *buffer_info;

   443

			tx_desc = IGB_TX_DESC(tx_ring, i);

   444

			buffer_info = &tx_ring->tx_buffer_info[i];

   445

			u0 = (struct my_u0 *)tx_desc;

   446

			if (i == tx_ring->next_to_use &&

   447

			    i == tx_ring->next_to_clean)

   448

				next_desc = " NTC/U";

   449

			else if (i == tx_ring->next_to_use)

   450

				next_desc = " NTU";

   451

			else if (i == tx_ring->next_to_clean)

   452

				next_desc = " NTC";

   453

			else

   454

				next_desc = "";

   455

   456

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

   457

				i, le64_to_cpu(u0->a),

   458

				le64_to_cpu(u0->b),

   459

				(u64)dma_unmap_addr(buffer_info, dma),

   460

				dma_unmap_len(buffer_info, len),

   461

				buffer_info->next_to_watch,

   462

				(u64)buffer_info->time_stamp,

   463

				buffer_info->skb, next_desc);

   464

   465

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

   466

				print_hex_dump(KERN_INFO, "",

   467

					DUMP_PREFIX_ADDRESS,

   468

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

   469

					dma_unmap_len(buffer_info, len),

   470

					true);

   471

		}

   472

	}

   473

   474

	/* Print RX Rings Summary */

   475

rx_ring_summary:

   476

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

   477

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

   478

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

   479

		rx_ring = adapter->rx_ring[n];

   480

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

   481

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

   482

	}

   483

   484

	/* Print RX Rings */

   485

	if (!netif_msg_rx_status(adapter))

   486

		goto exit;

   487

   488

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

   489

   490

	/* Advanced Receive Descriptor (Read) Format

   491

	 *    63                                           1        0

   492

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

   493

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

   494

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

   495

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

   496

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

   497

	 *

   498

	 *

   499

	 * Advanced Receive Descriptor (Write-Back) Format

   500

	 *

   501

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

   502

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

   503

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

   504

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

   505

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

   506

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

   507

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

   508

	 *   63       48 47    32 31            20 19               0

   509

	 */

   510

   511

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

   512

		rx_ring = adapter->rx_ring[n];

   513

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

   514

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

   515

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

   516

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

   517

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

   518

   519

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

   520

			const char *next_desc;

   521

			struct igb_rx_buffer *buffer_info;

   522

			buffer_info = &rx_ring->rx_buffer_info[i];

   523

			rx_desc = IGB_RX_DESC(rx_ring, i);

   524

			u0 = (struct my_u0 *)rx_desc;

   525

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

   526

   527

			if (i == rx_ring->next_to_use)

   528

				next_desc = " NTU";