be_main.c 96.9 KB
Newer Older
S
Sathya Perla 已提交
1
/*
2
 * Copyright (C) 2005 - 2011 Emulex
S
Sathya Perla 已提交
3 4 5 6 7 8 9 10
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.  The full GNU General
 * Public License is included in this distribution in the file called COPYING.
 *
 * Contact Information:
11
 * linux-drivers@emulex.com
S
Sathya Perla 已提交
12
 *
13 14 15
 * Emulex
 * 3333 Susan Street
 * Costa Mesa, CA 92626
S
Sathya Perla 已提交
16 17
 */

18
#include <linux/prefetch.h>
19
#include <linux/module.h>
S
Sathya Perla 已提交
20
#include "be.h"
21
#include "be_cmds.h"
22
#include <asm/div64.h>
S
Sathya Perla 已提交
23 24 25 26 27 28 29

MODULE_VERSION(DRV_VER);
MODULE_DEVICE_TABLE(pci, be_dev_ids);
MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
MODULE_AUTHOR("ServerEngines Corporation");
MODULE_LICENSE("GPL");

30 31 32
static unsigned int num_vfs;
module_param(num_vfs, uint, S_IRUGO);
MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
S
Sathya Perla 已提交
33

34 35 36 37
static ushort rx_frag_size = 2048;
module_param(rx_frag_size, ushort, S_IRUGO);
MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");

S
Sathya Perla 已提交
38
static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
39
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
40
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
41 42
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
43
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
44
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
45
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
S
Sathya Perla 已提交
46 47 48
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, be_dev_ids);
49
/* UE Status Low CSR */
50
static const char * const ue_status_low_desc[] = {
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
	"CEV",
	"CTX",
	"DBUF",
	"ERX",
	"Host",
	"MPU",
	"NDMA",
	"PTC ",
	"RDMA ",
	"RXF ",
	"RXIPS ",
	"RXULP0 ",
	"RXULP1 ",
	"RXULP2 ",
	"TIM ",
	"TPOST ",
	"TPRE ",
	"TXIPS ",
	"TXULP0 ",
	"TXULP1 ",
	"UC ",
	"WDMA ",
	"TXULP2 ",
	"HOST1 ",
	"P0_OB_LINK ",
	"P1_OB_LINK ",
	"HOST_GPIO ",
	"MBOX ",
	"AXGMAC0",
	"AXGMAC1",
	"JTAG",
	"MPU_INTPEND"
};
/* UE Status High CSR */
85
static const char * const ue_status_hi_desc[] = {
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
	"LPCMEMHOST",
	"MGMT_MAC",
	"PCS0ONLINE",
	"MPU_IRAM",
	"PCS1ONLINE",
	"PCTL0",
	"PCTL1",
	"PMEM",
	"RR",
	"TXPB",
	"RXPP",
	"XAUI",
	"TXP",
	"ARM",
	"IPC",
	"HOST2",
	"HOST3",
	"HOST4",
	"HOST5",
	"HOST6",
	"HOST7",
	"HOST8",
	"HOST9",
109
	"NETC",
110 111 112 113 114 115 116 117 118
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown"
};
S
Sathya Perla 已提交
119

120 121 122 123 124 125 126
/* Is BE in a multi-channel mode */
static inline bool be_is_mc(struct be_adapter *adapter) {
	return (adapter->function_mode & FLEX10_MODE ||
		adapter->function_mode & VNIC_MODE ||
		adapter->function_mode & UMC_ENABLED);
}

S
Sathya Perla 已提交
127 128 129
static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
{
	struct be_dma_mem *mem = &q->dma_mem;
130
	if (mem->va) {
I
Ivan Vecera 已提交
131 132
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
133 134
		mem->va = NULL;
	}
S
Sathya Perla 已提交
135 136 137 138 139 140 141 142 143 144 145
}

static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
		u16 len, u16 entry_size)
{
	struct be_dma_mem *mem = &q->dma_mem;

	memset(q, 0, sizeof(*q));
	q->len = len;
	q->entry_size = entry_size;
	mem->size = len * entry_size;
I
Ivan Vecera 已提交
146 147
	mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
				     GFP_KERNEL);
S
Sathya Perla 已提交
148
	if (!mem->va)
S
Sathya Perla 已提交
149
		return -ENOMEM;
S
Sathya Perla 已提交
150 151 152 153
	memset(mem->va, 0, mem->size);
	return 0;
}

154
static void be_intr_set(struct be_adapter *adapter, bool enable)
S
Sathya Perla 已提交
155
{
156
	u32 reg, enabled;
157

158 159 160
	if (adapter->eeh_err)
		return;

161 162 163 164
	pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
				&reg);
	enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;

165
	if (!enabled && enable)
S
Sathya Perla 已提交
166
		reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
167
	else if (enabled && !enable)
S
Sathya Perla 已提交
168
		reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
169
	else
S
Sathya Perla 已提交
170
		return;
171

172 173
	pci_write_config_dword(adapter->pdev,
			PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
S
Sathya Perla 已提交
174 175
}

176
static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
S
Sathya Perla 已提交
177 178 179 180
{
	u32 val = 0;
	val |= qid & DB_RQ_RING_ID_MASK;
	val |= posted << DB_RQ_NUM_POSTED_SHIFT;
181 182

	wmb();
183
	iowrite32(val, adapter->db + DB_RQ_OFFSET);
S
Sathya Perla 已提交
184 185
}

186
static void be_txq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
S
Sathya Perla 已提交
187 188 189 190
{
	u32 val = 0;
	val |= qid & DB_TXULP_RING_ID_MASK;
	val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
191 192

	wmb();
193
	iowrite32(val, adapter->db + DB_TXULP1_OFFSET);
S
Sathya Perla 已提交
194 195
}

196
static void be_eq_notify(struct be_adapter *adapter, u16 qid,
S
Sathya Perla 已提交
197 198 199 200
		bool arm, bool clear_int, u16 num_popped)
{
	u32 val = 0;
	val |= qid & DB_EQ_RING_ID_MASK;
201 202
	val |= ((qid & DB_EQ_RING_ID_EXT_MASK) <<
			DB_EQ_RING_ID_EXT_MASK_SHIFT);
203 204 205 206

	if (adapter->eeh_err)
		return;

S
Sathya Perla 已提交
207 208 209 210 211 212
	if (arm)
		val |= 1 << DB_EQ_REARM_SHIFT;
	if (clear_int)
		val |= 1 << DB_EQ_CLR_SHIFT;
	val |= 1 << DB_EQ_EVNT_SHIFT;
	val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
213
	iowrite32(val, adapter->db + DB_EQ_OFFSET);
S
Sathya Perla 已提交
214 215
}

216
void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
S
Sathya Perla 已提交
217 218 219
{
	u32 val = 0;
	val |= qid & DB_CQ_RING_ID_MASK;
220 221
	val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
			DB_CQ_RING_ID_EXT_MASK_SHIFT);
222 223 224 225

	if (adapter->eeh_err)
		return;

S
Sathya Perla 已提交
226 227 228
	if (arm)
		val |= 1 << DB_CQ_REARM_SHIFT;
	val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
229
	iowrite32(val, adapter->db + DB_CQ_OFFSET);
S
Sathya Perla 已提交
230 231 232 233 234 235 236
}

static int be_mac_addr_set(struct net_device *netdev, void *p)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	struct sockaddr *addr = p;
	int status = 0;
237
	u8 current_mac[ETH_ALEN];
238
	u32 pmac_id = adapter->pmac_id[0];
S
Sathya Perla 已提交
239

240 241 242
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

243
	status = be_cmd_mac_addr_query(adapter, current_mac,
244 245
				MAC_ADDRESS_TYPE_NETWORK, false,
				adapter->if_handle, 0);
246
	if (status)
247
		goto err;
S
Sathya Perla 已提交
248

249 250
	if (memcmp(addr->sa_data, current_mac, ETH_ALEN)) {
		status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
251
				adapter->if_handle, &adapter->pmac_id[0], 0);
252 253
		if (status)
			goto err;
S
Sathya Perla 已提交
254

255 256 257 258 259 260
		be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0);
	}
	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
	return 0;
err:
	dev_err(&adapter->pdev->dev, "MAC %pM set Failed\n", addr->sa_data);
S
Sathya Perla 已提交
261 262 263
	return status;
}

264 265
static void populate_be2_stats(struct be_adapter *adapter)
{
266 267 268
	struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
	struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
269
	struct be_port_rxf_stats_v0 *port_stats =
270 271
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
272

273
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
274 275 276 277 278 279 280 281 282 283 284 285 286 287
	drvs->rx_pause_frames = port_stats->rx_pause_frames;
	drvs->rx_crc_errors = port_stats->rx_crc_errors;
	drvs->rx_control_frames = port_stats->rx_control_frames;
	drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
	drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
	drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
	drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
	drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
	drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
	drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
	drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
	drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
	drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
	drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
288
	drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
289 290
	drvs->rx_dropped_header_too_small =
		port_stats->rx_dropped_header_too_small;
291 292 293
	drvs->rx_address_mismatch_drops =
					port_stats->rx_address_mismatch_drops +
					port_stats->rx_vlan_mismatch_drops;
294 295 296 297 298 299 300
	drvs->rx_alignment_symbol_errors =
		port_stats->rx_alignment_symbol_errors;

	drvs->tx_pauseframes = port_stats->tx_pauseframes;
	drvs->tx_controlframes = port_stats->tx_controlframes;

	if (adapter->port_num)
301
		drvs->jabber_events = rxf_stats->port1_jabber_events;
302
	else
303
		drvs->jabber_events = rxf_stats->port0_jabber_events;
304 305 306 307
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
308 309
	drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
	drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
310 311 312 313 314
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

static void populate_be3_stats(struct be_adapter *adapter)
{
315 316 317
	struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
	struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
318
	struct be_port_rxf_stats_v1 *port_stats =
319 320
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
321

322
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
323 324
	drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
	drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
	drvs->rx_pause_frames = port_stats->rx_pause_frames;
	drvs->rx_crc_errors = port_stats->rx_crc_errors;
	drvs->rx_control_frames = port_stats->rx_control_frames;
	drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
	drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
	drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
	drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
	drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
	drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
	drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
	drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
	drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
	drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
	drvs->rx_dropped_header_too_small =
		port_stats->rx_dropped_header_too_small;
	drvs->rx_input_fifo_overflow_drop =
		port_stats->rx_input_fifo_overflow_drop;
342
	drvs->rx_address_mismatch_drops = port_stats->rx_address_mismatch_drops;
343 344
	drvs->rx_alignment_symbol_errors =
		port_stats->rx_alignment_symbol_errors;
345
	drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
346 347 348 349 350 351 352
	drvs->tx_pauseframes = port_stats->tx_pauseframes;
	drvs->tx_controlframes = port_stats->tx_controlframes;
	drvs->jabber_events = port_stats->jabber_events;
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
353 354
	drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
	drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
355 356 357
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

S
Selvin Xavier 已提交
358 359
static void populate_lancer_stats(struct be_adapter *adapter)
{
360

S
Selvin Xavier 已提交
361
	struct be_drv_stats *drvs = &adapter->drv_stats;
362 363 364 365 366 367 368
	struct lancer_pport_stats *pport_stats =
					pport_stats_from_cmd(adapter);

	be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
	drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
	drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
	drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
S
Selvin Xavier 已提交
369
	drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
370
	drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
S
Selvin Xavier 已提交
371 372 373 374 375 376 377 378 379 380 381 382
	drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
	drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
	drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
	drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
	drvs->rx_dropped_tcp_length =
				pport_stats->rx_dropped_invalid_tcp_length;
	drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
	drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
	drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
	drvs->rx_dropped_header_too_small =
				pport_stats->rx_dropped_header_too_small;
	drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
383 384 385
	drvs->rx_address_mismatch_drops =
					pport_stats->rx_address_mismatch_drops +
					pport_stats->rx_vlan_mismatch_drops;
386
	drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
S
Selvin Xavier 已提交
387
	drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
388 389
	drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
	drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
S
Selvin Xavier 已提交
390
	drvs->jabber_events = pport_stats->rx_jabbers;
391 392
	drvs->forwarded_packets = pport_stats->num_forwards_lo;
	drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
S
Selvin Xavier 已提交
393
	drvs->rx_drops_too_many_frags =
394
				pport_stats->rx_drops_too_many_frags_lo;
S
Selvin Xavier 已提交
395
}
396

397 398 399 400 401 402 403 404 405 406 407 408
static void accumulate_16bit_val(u32 *acc, u16 val)
{
#define lo(x)			(x & 0xFFFF)
#define hi(x)			(x & 0xFFFF0000)
	bool wrapped = val < lo(*acc);
	u32 newacc = hi(*acc) + val;

	if (wrapped)
		newacc += 65536;
	ACCESS_ONCE(*acc) = newacc;
}

409 410
void be_parse_stats(struct be_adapter *adapter)
{
411 412 413 414
	struct be_erx_stats_v1 *erx = be_erx_stats_from_cmd(adapter);
	struct be_rx_obj *rxo;
	int i;

S
Selvin Xavier 已提交
415 416 417 418 419 420
	if (adapter->generation == BE_GEN3) {
		if (lancer_chip(adapter))
			populate_lancer_stats(adapter);
		 else
			populate_be3_stats(adapter);
	} else {
421
		populate_be2_stats(adapter);
S
Selvin Xavier 已提交
422
	}
423

424 425 426
	if (lancer_chip(adapter))
		goto done;

427
	/* as erx_v1 is longer than v0, ok to use v1 defn for v0 access */
428 429 430 431 432 433 434
	for_all_rx_queues(adapter, rxo, i) {
		/* below erx HW counter can actually wrap around after
		 * 65535. Driver accumulates a 32-bit value
		 */
		accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
				(u16)erx->rx_drops_no_fragments[rxo->q.id]);
	}
435 436
done:
	return;
437 438
}

439 440
static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
					struct rtnl_link_stats64 *stats)
S
Sathya Perla 已提交
441
{
442
	struct be_adapter *adapter = netdev_priv(netdev);
443
	struct be_drv_stats *drvs = &adapter->drv_stats;
444
	struct be_rx_obj *rxo;
445
	struct be_tx_obj *txo;
446 447
	u64 pkts, bytes;
	unsigned int start;
448
	int i;
S
Sathya Perla 已提交
449

450
	for_all_rx_queues(adapter, rxo, i) {
451 452 453 454 455 456 457 458 459 460 461
		const struct be_rx_stats *rx_stats = rx_stats(rxo);
		do {
			start = u64_stats_fetch_begin_bh(&rx_stats->sync);
			pkts = rx_stats(rxo)->rx_pkts;
			bytes = rx_stats(rxo)->rx_bytes;
		} while (u64_stats_fetch_retry_bh(&rx_stats->sync, start));
		stats->rx_packets += pkts;
		stats->rx_bytes += bytes;
		stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
		stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
					rx_stats(rxo)->rx_drops_no_frags;
462 463
	}

464
	for_all_tx_queues(adapter, txo, i) {
465 466 467 468 469 470 471 472
		const struct be_tx_stats *tx_stats = tx_stats(txo);
		do {
			start = u64_stats_fetch_begin_bh(&tx_stats->sync);
			pkts = tx_stats(txo)->tx_pkts;
			bytes = tx_stats(txo)->tx_bytes;
		} while (u64_stats_fetch_retry_bh(&tx_stats->sync, start));
		stats->tx_packets += pkts;
		stats->tx_bytes += bytes;
473
	}
S
Sathya Perla 已提交
474 475

	/* bad pkts received */
476
	stats->rx_errors = drvs->rx_crc_errors +
477 478 479 480 481 482 483 484
		drvs->rx_alignment_symbol_errors +
		drvs->rx_in_range_errors +
		drvs->rx_out_range_errors +
		drvs->rx_frame_too_long +
		drvs->rx_dropped_too_small +
		drvs->rx_dropped_too_short +
		drvs->rx_dropped_header_too_small +
		drvs->rx_dropped_tcp_length +
485
		drvs->rx_dropped_runt;
486

S
Sathya Perla 已提交
487
	/* detailed rx errors */
488
	stats->rx_length_errors = drvs->rx_in_range_errors +
489 490
		drvs->rx_out_range_errors +
		drvs->rx_frame_too_long;
491

492
	stats->rx_crc_errors = drvs->rx_crc_errors;
S
Sathya Perla 已提交
493 494

	/* frame alignment errors */
495
	stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
496

S
Sathya Perla 已提交
497 498
	/* receiver fifo overrun */
	/* drops_no_pbuf is no per i/f, it's per BE card */
499
	stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
500 501
				drvs->rx_input_fifo_overflow_drop +
				drvs->rx_drops_no_pbuf;
502
	return stats;
S
Sathya Perla 已提交
503 504
}

505
void be_link_status_update(struct be_adapter *adapter, u8 link_status)
S
Sathya Perla 已提交
506 507 508
{
	struct net_device *netdev = adapter->netdev;

509
	if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
510
		netif_carrier_off(netdev);
511
		adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
S
Sathya Perla 已提交
512
	}
513 514 515 516 517

	if ((link_status & LINK_STATUS_MASK) == LINK_UP)
		netif_carrier_on(netdev);
	else
		netif_carrier_off(netdev);
S
Sathya Perla 已提交
518 519
}

520
static void be_tx_stats_update(struct be_tx_obj *txo,
521
			u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
S
Sathya Perla 已提交
522
{
523 524
	struct be_tx_stats *stats = tx_stats(txo);

525
	u64_stats_update_begin(&stats->sync);
526 527 528 529
	stats->tx_reqs++;
	stats->tx_wrbs += wrb_cnt;
	stats->tx_bytes += copied;
	stats->tx_pkts += (gso_segs ? gso_segs : 1);
S
Sathya Perla 已提交
530
	if (stopped)
531
		stats->tx_stops++;
532
	u64_stats_update_end(&stats->sync);
S
Sathya Perla 已提交
533 534 535
}

/* Determine number of WRB entries needed to xmit data in an skb */
536 537
static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
								bool *dummy)
S
Sathya Perla 已提交
538
{
539 540 541 542
	int cnt = (skb->len > skb->data_len);

	cnt += skb_shinfo(skb)->nr_frags;

S
Sathya Perla 已提交
543 544
	/* to account for hdr wrb */
	cnt++;
545 546 547
	if (lancer_chip(adapter) || !(cnt & 1)) {
		*dummy = false;
	} else {
S
Sathya Perla 已提交
548 549 550
		/* add a dummy to make it an even num */
		cnt++;
		*dummy = true;
551
	}
S
Sathya Perla 已提交
552 553 554 555 556 557 558 559 560 561 562
	BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
	return cnt;
}

static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
{
	wrb->frag_pa_hi = upper_32_bits(addr);
	wrb->frag_pa_lo = addr & 0xFFFFFFFF;
	wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
}

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
					struct sk_buff *skb)
{
	u8 vlan_prio;
	u16 vlan_tag;

	vlan_tag = vlan_tx_tag_get(skb);
	vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
	/* If vlan priority provided by OS is NOT in available bmap */
	if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
		vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
				adapter->recommended_prio;

	return vlan_tag;
}

579 580
static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
		struct sk_buff *skb, u32 wrb_cnt, u32 len)
S
Sathya Perla 已提交
581
{
582
	u16 vlan_tag;
583

S
Sathya Perla 已提交
584 585 586 587
	memset(hdr, 0, sizeof(*hdr));

	AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);

A
Ajit Khaparde 已提交
588
	if (skb_is_gso(skb)) {
S
Sathya Perla 已提交
589 590 591
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
			hdr, skb_shinfo(skb)->gso_size);
592
		if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
A
Ajit Khaparde 已提交
593
			AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
594 595 596 597 598 599 600 601 602 603
		if (lancer_chip(adapter) && adapter->sli_family  ==
							LANCER_A0_SLI_FAMILY) {
			AMAP_SET_BITS(struct amap_eth_hdr_wrb, ipcs, hdr, 1);
			if (is_tcp_pkt(skb))
				AMAP_SET_BITS(struct amap_eth_hdr_wrb,
								tcpcs, hdr, 1);
			else if (is_udp_pkt(skb))
				AMAP_SET_BITS(struct amap_eth_hdr_wrb,
								udpcs, hdr, 1);
		}
S
Sathya Perla 已提交
604 605 606 607 608 609 610
	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
		if (is_tcp_pkt(skb))
			AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
		else if (is_udp_pkt(skb))
			AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
	}

A
Ajit Khaparde 已提交
611
	if (vlan_tx_tag_present(skb)) {
S
Sathya Perla 已提交
612
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
613
		vlan_tag = be_get_tx_vlan_tag(adapter, skb);
614
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
S
Sathya Perla 已提交
615 616 617 618 619 620 621 622
	}

	AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
	AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, 1);
	AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
	AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
}

I
Ivan Vecera 已提交
623
static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
624 625 626 627 628 629 630
		bool unmap_single)
{
	dma_addr_t dma;

	be_dws_le_to_cpu(wrb, sizeof(*wrb));

	dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
631
	if (wrb->frag_len) {
632
		if (unmap_single)
I
Ivan Vecera 已提交
633 634
			dma_unmap_single(dev, dma, wrb->frag_len,
					 DMA_TO_DEVICE);
635
		else
I
Ivan Vecera 已提交
636
			dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
637 638
	}
}
S
Sathya Perla 已提交
639

640
static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
S
Sathya Perla 已提交
641 642
		struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
{
643 644
	dma_addr_t busaddr;
	int i, copied = 0;
I
Ivan Vecera 已提交
645
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
646 647 648
	struct sk_buff *first_skb = skb;
	struct be_eth_wrb *wrb;
	struct be_eth_hdr_wrb *hdr;
649 650
	bool map_single = false;
	u16 map_head;
S
Sathya Perla 已提交
651 652 653

	hdr = queue_head_node(txq);
	queue_head_inc(txq);
654
	map_head = txq->head;
S
Sathya Perla 已提交
655

656
	if (skb->len > skb->data_len) {
E
Eric Dumazet 已提交
657
		int len = skb_headlen(skb);
I
Ivan Vecera 已提交
658 659
		busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
		if (dma_mapping_error(dev, busaddr))
660 661
			goto dma_err;
		map_single = true;
662 663 664 665 666 667
		wrb = queue_head_node(txq);
		wrb_fill(wrb, busaddr, len);
		be_dws_cpu_to_le(wrb, sizeof(*wrb));
		queue_head_inc(txq);
		copied += len;
	}
S
Sathya Perla 已提交
668

669
	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
E
Eric Dumazet 已提交
670
		const struct skb_frag_struct *frag =
671
			&skb_shinfo(skb)->frags[i];
672
		busaddr = skb_frag_dma_map(dev, frag, 0,
E
Eric Dumazet 已提交
673
					   skb_frag_size(frag), DMA_TO_DEVICE);
I
Ivan Vecera 已提交
674
		if (dma_mapping_error(dev, busaddr))
675
			goto dma_err;
676
		wrb = queue_head_node(txq);
E
Eric Dumazet 已提交
677
		wrb_fill(wrb, busaddr, skb_frag_size(frag));
678 679
		be_dws_cpu_to_le(wrb, sizeof(*wrb));
		queue_head_inc(txq);
E
Eric Dumazet 已提交
680
		copied += skb_frag_size(frag);
S
Sathya Perla 已提交
681 682 683 684 685 686 687 688 689
	}

	if (dummy_wrb) {
		wrb = queue_head_node(txq);
		wrb_fill(wrb, 0, 0);
		be_dws_cpu_to_le(wrb, sizeof(*wrb));
		queue_head_inc(txq);
	}

690
	wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied);
S
Sathya Perla 已提交
691 692 693
	be_dws_cpu_to_le(hdr, sizeof(*hdr));

	return copied;
694 695 696 697
dma_err:
	txq->head = map_head;
	while (copied) {
		wrb = queue_head_node(txq);
I
Ivan Vecera 已提交
698
		unmap_tx_frag(dev, wrb, map_single);
699 700 701 702 703
		map_single = false;
		copied -= wrb->frag_len;
		queue_head_inc(txq);
	}
	return 0;
S
Sathya Perla 已提交
704 705
}

706
static netdev_tx_t be_xmit(struct sk_buff *skb,
707
			struct net_device *netdev)
S
Sathya Perla 已提交
708 709
{
	struct be_adapter *adapter = netdev_priv(netdev);
710 711
	struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
	struct be_queue_info *txq = &txo->q;
S
Sathya Perla 已提交
712 713 714 715
	u32 wrb_cnt = 0, copied = 0;
	u32 start = txq->head;
	bool dummy_wrb, stopped = false;

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
	/* For vlan tagged pkts, BE
	 * 1) calculates checksum even when CSO is not requested
	 * 2) calculates checksum wrongly for padded pkt less than
	 * 60 bytes long.
	 * As a workaround disable TX vlan offloading in such cases.
	 */
	if (unlikely(vlan_tx_tag_present(skb) &&
		     (skb->ip_summed != CHECKSUM_PARTIAL || skb->len <= 60))) {
		skb = skb_share_check(skb, GFP_ATOMIC);
		if (unlikely(!skb))
			goto tx_drop;

		skb = __vlan_put_tag(skb, be_get_tx_vlan_tag(adapter, skb));
		if (unlikely(!skb))
			goto tx_drop;

		skb->vlan_tci = 0;
	}

735
	wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
S
Sathya Perla 已提交
736

737
	copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb);
738 739
	if (copied) {
		/* record the sent skb in the sent_skb table */
740 741
		BUG_ON(txo->sent_skb_list[start]);
		txo->sent_skb_list[start] = skb;
742 743 744 745 746

		/* Ensure txq has space for the next skb; Else stop the queue
		 * *BEFORE* ringing the tx doorbell, so that we serialze the
		 * tx compls of the current transmit which'll wake up the queue
		 */
747
		atomic_add(wrb_cnt, &txq->used);
748 749
		if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
								txq->len) {
750
			netif_stop_subqueue(netdev, skb_get_queue_mapping(skb));
751 752
			stopped = true;
		}
S
Sathya Perla 已提交
753

754
		be_txq_notify(adapter, txq->id, wrb_cnt);
S
Sathya Perla 已提交
755

756
		be_tx_stats_update(txo, wrb_cnt, copied,
757
				skb_shinfo(skb)->gso_segs, stopped);
758 759 760
	} else {
		txq->head = start;
		dev_kfree_skb_any(skb);
S
Sathya Perla 已提交
761
	}
762
tx_drop:
S
Sathya Perla 已提交
763 764 765 766 767 768 769
	return NETDEV_TX_OK;
}

static int be_change_mtu(struct net_device *netdev, int new_mtu)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	if (new_mtu < BE_MIN_MTU ||
A
Ajit Khaparde 已提交
770 771
			new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
					(ETH_HLEN + ETH_FCS_LEN))) {
S
Sathya Perla 已提交
772 773
		dev_info(&adapter->pdev->dev,
			"MTU must be between %d and %d bytes\n",
A
Ajit Khaparde 已提交
774 775
			BE_MIN_MTU,
			(BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
S
Sathya Perla 已提交
776 777 778 779 780 781 782 783 784
		return -EINVAL;
	}
	dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
			netdev->mtu, new_mtu);
	netdev->mtu = new_mtu;
	return 0;
}

/*
785 786
 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
 * If the user configures more, place BE in vlan promiscuous mode.
S
Sathya Perla 已提交
787
 */
788
static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
S
Sathya Perla 已提交
789
{
790
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf_num];
S
Sathya Perla 已提交
791 792
	u16 vtag[BE_NUM_VLANS_SUPPORTED];
	u16 ntags = 0, i;
793
	int status = 0;
794 795

	if (vf) {
796 797 798
		vtag[0] = cpu_to_le16(vf_cfg->vlan_tag);
		status = be_cmd_vlan_config(adapter, vf_cfg->if_handle, vtag,
					    1, 1, 0);
799
	}
S
Sathya Perla 已提交
800

801 802 803 804
	/* No need to further configure vids if in promiscuous mode */
	if (adapter->promiscuous)
		return 0;

805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
	if (adapter->vlans_added > adapter->max_vlans)
		goto set_vlan_promisc;

	/* Construct VLAN Table to give to HW */
	for (i = 0; i < VLAN_N_VID; i++)
		if (adapter->vlan_tag[i])
			vtag[ntags++] = cpu_to_le16(i);

	status = be_cmd_vlan_config(adapter, adapter->if_handle,
				    vtag, ntags, 1, 0);

	/* Set to VLAN promisc mode as setting VLAN filter failed */
	if (status) {
		dev_info(&adapter->pdev->dev, "Exhausted VLAN HW filters.\n");
		dev_info(&adapter->pdev->dev, "Disabling HW VLAN filtering.\n");
		goto set_vlan_promisc;
S
Sathya Perla 已提交
821
	}
822

823
	return status;
824 825 826 827 828

set_vlan_promisc:
	status = be_cmd_vlan_config(adapter, adapter->if_handle,
				    NULL, 0, 1, 1);
	return status;
S
Sathya Perla 已提交
829 830
}

831
static int be_vlan_add_vid(struct net_device *netdev, u16 vid)
S
Sathya Perla 已提交
832 833
{
	struct be_adapter *adapter = netdev_priv(netdev);
A
Ajit Khaparde 已提交
834
	int status = 0;
S
Sathya Perla 已提交
835

A
Ajit Khaparde 已提交
836 837 838 839
	if (!be_physfn(adapter)) {
		status = -EINVAL;
		goto ret;
	}
840

S
Sathya Perla 已提交
841
	adapter->vlan_tag[vid] = 1;
842
	if (adapter->vlans_added <= (adapter->max_vlans + 1))
A
Ajit Khaparde 已提交
843
		status = be_vid_config(adapter, false, 0);
844

A
Ajit Khaparde 已提交
845 846 847 848 849 850
	if (!status)
		adapter->vlans_added++;
	else
		adapter->vlan_tag[vid] = 0;
ret:
	return status;
S
Sathya Perla 已提交
851 852
}

853
static int be_vlan_rem_vid(struct net_device *netdev, u16 vid)
S
Sathya Perla 已提交
854 855
{
	struct be_adapter *adapter = netdev_priv(netdev);
A
Ajit Khaparde 已提交
856
	int status = 0;
S
Sathya Perla 已提交
857

A
Ajit Khaparde 已提交
858 859 860 861
	if (!be_physfn(adapter)) {
		status = -EINVAL;
		goto ret;
	}
862

S
Sathya Perla 已提交
863
	adapter->vlan_tag[vid] = 0;
864
	if (adapter->vlans_added <= adapter->max_vlans)
A
Ajit Khaparde 已提交
865
		status = be_vid_config(adapter, false, 0);
866

A
Ajit Khaparde 已提交
867 868 869 870 871 872
	if (!status)
		adapter->vlans_added--;
	else
		adapter->vlan_tag[vid] = 1;
ret:
	return status;
S
Sathya Perla 已提交
873 874
}

875
static void be_set_rx_mode(struct net_device *netdev)
S
Sathya Perla 已提交
876 877
{
	struct be_adapter *adapter = netdev_priv(netdev);
878
	int status;
S
Sathya Perla 已提交
879

880
	if (netdev->flags & IFF_PROMISC) {
881
		be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
882 883
		adapter->promiscuous = true;
		goto done;
S
Sathya Perla 已提交
884 885
	}

L
Lucas De Marchi 已提交
886
	/* BE was previously in promiscuous mode; disable it */
887 888
	if (adapter->promiscuous) {
		adapter->promiscuous = false;
889
		be_cmd_rx_filter(adapter, IFF_PROMISC, OFF);
890 891 892

		if (adapter->vlans_added)
			be_vid_config(adapter, false, 0);
S
Sathya Perla 已提交
893 894
	}

895
	/* Enable multicast promisc if num configured exceeds what we support */
896
	if (netdev->flags & IFF_ALLMULTI ||
897 898
			netdev_mc_count(netdev) > BE_MAX_MC) {
		be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
899
		goto done;
S
Sathya Perla 已提交
900 901
	}

902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
	if (netdev_uc_count(netdev) != adapter->uc_macs) {
		struct netdev_hw_addr *ha;
		int i = 1; /* First slot is claimed by the Primary MAC */

		for (; adapter->uc_macs > 0; adapter->uc_macs--, i++) {
			be_cmd_pmac_del(adapter, adapter->if_handle,
					adapter->pmac_id[i], 0);
		}

		if (netdev_uc_count(netdev) > adapter->max_pmac_cnt) {
			be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
			adapter->promiscuous = true;
			goto done;
		}

		netdev_for_each_uc_addr(ha, adapter->netdev) {
			adapter->uc_macs++; /* First slot is for Primary MAC */
			be_cmd_pmac_add(adapter, (u8 *)ha->addr,
					adapter->if_handle,
					&adapter->pmac_id[adapter->uc_macs], 0);
		}
	}

925 926 927 928 929 930 931 932
	status = be_cmd_rx_filter(adapter, IFF_MULTICAST, ON);

	/* Set to MCAST promisc mode if setting MULTICAST address fails */
	if (status) {
		dev_info(&adapter->pdev->dev, "Exhausted multicast HW filters.\n");
		dev_info(&adapter->pdev->dev, "Disabling HW multicast filtering.\n");
		be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
	}
933 934
done:
	return;
S
Sathya Perla 已提交
935 936
}

937 938 939
static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
{
	struct be_adapter *adapter = netdev_priv(netdev);
940
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
941 942
	int status;

943
	if (!sriov_enabled(adapter))
944 945
		return -EPERM;

946
	if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
947 948
		return -EINVAL;

949 950 951
	if (lancer_chip(adapter)) {
		status = be_cmd_set_mac_list(adapter,  mac, 1, vf + 1);
	} else {
952 953
		status = be_cmd_pmac_del(adapter, vf_cfg->if_handle,
					 vf_cfg->pmac_id, vf + 1);
954

955 956
		status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
					 &vf_cfg->pmac_id, vf + 1);
957 958
	}

959
	if (status)
960 961
		dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
				mac, vf);
962
	else
963
		memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
964

965 966 967
	return status;
}

968 969 970 971
static int be_get_vf_config(struct net_device *netdev, int vf,
			struct ifla_vf_info *vi)
{
	struct be_adapter *adapter = netdev_priv(netdev);
972
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
973

974
	if (!sriov_enabled(adapter))
975 976
		return -EPERM;

977
	if (vf >= adapter->num_vfs)
978 979 980
		return -EINVAL;

	vi->vf = vf;
981 982
	vi->tx_rate = vf_cfg->tx_rate;
	vi->vlan = vf_cfg->vlan_tag;
983
	vi->qos = 0;
984
	memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
985 986 987 988

	return 0;
}

989 990 991 992 993 994
static int be_set_vf_vlan(struct net_device *netdev,
			int vf, u16 vlan, u8 qos)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	int status = 0;

995
	if (!sriov_enabled(adapter))
996 997
		return -EPERM;

998
	if (vf >= adapter->num_vfs || vlan > 4095)
999 1000 1001
		return -EINVAL;

	if (vlan) {
1002 1003 1004 1005 1006 1007 1008
		if (adapter->vf_cfg[vf].vlan_tag != vlan) {
			/* If this is new value, program it. Else skip. */
			adapter->vf_cfg[vf].vlan_tag = vlan;

			status = be_cmd_set_hsw_config(adapter, vlan,
				vf + 1, adapter->vf_cfg[vf].if_handle);
		}
1009
	} else {
1010
		/* Reset Transparent Vlan Tagging. */
1011
		adapter->vf_cfg[vf].vlan_tag = 0;
1012 1013 1014
		vlan = adapter->vf_cfg[vf].def_vid;
		status = be_cmd_set_hsw_config(adapter, vlan, vf + 1,
			adapter->vf_cfg[vf].if_handle);
1015 1016 1017 1018 1019 1020 1021 1022 1023
	}


	if (status)
		dev_info(&adapter->pdev->dev,
				"VLAN %d config on VF %d failed\n", vlan, vf);
	return status;
}

1024 1025 1026 1027 1028 1029
static int be_set_vf_tx_rate(struct net_device *netdev,
			int vf, int rate)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	int status = 0;

1030
	if (!sriov_enabled(adapter))
1031 1032
		return -EPERM;

1033
	if (vf >= adapter->num_vfs)
1034 1035
		return -EINVAL;

1036 1037 1038 1039 1040
	if (rate < 100 || rate > 10000) {
		dev_err(&adapter->pdev->dev,
			"tx rate must be between 100 and 10000 Mbps\n");
		return -EINVAL;
	}
1041

1042
	status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
1043 1044

	if (status)
1045
		dev_err(&adapter->pdev->dev,
1046
				"tx rate %d on VF %d failed\n", rate, vf);
1047 1048
	else
		adapter->vf_cfg[vf].tx_rate = rate;
1049 1050 1051
	return status;
}

S
Sathya Perla 已提交
1052
static void be_eqd_update(struct be_adapter *adapter, struct be_eq_obj *eqo)
S
Sathya Perla 已提交
1053
{
S
Sathya Perla 已提交
1054
	struct be_rx_stats *stats = rx_stats(&adapter->rx_obj[eqo->idx]);
1055
	ulong now = jiffies;
1056
	ulong delta = now - stats->rx_jiffies;
1057 1058
	u64 pkts;
	unsigned int start, eqd;
1059

S
Sathya Perla 已提交
1060 1061 1062 1063 1064 1065
	if (!eqo->enable_aic) {
		eqd = eqo->eqd;
		goto modify_eqd;
	}

	if (eqo->idx >= adapter->num_rx_qs)
1066
		return;
S
Sathya Perla 已提交
1067

S
Sathya Perla 已提交
1068 1069
	stats = rx_stats(&adapter->rx_obj[eqo->idx]);

1070
	/* Wrapped around */
1071 1072
	if (time_before(now, stats->rx_jiffies)) {
		stats->rx_jiffies = now;
1073 1074
		return;
	}
S
Sathya Perla 已提交
1075

1076 1077
	/* Update once a second */
	if (delta < HZ)
S
Sathya Perla 已提交
1078 1079
		return;

1080 1081 1082 1083 1084
	do {
		start = u64_stats_fetch_begin_bh(&stats->sync);
		pkts = stats->rx_pkts;
	} while (u64_stats_fetch_retry_bh(&stats->sync, start));

1085
	stats->rx_pps = (unsigned long)(pkts - stats->rx_pkts_prev) / (delta / HZ);
1086
	stats->rx_pkts_prev = pkts;
1087
	stats->rx_jiffies = now;
S
Sathya Perla 已提交
1088 1089 1090
	eqd = (stats->rx_pps / 110000) << 3;
	eqd = min(eqd, eqo->max_eqd);
	eqd = max(eqd, eqo->min_eqd);
1091 1092
	if (eqd < 10)
		eqd = 0;
S
Sathya Perla 已提交
1093 1094 1095 1096 1097

modify_eqd:
	if (eqd != eqo->cur_eqd) {
		be_cmd_modify_eqd(adapter, eqo->q.id, eqd);
		eqo->cur_eqd = eqd;
1098
	}
S
Sathya Perla 已提交
1099 1100
}

1101
static void be_rx_stats_update(struct be_rx_obj *rxo,
1102
		struct be_rx_compl_info *rxcp)
1103
{
1104
	struct be_rx_stats *stats = rx_stats(rxo);
1105

1106
	u64_stats_update_begin(&stats->sync);
1107
	stats->rx_compl++;
1108
	stats->rx_bytes += rxcp->pkt_size;
1109
	stats->rx_pkts++;
1110
	if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1111
		stats->rx_mcast_pkts++;
1112
	if (rxcp->err)
1113
		stats->rx_compl_err++;
1114
	u64_stats_update_end(&stats->sync);
1115 1116
}

1117
static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1118
{
1119 1120
	/* L4 checksum is not reliable for non TCP/UDP packets.
	 * Also ignore ipcksm for ipv6 pkts */
1121 1122
	return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
				(rxcp->ip_csum || rxcp->ipv6);
1123 1124
}

S
Sathya Perla 已提交
1125 1126
static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo,
						u16 frag_idx)
S
Sathya Perla 已提交
1127
{
S
Sathya Perla 已提交
1128
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
1129
	struct be_rx_page_info *rx_page_info;
1130
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1131

1132
	rx_page_info = &rxo->page_info_tbl[frag_idx];
S
Sathya Perla 已提交
1133 1134
	BUG_ON(!rx_page_info->page);

A
Ajit Khaparde 已提交
1135
	if (rx_page_info->last_page_user) {
I
Ivan Vecera 已提交
1136 1137 1138
		dma_unmap_page(&adapter->pdev->dev,
			       dma_unmap_addr(rx_page_info, bus),
			       adapter->big_page_size, DMA_FROM_DEVICE);
A
Ajit Khaparde 已提交
1139 1140
		rx_page_info->last_page_user = false;
	}
S
Sathya Perla 已提交
1141 1142 1143 1144 1145 1146

	atomic_dec(&rxq->used);
	return rx_page_info;
}

/* Throwaway the data in the Rx completion */
S
Sathya Perla 已提交
1147 1148
static void be_rx_compl_discard(struct be_rx_obj *rxo,
				struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1149
{
1150
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1151
	struct be_rx_page_info *page_info;
1152
	u16 i, num_rcvd = rxcp->num_rcvd;
S
Sathya Perla 已提交
1153

1154
	for (i = 0; i < num_rcvd; i++) {
S
Sathya Perla 已提交
1155
		page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1156 1157
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
1158
		index_inc(&rxcp->rxq_idx, rxq->len);
S
Sathya Perla 已提交
1159 1160 1161 1162 1163 1164 1165
	}
}

/*
 * skb_fill_rx_data forms a complete skb for an ether frame
 * indicated by rxcp.
 */
S
Sathya Perla 已提交
1166 1167
static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
			     struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1168
{
1169
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1170
	struct be_rx_page_info *page_info;
1171 1172
	u16 i, j;
	u16 hdr_len, curr_frag_len, remaining;
S
Sathya Perla 已提交
1173 1174
	u8 *start;

S
Sathya Perla 已提交
1175
	page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
S
Sathya Perla 已提交
1176 1177 1178 1179
	start = page_address(page_info->page) + page_info->page_offset;
	prefetch(start);

	/* Copy data in the first descriptor of this completion */
1180
	curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
S
Sathya Perla 已提交
1181 1182

	/* Copy the header portion into skb_data */
1183
	hdr_len = min(BE_HDR_LEN, curr_frag_len);
S
Sathya Perla 已提交
1184 1185 1186 1187 1188 1189 1190 1191 1192
	memcpy(skb->data, start, hdr_len);
	skb->len = curr_frag_len;
	if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
		/* Complete packet has now been moved to data */
		put_page(page_info->page);
		skb->data_len = 0;
		skb->tail += curr_frag_len;
	} else {
		skb_shinfo(skb)->nr_frags = 1;
1193
		skb_frag_set_page(skb, 0, page_info->page);
S
Sathya Perla 已提交
1194 1195
		skb_shinfo(skb)->frags[0].page_offset =
					page_info->page_offset + hdr_len;
E
Eric Dumazet 已提交
1196
		skb_frag_size_set(&skb_shinfo(skb)->frags[0], curr_frag_len - hdr_len);
S
Sathya Perla 已提交
1197
		skb->data_len = curr_frag_len - hdr_len;
E
Eric Dumazet 已提交
1198
		skb->truesize += rx_frag_size;
S
Sathya Perla 已提交
1199 1200
		skb->tail += hdr_len;
	}
A
Ajit Khaparde 已提交
1201
	page_info->page = NULL;
S
Sathya Perla 已提交
1202

1203 1204 1205
	if (rxcp->pkt_size <= rx_frag_size) {
		BUG_ON(rxcp->num_rcvd != 1);
		return;
S
Sathya Perla 已提交
1206 1207 1208
	}

	/* More frags present for this completion */
1209 1210 1211
	index_inc(&rxcp->rxq_idx, rxq->len);
	remaining = rxcp->pkt_size - curr_frag_len;
	for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
S
Sathya Perla 已提交
1212
		page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1213
		curr_frag_len = min(remaining, rx_frag_size);
S
Sathya Perla 已提交
1214

1215 1216 1217 1218
		/* Coalesce all frags from the same physical page in one slot */
		if (page_info->page_offset == 0) {
			/* Fresh page */
			j++;
1219
			skb_frag_set_page(skb, j, page_info->page);
1220 1221
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
1222
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1223 1224 1225 1226 1227
			skb_shinfo(skb)->nr_frags++;
		} else {
			put_page(page_info->page);
		}

E
Eric Dumazet 已提交
1228
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
S
Sathya Perla 已提交
1229 1230
		skb->len += curr_frag_len;
		skb->data_len += curr_frag_len;
E
Eric Dumazet 已提交
1231
		skb->truesize += rx_frag_size;
1232 1233
		remaining -= curr_frag_len;
		index_inc(&rxcp->rxq_idx, rxq->len);
A
Ajit Khaparde 已提交
1234
		page_info->page = NULL;
S
Sathya Perla 已提交
1235
	}
1236
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
1237 1238
}

1239
/* Process the RX completion indicated by rxcp when GRO is disabled */
S
Sathya Perla 已提交
1240 1241
static void be_rx_compl_process(struct be_rx_obj *rxo,
				struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1242
{
S
Sathya Perla 已提交
1243
	struct be_adapter *adapter = rxo->adapter;
1244
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
1245
	struct sk_buff *skb;
1246

1247
	skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
1248
	if (unlikely(!skb)) {
1249
		rx_stats(rxo)->rx_drops_no_skbs++;
S
Sathya Perla 已提交
1250
		be_rx_compl_discard(rxo, rxcp);
S
Sathya Perla 已提交
1251 1252 1253
		return;
	}

S
Sathya Perla 已提交
1254
	skb_fill_rx_data(rxo, skb, rxcp);
S
Sathya Perla 已提交
1255

1256
	if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1257
		skb->ip_summed = CHECKSUM_UNNECESSARY;
S
Somnath Kotur 已提交
1258 1259
	else
		skb_checksum_none_assert(skb);
S
Sathya Perla 已提交
1260

1261
	skb->protocol = eth_type_trans(skb, netdev);
S
Sathya Perla 已提交
1262
	if (netdev->features & NETIF_F_RXHASH)
A
Ajit Khaparde 已提交
1263 1264
		skb->rxhash = rxcp->rss_hash;

S
Sathya Perla 已提交
1265

1266
	if (rxcp->vlanf)
A
Ajit Khaparde 已提交
1267 1268 1269
		__vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);

	netif_receive_skb(skb);
S
Sathya Perla 已提交
1270 1271
}

1272
/* Process the RX completion indicated by rxcp when GRO is enabled */
S
Sathya Perla 已提交
1273 1274
void be_rx_compl_process_gro(struct be_rx_obj *rxo, struct napi_struct *napi,
			     struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1275
{
S
Sathya Perla 已提交
1276
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
1277
	struct be_rx_page_info *page_info;
1278
	struct sk_buff *skb = NULL;
1279
	struct be_queue_info *rxq = &rxo->q;
1280 1281
	u16 remaining, curr_frag_len;
	u16 i, j;
1282

S
Sathya Perla 已提交
1283
	skb = napi_get_frags(napi);
1284
	if (!skb) {
S
Sathya Perla 已提交
1285
		be_rx_compl_discard(rxo, rxcp);
1286 1287 1288
		return;
	}

1289 1290
	remaining = rxcp->pkt_size;
	for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
S
Sathya Perla 已提交
1291
		page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
S
Sathya Perla 已提交
1292 1293 1294

		curr_frag_len = min(remaining, rx_frag_size);

1295 1296 1297 1298
		/* Coalesce all frags from the same physical page in one slot */
		if (i == 0 || page_info->page_offset == 0) {
			/* First frag or Fresh page */
			j++;
1299
			skb_frag_set_page(skb, j, page_info->page);
1300 1301
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
1302
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1303 1304 1305
		} else {
			put_page(page_info->page);
		}
E
Eric Dumazet 已提交
1306
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
E
Eric Dumazet 已提交
1307
		skb->truesize += rx_frag_size;
1308
		remaining -= curr_frag_len;
1309
		index_inc(&rxcp->rxq_idx, rxq->len);
S
Sathya Perla 已提交
1310 1311
		memset(page_info, 0, sizeof(*page_info));
	}
1312
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
1313

1314
	skb_shinfo(skb)->nr_frags = j + 1;
1315 1316
	skb->len = rxcp->pkt_size;
	skb->data_len = rxcp->pkt_size;
1317
	skb->ip_summed = CHECKSUM_UNNECESSARY;
A
Ajit Khaparde 已提交
1318 1319
	if (adapter->netdev->features & NETIF_F_RXHASH)
		skb->rxhash = rxcp->rss_hash;
1320

1321
	if (rxcp->vlanf)
A
Ajit Khaparde 已提交
1322 1323
		__vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);

S
Sathya Perla 已提交
1324
	napi_gro_frags(napi);
1325 1326
}

S
Sathya Perla 已提交
1327 1328
static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
				 struct be_rx_compl_info *rxcp)
1329 1330 1331 1332 1333 1334
{
	rxcp->pkt_size =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, pktsize, compl);
	rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtp, compl);
	rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, err, compl);
	rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, tcpf, compl);
1335
	rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
	rxcp->ip_csum =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ipcksm, compl);
	rxcp->l4_csum =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, l4_cksm, compl);
	rxcp->ipv6 =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ip_version, compl);
	rxcp->rxq_idx =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, fragndx, compl);
	rxcp->num_rcvd =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
	rxcp->pkt_type =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
A
Ajit Khaparde 已提交
1348 1349
	rxcp->rss_hash =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, rxcp);
1350 1351
	if (rxcp->vlanf) {
		rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1352 1353 1354
					  compl);
		rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
					       compl);
1355
	}
1356
	rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, port, compl);
1357 1358
}

S
Sathya Perla 已提交
1359 1360
static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
				 struct be_rx_compl_info *rxcp)
1361 1362 1363 1364 1365 1366
{
	rxcp->pkt_size =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, pktsize, compl);
	rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtp, compl);
	rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, err, compl);
	rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, tcpf, compl);
1367
	rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
	rxcp->ip_csum =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ipcksm, compl);
	rxcp->l4_csum =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, l4_cksm, compl);
	rxcp->ipv6 =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ip_version, compl);
	rxcp->rxq_idx =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, fragndx, compl);
	rxcp->num_rcvd =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
	rxcp->pkt_type =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
A
Ajit Khaparde 已提交
1380 1381
	rxcp->rss_hash =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, rxcp);
1382 1383
	if (rxcp->vlanf) {
		rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1384 1385 1386
					  compl);
		rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
					       compl);
1387
	}
1388
	rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, port, compl);
1389 1390 1391 1392 1393 1394 1395
}

static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
{
	struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
	struct be_rx_compl_info *rxcp = &rxo->rxcp;
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
1396

1397 1398 1399 1400
	/* For checking the valid bit it is Ok to use either definition as the
	 * valid bit is at the same position in both v0 and v1 Rx compl */
	if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
		return NULL;
S
Sathya Perla 已提交
1401

1402 1403
	rmb();
	be_dws_le_to_cpu(compl, sizeof(*compl));
S
Sathya Perla 已提交
1404

1405
	if (adapter->be3_native)
S
Sathya Perla 已提交
1406
		be_parse_rx_compl_v1(compl, rxcp);
1407
	else
S
Sathya Perla 已提交
1408
		be_parse_rx_compl_v0(compl, rxcp);
S
Sathya Perla 已提交
1409

1410 1411 1412
	if (rxcp->vlanf) {
		/* vlanf could be wrongly set in some cards.
		 * ignore if vtm is not set */
1413
		if ((adapter->function_mode & FLEX10_MODE) && !rxcp->vtm)
1414
			rxcp->vlanf = 0;
S
Sathya Perla 已提交
1415

1416
		if (!lancer_chip(adapter))
1417
			rxcp->vlan_tag = swab16(rxcp->vlan_tag);
S
Sathya Perla 已提交
1418

1419
		if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
1420
		    !adapter->vlan_tag[rxcp->vlan_tag])
1421 1422
			rxcp->vlanf = 0;
	}
1423 1424 1425

	/* As the compl has been parsed, reset it; we wont touch it again */
	compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
S
Sathya Perla 已提交
1426

1427
	queue_tail_inc(&rxo->cq);
S
Sathya Perla 已提交
1428 1429 1430
	return rxcp;
}

1431
static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
S
Sathya Perla 已提交
1432 1433
{
	u32 order = get_order(size);
1434

S
Sathya Perla 已提交
1435
	if (order > 0)
1436 1437
		gfp |= __GFP_COMP;
	return  alloc_pages(gfp, order);
S
Sathya Perla 已提交
1438 1439 1440 1441 1442 1443
}

/*
 * Allocate a page, split it to fragments of size rx_frag_size and post as
 * receive buffers to BE
 */
1444
static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
S
Sathya Perla 已提交
1445
{
1446
	struct be_adapter *adapter = rxo->adapter;
1447
	struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1448
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1449 1450 1451 1452 1453
	struct page *pagep = NULL;
	struct be_eth_rx_d *rxd;
	u64 page_dmaaddr = 0, frag_dmaaddr;
	u32 posted, page_offset = 0;

1454
	page_info = &rxo->page_info_tbl[rxq->head];
S
Sathya Perla 已提交
1455 1456
	for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
		if (!pagep) {
1457
			pagep = be_alloc_pages(adapter->big_page_size, gfp);
S
Sathya Perla 已提交
1458
			if (unlikely(!pagep)) {
1459
				rx_stats(rxo)->rx_post_fail++;
S
Sathya Perla 已提交
1460 1461
				break;
			}
I
Ivan Vecera 已提交
1462 1463 1464
			page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
						    0, adapter->big_page_size,
						    DMA_FROM_DEVICE);
S
Sathya Perla 已提交
1465 1466 1467 1468 1469 1470 1471
			page_info->page_offset = 0;
		} else {
			get_page(pagep);
			page_info->page_offset = page_offset + rx_frag_size;
		}
		page_offset = page_info->page_offset;
		page_info->page = pagep;
1472
		dma_unmap_addr_set(page_info, bus, page_dmaaddr);
S
Sathya Perla 已提交
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
		frag_dmaaddr = page_dmaaddr + page_info->page_offset;

		rxd = queue_head_node(rxq);
		rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
		rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));

		/* Any space left in the current big page for another frag? */
		if ((page_offset + rx_frag_size + rx_frag_size) >
					adapter->big_page_size) {
			pagep = NULL;
			page_info->last_page_user = true;
		}
1485 1486 1487

		prev_page_info = page_info;
		queue_head_inc(rxq);
S
Sathya Perla 已提交
1488
		page_info = &rxo->page_info_tbl[rxq->head];
S
Sathya Perla 已提交
1489 1490
	}
	if (pagep)
1491
		prev_page_info->last_page_user = true;
S
Sathya Perla 已提交
1492 1493 1494

	if (posted) {
		atomic_add(posted, &rxq->used);
1495
		be_rxq_notify(adapter, rxq->id, posted);
1496 1497
	} else if (atomic_read(&rxq->used) == 0) {
		/* Let be_worker replenish when memory is available */
1498
		rxo->rx_post_starved = true;
S
Sathya Perla 已提交
1499 1500 1501
	}
}

1502
static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
S
Sathya Perla 已提交
1503 1504 1505 1506 1507 1508
{
	struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);

	if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
		return NULL;

1509
	rmb();
S
Sathya Perla 已提交
1510 1511 1512 1513 1514 1515 1516 1517
	be_dws_le_to_cpu(txcp, sizeof(*txcp));

	txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;

	queue_tail_inc(tx_cq);
	return txcp;
}

1518 1519
static u16 be_tx_compl_process(struct be_adapter *adapter,
		struct be_tx_obj *txo, u16 last_index)
S
Sathya Perla 已提交
1520
{
1521
	struct be_queue_info *txq = &txo->q;
1522
	struct be_eth_wrb *wrb;
1523
	struct sk_buff **sent_skbs = txo->sent_skb_list;
S
Sathya Perla 已提交
1524
	struct sk_buff *sent_skb;
1525 1526
	u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
	bool unmap_skb_hdr = true;
S
Sathya Perla 已提交
1527

1528
	sent_skb = sent_skbs[txq->tail];
S
Sathya Perla 已提交
1529
	BUG_ON(!sent_skb);
1530 1531 1532
	sent_skbs[txq->tail] = NULL;

	/* skip header wrb */
1533
	queue_tail_inc(txq);
S
Sathya Perla 已提交
1534

1535
	do {
S
Sathya Perla 已提交
1536
		cur_index = txq->tail;
1537
		wrb = queue_tail_node(txq);
I
Ivan Vecera 已提交
1538 1539
		unmap_tx_frag(&adapter->pdev->dev, wrb,
			      (unmap_skb_hdr && skb_headlen(sent_skb)));
1540 1541
		unmap_skb_hdr = false;

S
Sathya Perla 已提交
1542 1543
		num_wrbs++;
		queue_tail_inc(txq);
1544
	} while (cur_index != last_index);
S
Sathya Perla 已提交
1545 1546

	kfree_skb(sent_skb);
1547
	return num_wrbs;
S
Sathya Perla 已提交
1548 1549
}

S
Sathya Perla 已提交
1550 1551
/* Return the number of events in the event queue */
static inline int events_get(struct be_eq_obj *eqo)
1552
{
S
Sathya Perla 已提交
1553 1554
	struct be_eq_entry *eqe;
	int num = 0;
1555

S
Sathya Perla 已提交
1556 1557 1558 1559
	do {
		eqe = queue_tail_node(&eqo->q);
		if (eqe->evt == 0)
			break;
1560

S
Sathya Perla 已提交
1561 1562 1563 1564 1565 1566 1567
		rmb();
		eqe->evt = 0;
		num++;
		queue_tail_inc(&eqo->q);
	} while (true);

	return num;
1568 1569
}

S
Sathya Perla 已提交
1570
static int event_handle(struct be_eq_obj *eqo)
1571
{
S
Sathya Perla 已提交
1572 1573
	bool rearm = false;
	int num = events_get(eqo);
1574

S
Sathya Perla 已提交
1575
	/* Deal with any spurious interrupts that come without events */
1576 1577 1578
	if (!num)
		rearm = true;

1579 1580 1581
	if (num || msix_enabled(eqo->adapter))
		be_eq_notify(eqo->adapter, eqo->q.id, rearm, true, num);

1582
	if (num)
S
Sathya Perla 已提交
1583
		napi_schedule(&eqo->napi);
1584 1585 1586 1587

	return num;
}

S
Sathya Perla 已提交
1588 1589
/* Leaves the EQ is disarmed state */
static void be_eq_clean(struct be_eq_obj *eqo)
1590
{
S
Sathya Perla 已提交
1591
	int num = events_get(eqo);
1592

S
Sathya Perla 已提交
1593
	be_eq_notify(eqo->adapter, eqo->q.id, false, true, num);
1594 1595
}

S
Sathya Perla 已提交
1596
static void be_rx_cq_clean(struct be_rx_obj *rxo)
S
Sathya Perla 已提交
1597 1598
{
	struct be_rx_page_info *page_info;
1599 1600
	struct be_queue_info *rxq = &rxo->q;
	struct be_queue_info *rx_cq = &rxo->cq;
1601
	struct be_rx_compl_info *rxcp;
S
Sathya Perla 已提交
1602 1603 1604
	u16 tail;

	/* First cleanup pending rx completions */
1605
	while ((rxcp = be_rx_compl_get(rxo)) != NULL) {
S
Sathya Perla 已提交
1606 1607
		be_rx_compl_discard(rxo, rxcp);
		be_cq_notify(rxo->adapter, rx_cq->id, false, 1);
S
Sathya Perla 已提交
1608 1609 1610 1611
	}

	/* Then free posted rx buffer that were not used */
	tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1612
	for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
S
Sathya Perla 已提交
1613
		page_info = get_rx_page_info(rxo, tail);
S
Sathya Perla 已提交
1614 1615 1616 1617
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
	}
	BUG_ON(atomic_read(&rxq->used));
1618
	rxq->tail = rxq->head = 0;
S
Sathya Perla 已提交
1619 1620
}

S
Sathya Perla 已提交
1621
static void be_tx_compl_clean(struct be_adapter *adapter)
S
Sathya Perla 已提交
1622
{
S
Sathya Perla 已提交
1623 1624
	struct be_tx_obj *txo;
	struct be_queue_info *txq;
1625
	struct be_eth_tx_compl *txcp;
1626
	u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
1627 1628
	struct sk_buff *sent_skb;
	bool dummy_wrb;
S
Sathya Perla 已提交
1629
	int i, pending_txqs;
1630 1631 1632

	/* Wait for a max of 200ms for all the tx-completions to arrive. */
	do {
S
Sathya Perla 已提交
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
		pending_txqs = adapter->num_tx_qs;

		for_all_tx_queues(adapter, txo, i) {
			txq = &txo->q;
			while ((txcp = be_tx_compl_get(&txo->cq))) {
				end_idx =
					AMAP_GET_BITS(struct amap_eth_tx_compl,
						      wrb_index, txcp);
				num_wrbs += be_tx_compl_process(adapter, txo,
								end_idx);
				cmpl++;
			}
			if (cmpl) {
				be_cq_notify(adapter, txo->cq.id, false, cmpl);
				atomic_sub(num_wrbs, &txq->used);
				cmpl = 0;
				num_wrbs = 0;
			}
			if (atomic_read(&txq->used) == 0)
				pending_txqs--;
1653 1654
		}

S
Sathya Perla 已提交
1655
		if (pending_txqs == 0 || ++timeo > 200)
1656 1657 1658 1659 1660
			break;

		mdelay(1);
	} while (true);

S
Sathya Perla 已提交
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
	for_all_tx_queues(adapter, txo, i) {
		txq = &txo->q;
		if (atomic_read(&txq->used))
			dev_err(&adapter->pdev->dev, "%d pending tx-compls\n",
				atomic_read(&txq->used));

		/* free posted tx for which compls will never arrive */
		while (atomic_read(&txq->used)) {
			sent_skb = txo->sent_skb_list[txq->tail];
			end_idx = txq->tail;
			num_wrbs = wrb_cnt_for_skb(adapter, sent_skb,
						   &dummy_wrb);
			index_adv(&end_idx, num_wrbs - 1, txq->len);
			num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
			atomic_sub(num_wrbs, &txq->used);
		}
1677
	}
S
Sathya Perla 已提交
1678 1679
}

S
Sathya Perla 已提交
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
static void be_evt_queues_destroy(struct be_adapter *adapter)
{
	struct be_eq_obj *eqo;
	int i;

	for_all_evt_queues(adapter, eqo, i) {
		be_eq_clean(eqo);
		if (eqo->q.created)
			be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
		be_queue_free(adapter, &eqo->q);
	}
}

static int be_evt_queues_create(struct be_adapter *adapter)
{
	struct be_queue_info *eq;
	struct be_eq_obj *eqo;
	int i, rc;

	adapter->num_evt_qs = num_irqs(adapter);

	for_all_evt_queues(adapter, eqo, i) {
		eqo->adapter = adapter;
		eqo->tx_budget = BE_TX_BUDGET;
		eqo->idx = i;
		eqo->max_eqd = BE_MAX_EQD;
		eqo->enable_aic = true;

		eq = &eqo->q;
		rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
					sizeof(struct be_eq_entry));
		if (rc)
			return rc;

		rc = be_cmd_eq_create(adapter, eq, eqo->cur_eqd);
		if (rc)
			return rc;
	}
1718
	return 0;
S
Sathya Perla 已提交
1719 1720
}

1721 1722 1723 1724
static void be_mcc_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;

1725
	q = &adapter->mcc_obj.q;
1726
	if (q->created)
1727
		be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1728 1729
	be_queue_free(adapter, q);

1730
	q = &adapter->mcc_obj.cq;
1731
	if (q->created)
1732
		be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1733 1734 1735 1736 1737 1738 1739 1740
	be_queue_free(adapter, q);
}

/* Must be called only after TX qs are created as MCC shares TX EQ */
static int be_mcc_queues_create(struct be_adapter *adapter)
{
	struct be_queue_info *q, *cq;

1741
	cq = &adapter->mcc_obj.cq;
1742
	if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1743
			sizeof(struct be_mcc_compl)))
1744 1745
		goto err;

S
Sathya Perla 已提交
1746 1747
	/* Use the default EQ for MCC completions */
	if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
1748 1749
		goto mcc_cq_free;

1750
	q = &adapter->mcc_obj.q;
1751 1752 1753
	if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
		goto mcc_cq_destroy;

1754
	if (be_cmd_mccq_create(adapter, q, cq))
1755 1756 1757 1758 1759 1760 1761
		goto mcc_q_free;

	return 0;

mcc_q_free:
	be_queue_free(adapter, q);
mcc_cq_destroy:
1762
	be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1763 1764 1765 1766 1767 1768
mcc_cq_free:
	be_queue_free(adapter, cq);
err:
	return -1;
}

S
Sathya Perla 已提交
1769 1770 1771
static void be_tx_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;
1772 1773
	struct be_tx_obj *txo;
	u8 i;
S
Sathya Perla 已提交
1774

1775 1776 1777 1778 1779
	for_all_tx_queues(adapter, txo, i) {
		q = &txo->q;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
		be_queue_free(adapter, q);
S
Sathya Perla 已提交
1780

1781 1782 1783 1784 1785
		q = &txo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);
	}
S
Sathya Perla 已提交
1786 1787
}

1788 1789
static int be_num_txqs_want(struct be_adapter *adapter)
{
1790
	if (sriov_enabled(adapter) || be_is_mc(adapter) ||
1791 1792 1793 1794 1795 1796 1797
		lancer_chip(adapter) || !be_physfn(adapter) ||
		adapter->generation == BE_GEN2)
		return 1;
	else
		return MAX_TX_QS;
}

S
Sathya Perla 已提交
1798
static int be_tx_cqs_create(struct be_adapter *adapter)
S
Sathya Perla 已提交
1799
{
S
Sathya Perla 已提交
1800 1801
	struct be_queue_info *cq, *eq;
	int status;
1802 1803
	struct be_tx_obj *txo;
	u8 i;
S
Sathya Perla 已提交
1804

1805
	adapter->num_tx_qs = be_num_txqs_want(adapter);
1806 1807
	if (adapter->num_tx_qs != MAX_TX_QS) {
		rtnl_lock();
1808 1809
		netif_set_real_num_tx_queues(adapter->netdev,
			adapter->num_tx_qs);
1810 1811
		rtnl_unlock();
	}
1812

S
Sathya Perla 已提交
1813 1814 1815 1816 1817 1818
	for_all_tx_queues(adapter, txo, i) {
		cq = &txo->cq;
		status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
					sizeof(struct be_eth_tx_compl));
		if (status)
			return status;
1819

S
Sathya Perla 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
		/* If num_evt_qs is less than num_tx_qs, then more than
		 * one txq share an eq
		 */
		eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
		status = be_cmd_cq_create(adapter, cq, eq, false, 3);
		if (status)
			return status;
	}
	return 0;
}
S
Sathya Perla 已提交
1830

S
Sathya Perla 已提交
1831 1832 1833 1834
static int be_tx_qs_create(struct be_adapter *adapter)
{
	struct be_tx_obj *txo;
	int i, status;
1835

1836
	for_all_tx_queues(adapter, txo, i) {
S
Sathya Perla 已提交
1837 1838 1839 1840
		status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
					sizeof(struct be_eth_wrb));
		if (status)
			return status;
S
Sathya Perla 已提交
1841

S
Sathya Perla 已提交
1842 1843 1844
		status = be_cmd_txq_create(adapter, &txo->q, &txo->cq);
		if (status)
			return status;
1845
	}
S
Sathya Perla 已提交
1846

S
Sathya Perla 已提交
1847
	return 0;
S
Sathya Perla 已提交
1848 1849
}

S
Sathya Perla 已提交
1850
static void be_rx_cqs_destroy(struct be_adapter *adapter)
S
Sathya Perla 已提交
1851 1852
{
	struct be_queue_info *q;
1853 1854 1855 1856 1857 1858 1859 1860
	struct be_rx_obj *rxo;
	int i;

	for_all_rx_queues(adapter, rxo, i) {
		q = &rxo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);
1861 1862 1863
	}
}

S
Sathya Perla 已提交
1864
static int be_rx_cqs_create(struct be_adapter *adapter)
S
Sathya Perla 已提交
1865
{
S
Sathya Perla 已提交
1866
	struct be_queue_info *eq, *cq;
1867 1868
	struct be_rx_obj *rxo;
	int rc, i;
S
Sathya Perla 已提交
1869

S
Sathya Perla 已提交
1870 1871 1872 1873 1874
	/* We'll create as many RSS rings as there are irqs.
	 * But when there's only one irq there's no use creating RSS rings
	 */
	adapter->num_rx_qs = (num_irqs(adapter) > 1) ?
				num_irqs(adapter) + 1 : 1;
1875

S
Sathya Perla 已提交
1876
	adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1877 1878 1879 1880 1881 1882
	for_all_rx_queues(adapter, rxo, i) {
		rxo->adapter = adapter;
		cq = &rxo->cq;
		rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
				sizeof(struct be_eth_rx_compl));
		if (rc)
S
Sathya Perla 已提交
1883
			return rc;
1884

S
Sathya Perla 已提交
1885 1886
		eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
		rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
1887
		if (rc)
S
Sathya Perla 已提交
1888
			return rc;
1889
	}
S
Sathya Perla 已提交
1890

S
Sathya Perla 已提交
1891 1892 1893
	if (adapter->num_rx_qs != MAX_RX_QS)
		dev_info(&adapter->pdev->dev,
			"Created only %d receive queues", adapter->num_rx_qs);
S
Sathya Perla 已提交
1894

S
Sathya Perla 已提交
1895
	return 0;
1896 1897
}

S
Sathya Perla 已提交
1898 1899 1900
static irqreturn_t be_intx(int irq, void *dev)
{
	struct be_adapter *adapter = dev;
S
Sathya Perla 已提交
1901
	int num_evts;
S
Sathya Perla 已提交
1902

S
Sathya Perla 已提交
1903 1904 1905 1906 1907 1908
	/* With INTx only one EQ is used */
	num_evts = event_handle(&adapter->eq_obj[0]);
	if (num_evts)
		return IRQ_HANDLED;
	else
		return IRQ_NONE;
S
Sathya Perla 已提交
1909 1910
}

S
Sathya Perla 已提交
1911
static irqreturn_t be_msix(int irq, void *dev)
S
Sathya Perla 已提交
1912
{
S
Sathya Perla 已提交
1913
	struct be_eq_obj *eqo = dev;
S
Sathya Perla 已提交
1914

S
Sathya Perla 已提交
1915
	event_handle(eqo);
S
Sathya Perla 已提交
1916 1917 1918
	return IRQ_HANDLED;
}

1919
static inline bool do_gro(struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1920
{
1921
	return (rxcp->tcpf && !rxcp->err) ? true : false;
S
Sathya Perla 已提交
1922 1923
}

S
Sathya Perla 已提交
1924 1925
static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
			int budget)
S
Sathya Perla 已提交
1926
{
1927 1928
	struct be_adapter *adapter = rxo->adapter;
	struct be_queue_info *rx_cq = &rxo->cq;
1929
	struct be_rx_compl_info *rxcp;
S
Sathya Perla 已提交
1930 1931 1932
	u32 work_done;

	for (work_done = 0; work_done < budget; work_done++) {
1933
		rxcp = be_rx_compl_get(rxo);
S
Sathya Perla 已提交
1934 1935 1936
		if (!rxcp)
			break;

1937 1938 1939 1940 1941 1942
		/* Is it a flush compl that has no data */
		if (unlikely(rxcp->num_rcvd == 0))
			goto loop_continue;

		/* Discard compl with partial DMA Lancer B0 */
		if (unlikely(!rxcp->pkt_size)) {
S
Sathya Perla 已提交
1943
			be_rx_compl_discard(rxo, rxcp);
1944 1945 1946 1947 1948 1949 1950 1951
			goto loop_continue;
		}

		/* On BE drop pkts that arrive due to imperfect filtering in
		 * promiscuous mode on some skews
		 */
		if (unlikely(rxcp->port != adapter->port_num &&
				!lancer_chip(adapter))) {
S
Sathya Perla 已提交
1952
			be_rx_compl_discard(rxo, rxcp);
1953
			goto loop_continue;
1954
		}
1955

1956
		if (do_gro(rxcp))
S
Sathya Perla 已提交
1957
			be_rx_compl_process_gro(rxo, napi, rxcp);
1958
		else
S
Sathya Perla 已提交
1959
			be_rx_compl_process(rxo, rxcp);
1960
loop_continue:
1961
		be_rx_stats_update(rxo, rxcp);
S
Sathya Perla 已提交
1962 1963
	}

S
Sathya Perla 已提交
1964 1965
	if (work_done) {
		be_cq_notify(adapter, rx_cq->id, true, work_done);
1966

S
Sathya Perla 已提交
1967 1968
		if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
			be_post_rx_frags(rxo, GFP_ATOMIC);
S
Sathya Perla 已提交
1969
	}
S
Sathya Perla 已提交
1970

S
Sathya Perla 已提交
1971 1972 1973
	return work_done;
}

S
Sathya Perla 已提交
1974 1975
static bool be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
			  int budget, int idx)
S
Sathya Perla 已提交
1976 1977
{
	struct be_eth_tx_compl *txcp;
S
Sathya Perla 已提交
1978
	int num_wrbs = 0, work_done;
1979

S
Sathya Perla 已提交
1980 1981 1982 1983 1984
	for (work_done = 0; work_done < budget; work_done++) {
		txcp = be_tx_compl_get(&txo->cq);
		if (!txcp)
			break;
		num_wrbs += be_tx_compl_process(adapter, txo,
1985 1986
				AMAP_GET_BITS(struct amap_eth_tx_compl,
					wrb_index, txcp));
S
Sathya Perla 已提交
1987
	}
S
Sathya Perla 已提交
1988

S
Sathya Perla 已提交
1989 1990 1991
	if (work_done) {
		be_cq_notify(adapter, txo->cq.id, true, work_done);
		atomic_sub(num_wrbs, &txo->q.used);
1992

S
Sathya Perla 已提交
1993 1994 1995 1996 1997
		/* As Tx wrbs have been freed up, wake up netdev queue
		 * if it was stopped due to lack of tx wrbs.  */
		if (__netif_subqueue_stopped(adapter->netdev, idx) &&
			atomic_read(&txo->q.used) < txo->q.len / 2) {
			netif_wake_subqueue(adapter->netdev, idx);
1998
		}
S
Sathya Perla 已提交
1999 2000 2001 2002

		u64_stats_update_begin(&tx_stats(txo)->sync_compl);
		tx_stats(txo)->tx_compl += work_done;
		u64_stats_update_end(&tx_stats(txo)->sync_compl);
S
Sathya Perla 已提交
2003
	}
S
Sathya Perla 已提交
2004 2005
	return (work_done < budget); /* Done */
}
S
Sathya Perla 已提交
2006

S
Sathya Perla 已提交
2007 2008 2009 2010 2011 2012
int be_poll(struct napi_struct *napi, int budget)
{
	struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
	struct be_adapter *adapter = eqo->adapter;
	int max_work = 0, work, i;
	bool tx_done;
S
Sathya Perla 已提交
2013

S
Sathya Perla 已提交
2014 2015 2016 2017 2018 2019
	/* Process all TXQs serviced by this EQ */
	for (i = eqo->idx; i < adapter->num_tx_qs; i += adapter->num_evt_qs) {
		tx_done = be_process_tx(adapter, &adapter->tx_obj[i],
					eqo->tx_budget, i);
		if (!tx_done)
			max_work = budget;
S
Sathya Perla 已提交
2020 2021
	}

S
Sathya Perla 已提交
2022 2023 2024 2025 2026 2027 2028 2029
	/* This loop will iterate twice for EQ0 in which
	 * completions of the last RXQ (default one) are also processed
	 * For other EQs the loop iterates only once
	 */
	for (i = eqo->idx; i < adapter->num_rx_qs; i += adapter->num_evt_qs) {
		work = be_process_rx(&adapter->rx_obj[i], napi, budget);
		max_work = max(work, max_work);
	}
S
Sathya Perla 已提交
2030

S
Sathya Perla 已提交
2031 2032
	if (is_mcc_eqo(eqo))
		be_process_mcc(adapter);
2033

S
Sathya Perla 已提交
2034 2035 2036 2037 2038 2039
	if (max_work < budget) {
		napi_complete(napi);
		be_eq_notify(adapter, eqo->q.id, true, false, 0);
	} else {
		/* As we'll continue in polling mode, count and clear events */
		be_eq_notify(adapter, eqo->q.id, false, false, events_get(eqo));
2040
	}
S
Sathya Perla 已提交
2041
	return max_work;
S
Sathya Perla 已提交
2042 2043
}

2044
void be_detect_dump_ue(struct be_adapter *adapter)
2045
{
2046 2047
	u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
	u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
2048 2049
	u32 i;

2050 2051 2052
	if (adapter->eeh_err || adapter->ue_detected)
		return;

2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
	if (lancer_chip(adapter)) {
		sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
		if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
			sliport_err1 = ioread32(adapter->db +
					SLIPORT_ERROR1_OFFSET);
			sliport_err2 = ioread32(adapter->db +
					SLIPORT_ERROR2_OFFSET);
		}
	} else {
		pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_LOW, &ue_lo);
		pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_HIGH, &ue_hi);
		pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_LOW_MASK, &ue_lo_mask);
		pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_HI_MASK, &ue_hi_mask);

		ue_lo = (ue_lo & (~ue_lo_mask));
		ue_hi = (ue_hi & (~ue_hi_mask));
	}
2074

2075 2076
	if (ue_lo || ue_hi ||
		sliport_status & SLIPORT_STATUS_ERR_MASK) {
2077
		adapter->ue_detected = true;
2078
		adapter->eeh_err = true;
2079 2080
		dev_err(&adapter->pdev->dev,
			"Unrecoverable error in the card\n");
2081 2082
	}

2083 2084 2085
	if (ue_lo) {
		for (i = 0; ue_lo; ue_lo >>= 1, i++) {
			if (ue_lo & 1)
2086 2087 2088 2089
				dev_err(&adapter->pdev->dev,
				"UE: %s bit set\n", ue_status_low_desc[i]);
		}
	}
2090 2091 2092
	if (ue_hi) {
		for (i = 0; ue_hi; ue_hi >>= 1, i++) {
			if (ue_hi & 1)
2093 2094 2095 2096 2097
				dev_err(&adapter->pdev->dev,
				"UE: %s bit set\n", ue_status_hi_desc[i]);
		}
	}

2098 2099 2100 2101 2102 2103 2104 2105
	if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
		dev_err(&adapter->pdev->dev,
			"sliport status 0x%x\n", sliport_status);
		dev_err(&adapter->pdev->dev,
			"sliport error1 0x%x\n", sliport_err1);
		dev_err(&adapter->pdev->dev,
			"sliport error2 0x%x\n", sliport_err2);
	}
2106 2107
}

2108 2109
static void be_msix_disable(struct be_adapter *adapter)
{
2110
	if (msix_enabled(adapter)) {
2111
		pci_disable_msix(adapter->pdev);
2112
		adapter->num_msix_vec = 0;
2113 2114 2115
	}
}

S
Sathya Perla 已提交
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
static uint be_num_rss_want(struct be_adapter *adapter)
{
	if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
	     adapter->num_vfs == 0 && be_physfn(adapter) &&
	     !be_is_mc(adapter))
		return (adapter->be3_native) ? BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
	else
		return 0;
}

S
Sathya Perla 已提交
2126 2127
static void be_msix_enable(struct be_adapter *adapter)
{
S
Sathya Perla 已提交
2128
#define BE_MIN_MSIX_VECTORS		1
2129
	int i, status, num_vec;
S
Sathya Perla 已提交
2130

S
Sathya Perla 已提交
2131 2132 2133
	/* If RSS queues are not used, need a vec for default RX Q */
	num_vec = min(be_num_rss_want(adapter), num_online_cpus());
	num_vec = max(num_vec, BE_MIN_MSIX_VECTORS);
2134

2135
	for (i = 0; i < num_vec; i++)
S
Sathya Perla 已提交
2136 2137
		adapter->msix_entries[i].entry = i;

2138
	status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
2139 2140 2141
	if (status == 0) {
		goto done;
	} else if (status >= BE_MIN_MSIX_VECTORS) {
2142
		num_vec = status;
2143
		if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
2144
				num_vec) == 0)
2145 2146 2147 2148
			goto done;
	}
	return;
done:
2149 2150
	adapter->num_msix_vec = num_vec;
	return;
S
Sathya Perla 已提交
2151 2152
}

2153
static int be_sriov_enable(struct be_adapter *adapter)
2154
{
2155
	be_check_sriov_fn_type(adapter);
2156

2157
#ifdef CONFIG_PCI_IOV
2158
	if (be_physfn(adapter) && num_vfs) {
2159
		int status, pos;
2160
		u16 dev_vfs;
2161 2162 2163 2164

		pos = pci_find_ext_capability(adapter->pdev,
						PCI_EXT_CAP_ID_SRIOV);
		pci_read_config_word(adapter->pdev,
2165
				     pos + PCI_SRIOV_TOTAL_VF, &dev_vfs);
2166

2167 2168
		adapter->num_vfs = min_t(u16, num_vfs, dev_vfs);
		if (adapter->num_vfs != num_vfs)
2169
			dev_info(&adapter->pdev->dev,
2170 2171
				 "Device supports %d VFs and not %d\n",
				 adapter->num_vfs, num_vfs);
2172

2173 2174 2175
		status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
		if (status)
			adapter->num_vfs = 0;
2176

2177
		if (adapter->num_vfs) {
2178 2179 2180 2181 2182 2183
			adapter->vf_cfg = kcalloc(num_vfs,
						sizeof(struct be_vf_cfg),
						GFP_KERNEL);
			if (!adapter->vf_cfg)
				return -ENOMEM;
		}
2184 2185
	}
#endif
2186
	return 0;
2187 2188 2189 2190 2191
}

static void be_sriov_disable(struct be_adapter *adapter)
{
#ifdef CONFIG_PCI_IOV
2192
	if (sriov_enabled(adapter)) {
2193
		pci_disable_sriov(adapter->pdev);
2194
		kfree(adapter->vf_cfg);
2195
		adapter->num_vfs = 0;
2196 2197 2198 2199
	}
#endif
}

2200
static inline int be_msix_vec_get(struct be_adapter *adapter,
S
Sathya Perla 已提交
2201
				struct be_eq_obj *eqo)
2202
{
S
Sathya Perla 已提交
2203
	return adapter->msix_entries[eqo->idx].vector;
2204
}
S
Sathya Perla 已提交
2205

2206 2207
static int be_msix_register(struct be_adapter *adapter)
{
S
Sathya Perla 已提交
2208 2209 2210
	struct net_device *netdev = adapter->netdev;
	struct be_eq_obj *eqo;
	int status, i, vec;
S
Sathya Perla 已提交
2211

S
Sathya Perla 已提交
2212 2213 2214 2215
	for_all_evt_queues(adapter, eqo, i) {
		sprintf(eqo->desc, "%s-q%d", netdev->name, i);
		vec = be_msix_vec_get(adapter, eqo);
		status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
2216 2217 2218
		if (status)
			goto err_msix;
	}
2219

S
Sathya Perla 已提交
2220
	return 0;
2221
err_msix:
S
Sathya Perla 已提交
2222 2223 2224 2225
	for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
		free_irq(be_msix_vec_get(adapter, eqo), eqo);
	dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
		status);
2226
	be_msix_disable(adapter);
S
Sathya Perla 已提交
2227 2228 2229 2230 2231 2232 2233 2234
	return status;
}

static int be_irq_register(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	int status;

2235
	if (msix_enabled(adapter)) {
S
Sathya Perla 已提交
2236 2237 2238
		status = be_msix_register(adapter);
		if (status == 0)
			goto done;
2239 2240 2241
		/* INTx is not supported for VF */
		if (!be_physfn(adapter))
			return status;
S
Sathya Perla 已提交
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
	}

	/* INTx */
	netdev->irq = adapter->pdev->irq;
	status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
			adapter);
	if (status) {
		dev_err(&adapter->pdev->dev,
			"INTx request IRQ failed - err %d\n", status);
		return status;
	}
done:
	adapter->isr_registered = true;
	return 0;
}

static void be_irq_unregister(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
2261
	struct be_eq_obj *eqo;
2262
	int i;
S
Sathya Perla 已提交
2263 2264 2265 2266 2267

	if (!adapter->isr_registered)
		return;

	/* INTx */
2268
	if (!msix_enabled(adapter)) {
S
Sathya Perla 已提交
2269 2270 2271 2272 2273
		free_irq(netdev->irq, adapter);
		goto done;
	}

	/* MSIx */
S
Sathya Perla 已提交
2274 2275
	for_all_evt_queues(adapter, eqo, i)
		free_irq(be_msix_vec_get(adapter, eqo), eqo);
2276

S
Sathya Perla 已提交
2277 2278 2279 2280
done:
	adapter->isr_registered = false;
}

S
Sathya Perla 已提交
2281
static void be_rx_qs_destroy(struct be_adapter *adapter)
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
{
	struct be_queue_info *q;
	struct be_rx_obj *rxo;
	int i;

	for_all_rx_queues(adapter, rxo, i) {
		q = &rxo->q;
		if (q->created) {
			be_cmd_rxq_destroy(adapter, q);
			/* After the rxq is invalidated, wait for a grace time
			 * of 1ms for all dma to end and the flush compl to
			 * arrive
			 */
			mdelay(1);
S
Sathya Perla 已提交
2296
			be_rx_cq_clean(rxo);
2297
		}
S
Sathya Perla 已提交
2298
		be_queue_free(adapter, q);
2299 2300 2301
	}
}

2302 2303 2304
static int be_close(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
2305 2306
	struct be_eq_obj *eqo;
	int i;
2307 2308 2309

	be_async_mcc_disable(adapter);

2310 2311
	if (!lancer_chip(adapter))
		be_intr_set(adapter, false);
2312

S
Sathya Perla 已提交
2313 2314 2315 2316 2317 2318 2319
	for_all_evt_queues(adapter, eqo, i) {
		napi_disable(&eqo->napi);
		if (msix_enabled(adapter))
			synchronize_irq(be_msix_vec_get(adapter, eqo));
		else
			synchronize_irq(netdev->irq);
		be_eq_clean(eqo);
2320 2321
	}

2322 2323 2324 2325 2326
	be_irq_unregister(adapter);

	/* Wait for all pending tx completions to arrive so that
	 * all tx skbs are freed.
	 */
S
Sathya Perla 已提交
2327
	be_tx_compl_clean(adapter);
2328

S
Sathya Perla 已提交
2329
	be_rx_qs_destroy(adapter);
2330 2331 2332
	return 0;
}

S
Sathya Perla 已提交
2333
static int be_rx_qs_create(struct be_adapter *adapter)
2334 2335
{
	struct be_rx_obj *rxo;
2336 2337
	int rc, i, j;
	u8 rsstable[128];
2338 2339

	for_all_rx_queues(adapter, rxo, i) {
S
Sathya Perla 已提交
2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353
		rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
				    sizeof(struct be_eth_rx_d));
		if (rc)
			return rc;
	}

	/* The FW would like the default RXQ to be created first */
	rxo = default_rxo(adapter);
	rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, rx_frag_size,
			       adapter->if_handle, false, &rxo->rss_id);
	if (rc)
		return rc;

	for_all_rss_queues(adapter, rxo, i) {
2354
		rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
S
Sathya Perla 已提交
2355 2356
				       rx_frag_size, adapter->if_handle,
				       true, &rxo->rss_id);
2357 2358 2359 2360 2361
		if (rc)
			return rc;
	}

	if (be_multi_rxq(adapter)) {
2362 2363 2364 2365 2366 2367 2368 2369
		for (j = 0; j < 128; j += adapter->num_rx_qs - 1) {
			for_all_rss_queues(adapter, rxo, i) {
				if ((j + i) >= 128)
					break;
				rsstable[j + i] = rxo->rss_id;
			}
		}
		rc = be_cmd_rss_config(adapter, rsstable, 128);
2370 2371 2372 2373 2374
		if (rc)
			return rc;
	}

	/* First time posting */
S
Sathya Perla 已提交
2375
	for_all_rx_queues(adapter, rxo, i)
2376
		be_post_rx_frags(rxo, GFP_KERNEL);
2377 2378 2379
	return 0;
}

S
Sathya Perla 已提交
2380 2381 2382
static int be_open(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
2383
	struct be_eq_obj *eqo;
2384
	struct be_rx_obj *rxo;
S
Sathya Perla 已提交
2385
	struct be_tx_obj *txo;
2386
	u8 link_status;
2387
	int status, i;
2388

S
Sathya Perla 已提交
2389
	status = be_rx_qs_create(adapter);
2390 2391 2392
	if (status)
		goto err;

2393 2394
	be_irq_register(adapter);

2395 2396
	if (!lancer_chip(adapter))
		be_intr_set(adapter, true);
2397

S
Sathya Perla 已提交
2398
	for_all_rx_queues(adapter, rxo, i)
2399
		be_cq_notify(adapter, rxo->cq.id, true, 0);
2400

S
Sathya Perla 已提交
2401 2402 2403
	for_all_tx_queues(adapter, txo, i)
		be_cq_notify(adapter, txo->cq.id, true, 0);

2404 2405
	be_async_mcc_enable(adapter);

S
Sathya Perla 已提交
2406 2407 2408 2409 2410
	for_all_evt_queues(adapter, eqo, i) {
		napi_enable(&eqo->napi);
		be_eq_notify(adapter, eqo->q.id, true, false, 0);
	}

2411 2412 2413 2414 2415
	status = be_cmd_link_status_query(adapter, NULL, NULL,
					  &link_status, 0);
	if (!status)
		be_link_status_update(adapter, link_status);

2416 2417 2418 2419
	return 0;
err:
	be_close(adapter->netdev);
	return -EIO;
2420 2421
}

2422 2423 2424 2425 2426 2427 2428 2429 2430
static int be_setup_wol(struct be_adapter *adapter, bool enable)
{
	struct be_dma_mem cmd;
	int status = 0;
	u8 mac[ETH_ALEN];

	memset(mac, 0, ETH_ALEN);

	cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
I
Ivan Vecera 已提交
2431 2432
	cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
				    GFP_KERNEL);
2433 2434 2435 2436 2437 2438 2439 2440 2441
	if (cmd.va == NULL)
		return -1;
	memset(cmd.va, 0, cmd.size);

	if (enable) {
		status = pci_write_config_dword(adapter->pdev,
			PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
		if (status) {
			dev_err(&adapter->pdev->dev,
2442
				"Could not enable Wake-on-lan\n");
I
Ivan Vecera 已提交
2443 2444
			dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
					  cmd.dma);
2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456
			return status;
		}
		status = be_cmd_enable_magic_wol(adapter,
				adapter->netdev->dev_addr, &cmd);
		pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
		pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
	} else {
		status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
		pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
		pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
	}

I
Ivan Vecera 已提交
2457
	dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2458 2459 2460
	return status;
}

2461 2462 2463 2464 2465 2466 2467 2468
/*
 * Generate a seed MAC address from the PF MAC Address using jhash.
 * MAC Address for VFs are assigned incrementally starting from the seed.
 * These addresses are programmed in the ASIC by the PF and the VF driver
 * queries for the MAC address during its probe.
 */
static inline int be_vf_eth_addr_config(struct be_adapter *adapter)
{
2469
	u32 vf;
2470
	int status = 0;
2471
	u8 mac[ETH_ALEN];
2472
	struct be_vf_cfg *vf_cfg;
2473 2474 2475

	be_vf_eth_addr_generate(adapter, mac);

2476
	for_all_vfs(adapter, vf_cfg, vf) {
2477 2478 2479 2480
		if (lancer_chip(adapter)) {
			status = be_cmd_set_mac_list(adapter,  mac, 1, vf + 1);
		} else {
			status = be_cmd_pmac_add(adapter, mac,
2481 2482
						 vf_cfg->if_handle,
						 &vf_cfg->pmac_id, vf + 1);
2483 2484
		}

2485 2486
		if (status)
			dev_err(&adapter->pdev->dev,
2487
			"Mac address assignment failed for VF %d\n", vf);
2488
		else
2489
			memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
2490 2491 2492 2493 2494 2495

		mac[5] += 1;
	}
	return status;
}

2496
static void be_vf_clear(struct be_adapter *adapter)
2497
{
2498
	struct be_vf_cfg *vf_cfg;
2499 2500
	u32 vf;

2501
	for_all_vfs(adapter, vf_cfg, vf) {
2502 2503 2504
		if (lancer_chip(adapter))
			be_cmd_set_mac_list(adapter, NULL, 0, vf + 1);
		else
2505 2506
			be_cmd_pmac_del(adapter, vf_cfg->if_handle,
					vf_cfg->pmac_id, vf + 1);
2507

2508 2509
		be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
	}
2510 2511
}

2512 2513
static int be_clear(struct be_adapter *adapter)
{
2514 2515
	int i = 1;

2516 2517 2518 2519 2520
	if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
		cancel_delayed_work_sync(&adapter->work);
		adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
	}

2521
	if (sriov_enabled(adapter))
2522 2523
		be_vf_clear(adapter);

2524 2525 2526 2527
	for (; adapter->uc_macs > 0; adapter->uc_macs--, i++)
		be_cmd_pmac_del(adapter, adapter->if_handle,
			adapter->pmac_id[i], 0);

2528
	be_cmd_if_destroy(adapter, adapter->if_handle,  0);
2529 2530

	be_mcc_queues_destroy(adapter);
S
Sathya Perla 已提交
2531
	be_rx_cqs_destroy(adapter);
2532
	be_tx_queues_destroy(adapter);
S
Sathya Perla 已提交
2533
	be_evt_queues_destroy(adapter);
2534 2535 2536

	/* tell fw we're done with firing cmds */
	be_cmd_fw_clean(adapter);
S
Sathya Perla 已提交
2537 2538

	be_msix_disable(adapter);
2539
	kfree(adapter->pmac_id);
2540 2541 2542
	return 0;
}

2543 2544
static void be_vf_setup_init(struct be_adapter *adapter)
{
2545
	struct be_vf_cfg *vf_cfg;
2546 2547
	int vf;

2548 2549 2550
	for_all_vfs(adapter, vf_cfg, vf) {
		vf_cfg->if_handle = -1;
		vf_cfg->pmac_id = -1;
2551 2552 2553
	}
}

2554 2555
static int be_vf_setup(struct be_adapter *adapter)
{
2556
	struct be_vf_cfg *vf_cfg;
2557
	u32 cap_flags, en_flags, vf;
2558
	u16 def_vlan, lnk_speed;
2559 2560
	int status;

2561 2562
	be_vf_setup_init(adapter);

2563 2564
	cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
				BE_IF_FLAGS_MULTICAST;
2565
	for_all_vfs(adapter, vf_cfg, vf) {
2566
		status = be_cmd_if_create(adapter, cap_flags, en_flags, NULL,
2567
					  &vf_cfg->if_handle, NULL, vf + 1);
2568 2569 2570 2571
		if (status)
			goto err;
	}

2572 2573 2574
	status = be_vf_eth_addr_config(adapter);
	if (status)
		goto err;
2575

2576
	for_all_vfs(adapter, vf_cfg, vf) {
2577
		status = be_cmd_link_status_query(adapter, NULL, &lnk_speed,
2578
						  NULL, vf + 1);
2579 2580
		if (status)
			goto err;
2581
		vf_cfg->tx_rate = lnk_speed * 10;
2582 2583 2584 2585 2586 2587

		status = be_cmd_get_hsw_config(adapter, &def_vlan,
				vf + 1, vf_cfg->if_handle);
		if (status)
			goto err;
		vf_cfg->def_vid = def_vlan;
2588 2589 2590 2591 2592 2593
	}
	return 0;
err:
	return status;
}

2594 2595 2596
static void be_setup_init(struct be_adapter *adapter)
{
	adapter->vlan_prio_bmap = 0xff;
A
Ajit Khaparde 已提交
2597
	adapter->phy.link_speed = -1;
2598 2599 2600 2601
	adapter->if_handle = -1;
	adapter->be3_native = false;
	adapter->promiscuous = false;
	adapter->eq_next_idx = 0;
A
Ajit Khaparde 已提交
2602
	adapter->phy.forced_port_speed = -1;
2603 2604
}

2605
static int be_add_mac_from_list(struct be_adapter *adapter, u8 *mac)
2606 2607
{
	u32 pmac_id;
2608 2609 2610 2611 2612
	int status;
	bool pmac_id_active;

	status = be_cmd_get_mac_from_list(adapter, 0, &pmac_id_active,
							&pmac_id, mac);
2613 2614
	if (status != 0)
		goto do_none;
2615 2616 2617 2618 2619 2620 2621

	if (pmac_id_active) {
		status = be_cmd_mac_addr_query(adapter, mac,
				MAC_ADDRESS_TYPE_NETWORK,
				false, adapter->if_handle, pmac_id);

		if (!status)
2622
			adapter->pmac_id[0] = pmac_id;
2623 2624
	} else {
		status = be_cmd_pmac_add(adapter, mac,
2625
				adapter->if_handle, &adapter->pmac_id[0], 0);
2626
	}
2627 2628 2629 2630
do_none:
	return status;
}

2631 2632 2633
static int be_setup(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
2634
	u32 cap_flags, en_flags;
2635
	u32 tx_fc, rx_fc;
S
Sathya Perla 已提交
2636
	int status;
2637 2638
	u8 mac[ETH_ALEN];

2639
	be_setup_init(adapter);
S
Sathya Perla 已提交
2640

2641
	be_cmd_req_native_mode(adapter);
2642

S
Sathya Perla 已提交
2643 2644 2645 2646
	be_msix_enable(adapter);

	status = be_evt_queues_create(adapter);
	if (status)
2647
		goto err;
S
Sathya Perla 已提交
2648

S
Sathya Perla 已提交
2649 2650 2651 2652 2653 2654
	status = be_tx_cqs_create(adapter);
	if (status)
		goto err;

	status = be_rx_cqs_create(adapter);
	if (status)
2655
		goto err;
S
Sathya Perla 已提交
2656

2657
	status = be_mcc_queues_create(adapter);
S
Sathya Perla 已提交
2658
	if (status)
2659
		goto err;
S
Sathya Perla 已提交
2660

2661 2662
	memset(mac, 0, ETH_ALEN);
	status = be_cmd_mac_addr_query(adapter, mac, MAC_ADDRESS_TYPE_NETWORK,
2663
			true /*permanent */, 0, 0);
2664 2665 2666 2667
	if (status)
		return status;
	memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
	memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2668

2669 2670 2671
	en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
			BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
	cap_flags = en_flags | BE_IF_FLAGS_MCAST_PROMISCUOUS |
2672 2673
			BE_IF_FLAGS_VLAN_PROMISCUOUS | BE_IF_FLAGS_PROMISCUOUS;

2674 2675 2676 2677 2678 2679
	if (adapter->function_caps & BE_FUNCTION_CAPS_RSS) {
		cap_flags |= BE_IF_FLAGS_RSS;
		en_flags |= BE_IF_FLAGS_RSS;
	}
	status = be_cmd_if_create(adapter, cap_flags, en_flags,
			netdev->dev_addr, &adapter->if_handle,
2680
			&adapter->pmac_id[0], 0);
2681
	if (status != 0)
2682
		goto err;
S
Sathya Perla 已提交
2683

2684 2685 2686 2687 2688 2689
	 /* The VF's permanent mac queried from card is incorrect.
	  * For BEx: Query the mac configued by the PF using if_handle
	  * For Lancer: Get and use mac_list to obtain mac address.
	  */
	if (!be_physfn(adapter)) {
		if (lancer_chip(adapter))
2690
			status = be_add_mac_from_list(adapter, mac);
2691 2692 2693 2694
		else
			status = be_cmd_mac_addr_query(adapter, mac,
					MAC_ADDRESS_TYPE_NETWORK, false,
					adapter->if_handle, 0);
2695 2696 2697 2698 2699
		if (!status) {
			memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
			memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
		}
	}
2700

S
Sathya Perla 已提交
2701 2702 2703 2704
	status = be_tx_qs_create(adapter);
	if (status)
		goto err;

2705
	be_cmd_get_fw_ver(adapter, adapter->fw_ver, NULL);
2706

2707 2708 2709
	status = be_vid_config(adapter, false, 0);
	if (status)
		goto err;
2710

2711
	be_set_rx_mode(adapter->netdev);
2712

2713
	status = be_cmd_get_flow_control(adapter, &tx_fc, &rx_fc);
2714 2715
	/* For Lancer: It is legal for this cmd to fail on VF */
	if (status && (be_physfn(adapter) || !lancer_chip(adapter)))
2716
		goto err;
2717

2718 2719 2720
	if (rx_fc != adapter->rx_fc || tx_fc != adapter->tx_fc) {
		status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
					adapter->rx_fc);
2721 2722
		/* For Lancer: It is legal for this cmd to fail on VF */
		if (status && (be_physfn(adapter) || !lancer_chip(adapter)))
2723 2724
			goto err;
	}
2725

2726
	pcie_set_readrq(adapter->pdev, 4096);
2727

2728
	if (sriov_enabled(adapter)) {
2729 2730 2731 2732 2733
		status = be_vf_setup(adapter);
		if (status)
			goto err;
	}

A
Ajit Khaparde 已提交
2734 2735 2736 2737
	be_cmd_get_phy_info(adapter);
	if (be_pause_supported(adapter))
		adapter->phy.fc_autoneg = 1;

2738 2739 2740
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
	adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;

2741
	return 0;
2742 2743 2744 2745
err:
	be_clear(adapter);
	return status;
}
S
Sathya Perla 已提交
2746

I
Ivan Vecera 已提交
2747 2748 2749 2750
#ifdef CONFIG_NET_POLL_CONTROLLER
static void be_netpoll(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
2751
	struct be_eq_obj *eqo;
I
Ivan Vecera 已提交
2752 2753
	int i;

S
Sathya Perla 已提交
2754 2755 2756 2757
	for_all_evt_queues(adapter, eqo, i)
		event_handle(eqo);

	return;
I
Ivan Vecera 已提交
2758 2759 2760
}
#endif

2761
#define FW_FILE_HDR_SIGN 	"ServerEngines Corp. "
2762
static bool be_flash_redboot(struct be_adapter *adapter,
2763 2764
			const u8 *p, u32 img_start, int image_size,
			int hdr_size)
2765 2766 2767 2768
{
	u32 crc_offset;
	u8 flashed_crc[4];
	int status;
2769 2770 2771

	crc_offset = hdr_size + img_start + image_size - 4;

2772
	p += crc_offset;
2773 2774

	status = be_cmd_get_flash_crc(adapter, flashed_crc,
2775
			(image_size - 4));
2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
	if (status) {
		dev_err(&adapter->pdev->dev,
		"could not get crc from flash, not flashing redboot\n");
		return false;
	}

	/*update redboot only if crc does not match*/
	if (!memcmp(flashed_crc, p, 4))
		return false;
	else
		return true;
}

2789 2790
static bool phy_flashing_required(struct be_adapter *adapter)
{
A
Ajit Khaparde 已提交
2791 2792
	return (adapter->phy.phy_type == TN_8022 &&
		adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
2793 2794
}

2795
static int be_flash_data(struct be_adapter *adapter,
2796
			const struct firmware *fw,
2797 2798
			struct be_dma_mem *flash_cmd, int num_of_images)

2799
{
2800 2801
	int status = 0, i, filehdr_size = 0;
	u32 total_bytes = 0, flash_op;
2802 2803 2804
	int num_bytes;
	const u8 *p = fw->data;
	struct be_cmd_write_flashrom *req = flash_cmd->va;
J
Joe Perches 已提交
2805
	const struct flash_comp *pflashcomp;
2806
	int num_comp;
2807

2808
	static const struct flash_comp gen3_flash_types[10] = {
2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823
		{ FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g3},
		{ FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT,
			FLASH_REDBOOT_IMAGE_MAX_SIZE_g3},
		{ FLASH_iSCSI_BIOS_START_g3, IMG_TYPE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3},
		{ FLASH_PXE_BIOS_START_g3, IMG_TYPE_PXE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3},
		{ FLASH_FCoE_BIOS_START_g3, IMG_TYPE_FCOE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3},
		{ FLASH_iSCSI_BACKUP_IMAGE_START_g3, IMG_TYPE_ISCSI_BACKUP,
			FLASH_IMAGE_MAX_SIZE_g3},
		{ FLASH_FCoE_PRIMARY_IMAGE_START_g3, IMG_TYPE_FCOE_FW_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g3},
		{ FLASH_FCoE_BACKUP_IMAGE_START_g3, IMG_TYPE_FCOE_FW_BACKUP,
2824 2825
			FLASH_IMAGE_MAX_SIZE_g3},
		{ FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2826 2827 2828
			FLASH_NCSI_IMAGE_MAX_SIZE_g3},
		{ FLASH_PHY_FW_START_g3, IMG_TYPE_PHY_FW,
			FLASH_PHY_FW_IMAGE_MAX_SIZE_g3}
2829
	};
J
Joe Perches 已提交
2830
	static const struct flash_comp gen2_flash_types[8] = {
2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851
		{ FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g2},
		{ FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT,
			FLASH_REDBOOT_IMAGE_MAX_SIZE_g2},
		{ FLASH_iSCSI_BIOS_START_g2, IMG_TYPE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2},
		{ FLASH_PXE_BIOS_START_g2, IMG_TYPE_PXE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2},
		{ FLASH_FCoE_BIOS_START_g2, IMG_TYPE_FCOE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2},
		{ FLASH_iSCSI_BACKUP_IMAGE_START_g2, IMG_TYPE_ISCSI_BACKUP,
			FLASH_IMAGE_MAX_SIZE_g2},
		{ FLASH_FCoE_PRIMARY_IMAGE_START_g2, IMG_TYPE_FCOE_FW_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g2},
		{ FLASH_FCoE_BACKUP_IMAGE_START_g2, IMG_TYPE_FCOE_FW_BACKUP,
			 FLASH_IMAGE_MAX_SIZE_g2}
	};

	if (adapter->generation == BE_GEN3) {
		pflashcomp = gen3_flash_types;
		filehdr_size = sizeof(struct flash_file_hdr_g3);
J
Joe Perches 已提交
2852
		num_comp = ARRAY_SIZE(gen3_flash_types);
2853 2854 2855
	} else {
		pflashcomp = gen2_flash_types;
		filehdr_size = sizeof(struct flash_file_hdr_g2);
J
Joe Perches 已提交
2856
		num_comp = ARRAY_SIZE(gen2_flash_types);
2857
	}
2858 2859 2860 2861
	for (i = 0; i < num_comp; i++) {
		if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) &&
				memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
			continue;
2862 2863 2864 2865
		if (pflashcomp[i].optype == IMG_TYPE_PHY_FW) {
			if (!phy_flashing_required(adapter))
				continue;
		}
2866 2867
		if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
			(!be_flash_redboot(adapter, fw->data,
2868 2869
			pflashcomp[i].offset, pflashcomp[i].size, filehdr_size +
			(num_of_images * sizeof(struct image_hdr)))))
2870 2871 2872 2873
			continue;
		p = fw->data;
		p += filehdr_size + pflashcomp[i].offset
			+ (num_of_images * sizeof(struct image_hdr));
2874 2875 2876
		if (p + pflashcomp[i].size > fw->data + fw->size)
			return -1;
		total_bytes = pflashcomp[i].size;
2877 2878 2879 2880 2881 2882
		while (total_bytes) {
			if (total_bytes > 32*1024)
				num_bytes = 32*1024;
			else
				num_bytes = total_bytes;
			total_bytes -= num_bytes;
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893
			if (!total_bytes) {
				if (pflashcomp[i].optype == IMG_TYPE_PHY_FW)
					flash_op = FLASHROM_OPER_PHY_FLASH;
				else
					flash_op = FLASHROM_OPER_FLASH;
			} else {
				if (pflashcomp[i].optype == IMG_TYPE_PHY_FW)
					flash_op = FLASHROM_OPER_PHY_SAVE;
				else
					flash_op = FLASHROM_OPER_SAVE;
			}
2894 2895 2896 2897 2898
			memcpy(req->params.data_buf, p, num_bytes);
			p += num_bytes;
			status = be_cmd_write_flashrom(adapter, flash_cmd,
				pflashcomp[i].optype, flash_op, num_bytes);
			if (status) {
2899 2900 2901 2902
				if ((status == ILLEGAL_IOCTL_REQ) &&
					(pflashcomp[i].optype ==
						IMG_TYPE_PHY_FW))
					break;
2903 2904 2905 2906
				dev_err(&adapter->pdev->dev,
					"cmd to write to flash rom failed.\n");
				return -1;
			}
2907 2908 2909 2910 2911
		}
	}
	return 0;
}

2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923
static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
{
	if (fhdr == NULL)
		return 0;
	if (fhdr->build[0] == '3')
		return BE_GEN3;
	else if (fhdr->build[0] == '2')
		return BE_GEN2;
	else
		return 0;
}

2924 2925
static int lancer_fw_download(struct be_adapter *adapter,
				const struct firmware *fw)
2926
{
2927 2928
#define LANCER_FW_DOWNLOAD_CHUNK      (32 * 1024)
#define LANCER_FW_DOWNLOAD_LOCATION   "/prg"
2929
	struct be_dma_mem flash_cmd;
2930 2931 2932 2933 2934 2935 2936 2937
	const u8 *data_ptr = NULL;
	u8 *dest_image_ptr = NULL;
	size_t image_size = 0;
	u32 chunk_size = 0;
	u32 data_written = 0;
	u32 offset = 0;
	int status = 0;
	u8 add_status = 0;
2938

2939
	if (!IS_ALIGNED(fw->size, sizeof(u32))) {
2940
		dev_err(&adapter->pdev->dev,
2941 2942 2943 2944
			"FW Image not properly aligned. "
			"Length must be 4 byte aligned.\n");
		status = -EINVAL;
		goto lancer_fw_exit;
2945 2946
	}

2947 2948 2949 2950 2951 2952 2953 2954 2955 2956
	flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
				+ LANCER_FW_DOWNLOAD_CHUNK;
	flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
						&flash_cmd.dma, GFP_KERNEL);
	if (!flash_cmd.va) {
		status = -ENOMEM;
		dev_err(&adapter->pdev->dev,
			"Memory allocation failure while flashing\n");
		goto lancer_fw_exit;
	}
2957

2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010
	dest_image_ptr = flash_cmd.va +
				sizeof(struct lancer_cmd_req_write_object);
	image_size = fw->size;
	data_ptr = fw->data;

	while (image_size) {
		chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);

		/* Copy the image chunk content. */
		memcpy(dest_image_ptr, data_ptr, chunk_size);

		status = lancer_cmd_write_object(adapter, &flash_cmd,
				chunk_size, offset, LANCER_FW_DOWNLOAD_LOCATION,
				&data_written, &add_status);

		if (status)
			break;

		offset += data_written;
		data_ptr += data_written;
		image_size -= data_written;
	}

	if (!status) {
		/* Commit the FW written */
		status = lancer_cmd_write_object(adapter, &flash_cmd,
					0, offset, LANCER_FW_DOWNLOAD_LOCATION,
					&data_written, &add_status);
	}

	dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
				flash_cmd.dma);
	if (status) {
		dev_err(&adapter->pdev->dev,
			"Firmware load error. "
			"Status code: 0x%x Additional Status: 0x%x\n",
			status, add_status);
		goto lancer_fw_exit;
	}

	dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
lancer_fw_exit:
	return status;
}

static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
{
	struct flash_file_hdr_g2 *fhdr;
	struct flash_file_hdr_g3 *fhdr3;
	struct image_hdr *img_hdr_ptr = NULL;
	struct be_dma_mem flash_cmd;
	const u8 *p;
	int status = 0, i = 0, num_imgs = 0;
3011 3012

	p = fw->data;
3013
	fhdr = (struct flash_file_hdr_g2 *) p;
3014 3015

	flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
I
Ivan Vecera 已提交
3016 3017
	flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
					  &flash_cmd.dma, GFP_KERNEL);
3018 3019 3020 3021
	if (!flash_cmd.va) {
		status = -ENOMEM;
		dev_err(&adapter->pdev->dev,
			"Memory allocation failure while flashing\n");
3022
		goto be_fw_exit;
3023 3024
	}

3025 3026 3027
	if ((adapter->generation == BE_GEN3) &&
			(get_ufigen_type(fhdr) == BE_GEN3)) {
		fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
3028 3029
		num_imgs = le32_to_cpu(fhdr3->num_imgs);
		for (i = 0; i < num_imgs; i++) {
3030 3031
			img_hdr_ptr = (struct image_hdr *) (fw->data +
					(sizeof(struct flash_file_hdr_g3) +
3032 3033 3034 3035
					 i * sizeof(struct image_hdr)));
			if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
				status = be_flash_data(adapter, fw, &flash_cmd,
							num_imgs);
3036 3037 3038 3039 3040 3041 3042 3043
		}
	} else if ((adapter->generation == BE_GEN2) &&
			(get_ufigen_type(fhdr) == BE_GEN2)) {
		status = be_flash_data(adapter, fw, &flash_cmd, 0);
	} else {
		dev_err(&adapter->pdev->dev,
			"UFI and Interface are not compatible for flashing\n");
		status = -1;
3044 3045
	}

I
Ivan Vecera 已提交
3046 3047
	dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
			  flash_cmd.dma);
3048 3049
	if (status) {
		dev_err(&adapter->pdev->dev, "Firmware load error\n");
3050
		goto be_fw_exit;
3051 3052
	}

3053
	dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
3054

3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080
be_fw_exit:
	return status;
}

int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
{
	const struct firmware *fw;
	int status;

	if (!netif_running(adapter->netdev)) {
		dev_err(&adapter->pdev->dev,
			"Firmware load not allowed (interface is down)\n");
		return -1;
	}

	status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
	if (status)
		goto fw_exit;

	dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);

	if (lancer_chip(adapter))
		status = lancer_fw_download(adapter, fw);
	else
		status = be_fw_download(adapter, fw);

3081 3082 3083 3084 3085
fw_exit:
	release_firmware(fw);
	return status;
}

3086
static const struct net_device_ops be_netdev_ops = {
S
Sathya Perla 已提交
3087 3088 3089
	.ndo_open		= be_open,
	.ndo_stop		= be_close,
	.ndo_start_xmit		= be_xmit,
3090
	.ndo_set_rx_mode	= be_set_rx_mode,
S
Sathya Perla 已提交
3091 3092
	.ndo_set_mac_address	= be_mac_addr_set,
	.ndo_change_mtu		= be_change_mtu,
3093
	.ndo_get_stats64	= be_get_stats64,
S
Sathya Perla 已提交
3094 3095 3096
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_vlan_rx_add_vid	= be_vlan_add_vid,
	.ndo_vlan_rx_kill_vid	= be_vlan_rem_vid,
3097
	.ndo_set_vf_mac		= be_set_vf_mac,
3098
	.ndo_set_vf_vlan	= be_set_vf_vlan,
3099
	.ndo_set_vf_tx_rate	= be_set_vf_tx_rate,
I
Ivan Vecera 已提交
3100 3101 3102 3103
	.ndo_get_vf_config	= be_get_vf_config,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= be_netpoll,
#endif
S
Sathya Perla 已提交
3104 3105 3106 3107 3108
};

static void be_netdev_init(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
3109
	struct be_eq_obj *eqo;
3110
	int i;
S
Sathya Perla 已提交
3111

3112
	netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3113 3114 3115 3116
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
		NETIF_F_HW_VLAN_TX;
	if (be_multi_rxq(adapter))
		netdev->hw_features |= NETIF_F_RXHASH;
3117 3118

	netdev->features |= netdev->hw_features |
3119
		NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
A
Ajit Khaparde 已提交
3120

3121
	netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3122
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
3123

3124 3125
	netdev->priv_flags |= IFF_UNICAST_FLT;

S
Sathya Perla 已提交
3126 3127
	netdev->flags |= IFF_MULTICAST;

3128 3129
	netif_set_gso_max_size(netdev, 65535);

S
Sathya Perla 已提交
3130
	netdev->netdev_ops = &be_netdev_ops;
S
Sathya Perla 已提交
3131 3132 3133

	SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);

S
Sathya Perla 已提交
3134 3135
	for_all_evt_queues(adapter, eqo, i)
		netif_napi_add(netdev, &eqo->napi, be_poll, BE_NAPI_WEIGHT);
S
Sathya Perla 已提交
3136 3137 3138 3139
}

static void be_unmap_pci_bars(struct be_adapter *adapter)
{
3140 3141 3142 3143
	if (adapter->csr)
		iounmap(adapter->csr);
	if (adapter->db)
		iounmap(adapter->db);
S
Sathya Perla 已提交
3144 3145 3146 3147 3148
}

static int be_map_pci_bars(struct be_adapter *adapter)
{
	u8 __iomem *addr;
3149
	int db_reg;
S
Sathya Perla 已提交
3150

3151 3152 3153 3154 3155 3156 3157 3158 3159
	if (lancer_chip(adapter)) {
		addr = ioremap_nocache(pci_resource_start(adapter->pdev, 0),
			pci_resource_len(adapter->pdev, 0));
		if (addr == NULL)
			return -ENOMEM;
		adapter->db = addr;
		return 0;
	}

3160 3161 3162 3163 3164 3165 3166
	if (be_physfn(adapter)) {
		addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
				pci_resource_len(adapter->pdev, 2));
		if (addr == NULL)
			return -ENOMEM;
		adapter->csr = addr;
	}
S
Sathya Perla 已提交
3167

3168 3169 3170 3171 3172 3173 3174 3175 3176 3177
	if (adapter->generation == BE_GEN2) {
		db_reg = 4;
	} else {
		if (be_physfn(adapter))
			db_reg = 4;
		else
			db_reg = 0;
	}
	addr = ioremap_nocache(pci_resource_start(adapter->pdev, db_reg),
				pci_resource_len(adapter->pdev, db_reg));
S
Sathya Perla 已提交
3178 3179
	if (addr == NULL)
		goto pci_map_err;
3180 3181
	adapter->db = addr;

S
Sathya Perla 已提交
3182 3183 3184 3185 3186 3187 3188 3189 3190
	return 0;
pci_map_err:
	be_unmap_pci_bars(adapter);
	return -ENOMEM;
}


static void be_ctrl_cleanup(struct be_adapter *adapter)
{
3191
	struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
S
Sathya Perla 已提交
3192 3193 3194 3195

	be_unmap_pci_bars(adapter);

	if (mem->va)
I
Ivan Vecera 已提交
3196 3197
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
3198

3199
	mem = &adapter->rx_filter;
3200
	if (mem->va)
I
Ivan Vecera 已提交
3201 3202
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
S
Sathya Perla 已提交
3203 3204 3205 3206
}

static int be_ctrl_init(struct be_adapter *adapter)
{
3207 3208
	struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
	struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
3209
	struct be_dma_mem *rx_filter = &adapter->rx_filter;
S
Sathya Perla 已提交
3210 3211 3212 3213
	int status;

	status = be_map_pci_bars(adapter);
	if (status)
3214
		goto done;
S
Sathya Perla 已提交
3215 3216

	mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
I
Ivan Vecera 已提交
3217 3218 3219 3220
	mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
						mbox_mem_alloc->size,
						&mbox_mem_alloc->dma,
						GFP_KERNEL);
S
Sathya Perla 已提交
3221
	if (!mbox_mem_alloc->va) {
3222 3223
		status = -ENOMEM;
		goto unmap_pci_bars;
S
Sathya Perla 已提交
3224 3225 3226 3227 3228
	}
	mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
	mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
	mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
	memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
3229

3230 3231 3232 3233
	rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
	rx_filter->va = dma_alloc_coherent(&adapter->pdev->dev, rx_filter->size,
					&rx_filter->dma, GFP_KERNEL);
	if (rx_filter->va == NULL) {
3234 3235 3236
		status = -ENOMEM;
		goto free_mbox;
	}
3237
	memset(rx_filter->va, 0, rx_filter->size);
3238

3239
	mutex_init(&adapter->mbox_lock);
3240 3241
	spin_lock_init(&adapter->mcc_lock);
	spin_lock_init(&adapter->mcc_cq_lock);
3242

3243
	init_completion(&adapter->flash_compl);
3244
	pci_save_state(adapter->pdev);
S
Sathya Perla 已提交
3245
	return 0;
3246 3247

free_mbox:
I
Ivan Vecera 已提交
3248 3249
	dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
			  mbox_mem_alloc->va, mbox_mem_alloc->dma);
3250 3251 3252 3253 3254 3255

unmap_pci_bars:
	be_unmap_pci_bars(adapter);

done:
	return status;
S
Sathya Perla 已提交
3256 3257 3258 3259
}

static void be_stats_cleanup(struct be_adapter *adapter)
{
3260
	struct be_dma_mem *cmd = &adapter->stats_cmd;
S
Sathya Perla 已提交
3261 3262

	if (cmd->va)
I
Ivan Vecera 已提交
3263 3264
		dma_free_coherent(&adapter->pdev->dev, cmd->size,
				  cmd->va, cmd->dma);
S
Sathya Perla 已提交
3265 3266 3267 3268
}

static int be_stats_init(struct be_adapter *adapter)
{
3269
	struct be_dma_mem *cmd = &adapter->stats_cmd;
S
Sathya Perla 已提交
3270

S
Selvin Xavier 已提交
3271
	if (adapter->generation == BE_GEN2) {
3272
		cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
S
Selvin Xavier 已提交
3273 3274 3275 3276 3277 3278
	} else {
		if (lancer_chip(adapter))
			cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
		else
			cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
	}
I
Ivan Vecera 已提交
3279 3280
	cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
				     GFP_KERNEL);
S
Sathya Perla 已提交
3281 3282
	if (cmd->va == NULL)
		return -1;
3283
	memset(cmd->va, 0, cmd->size);
S
Sathya Perla 已提交
3284 3285 3286 3287 3288 3289
	return 0;
}

static void __devexit be_remove(struct pci_dev *pdev)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
3290

S
Sathya Perla 已提交
3291 3292 3293 3294 3295
	if (!adapter)
		return;

	unregister_netdev(adapter->netdev);

3296 3297
	be_clear(adapter);

S
Sathya Perla 已提交
3298 3299 3300 3301
	be_stats_cleanup(adapter);

	be_ctrl_cleanup(adapter);

3302 3303
	be_sriov_disable(adapter);

S
Sathya Perla 已提交
3304 3305 3306 3307 3308 3309 3310
	pci_set_drvdata(pdev, NULL);
	pci_release_regions(pdev);
	pci_disable_device(pdev);

	free_netdev(adapter->netdev);
}

3311 3312 3313 3314 3315 3316
bool be_is_wol_supported(struct be_adapter *adapter)
{
	return ((adapter->wol_cap & BE_WOL_CAP) &&
		!be_is_wol_excluded(adapter)) ? true : false;
}

3317
static int be_get_config(struct be_adapter *adapter)
S
Sathya Perla 已提交
3318 3319 3320
{
	int status;

3321 3322
	status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
			&adapter->function_mode, &adapter->function_caps);
3323 3324 3325
	if (status)
		return status;

3326
	if (adapter->function_mode & FLEX10_MODE)
3327
		adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
3328 3329 3330
	else
		adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;

3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341
	if (be_physfn(adapter))
		adapter->max_pmac_cnt = BE_UC_PMAC_COUNT;
	else
		adapter->max_pmac_cnt = BE_VF_UC_PMAC_COUNT;

	/* primary mac needs 1 pmac entry */
	adapter->pmac_id = kcalloc(adapter->max_pmac_cnt + 1,
				  sizeof(u32), GFP_KERNEL);
	if (!adapter->pmac_id)
		return -ENOMEM;

3342 3343 3344 3345
	status = be_cmd_get_cntl_attributes(adapter);
	if (status)
		return status;

3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356
	status = be_cmd_get_acpi_wol_cap(adapter);
	if (status) {
		/* in case of a failure to get wol capabillities
		 * check the exclusion list to determine WOL capability */
		if (!be_is_wol_excluded(adapter))
			adapter->wol_cap |= BE_WOL_CAP;
	}

	if (be_is_wol_supported(adapter))
		adapter->wol = true;

3357
	return 0;
S
Sathya Perla 已提交
3358 3359
}

3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
static int be_dev_family_check(struct be_adapter *adapter)
{
	struct pci_dev *pdev = adapter->pdev;
	u32 sli_intf = 0, if_type;

	switch (pdev->device) {
	case BE_DEVICE_ID1:
	case OC_DEVICE_ID1:
		adapter->generation = BE_GEN2;
		break;
	case BE_DEVICE_ID2:
	case OC_DEVICE_ID2:
3372
	case OC_DEVICE_ID5:
3373 3374 3375
		adapter->generation = BE_GEN3;
		break;
	case OC_DEVICE_ID3:
3376
	case OC_DEVICE_ID4:
3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395
		pci_read_config_dword(pdev, SLI_INTF_REG_OFFSET, &sli_intf);
		if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
						SLI_INTF_IF_TYPE_SHIFT;

		if (((sli_intf & SLI_INTF_VALID_MASK) != SLI_INTF_VALID) ||
			if_type != 0x02) {
			dev_err(&pdev->dev, "SLI_INTF reg val is not valid\n");
			return -EINVAL;
		}
		adapter->sli_family = ((sli_intf & SLI_INTF_FAMILY_MASK) >>
					 SLI_INTF_FAMILY_SHIFT);
		adapter->generation = BE_GEN3;
		break;
	default:
		adapter->generation = 0;
	}
	return 0;
}

3396 3397
static int lancer_wait_ready(struct be_adapter *adapter)
{
3398
#define SLIPORT_READY_TIMEOUT 30
3399 3400 3401 3402 3403 3404 3405 3406
	u32 sliport_status;
	int status = 0, i;

	for (i = 0; i < SLIPORT_READY_TIMEOUT; i++) {
		sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
		if (sliport_status & SLIPORT_STATUS_RDY_MASK)
			break;

3407
		msleep(1000);
3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443
	}

	if (i == SLIPORT_READY_TIMEOUT)
		status = -1;

	return status;
}

static int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
{
	int status;
	u32 sliport_status, err, reset_needed;
	status = lancer_wait_ready(adapter);
	if (!status) {
		sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
		err = sliport_status & SLIPORT_STATUS_ERR_MASK;
		reset_needed = sliport_status & SLIPORT_STATUS_RN_MASK;
		if (err && reset_needed) {
			iowrite32(SLI_PORT_CONTROL_IP_MASK,
					adapter->db + SLIPORT_CONTROL_OFFSET);

			/* check adapter has corrected the error */
			status = lancer_wait_ready(adapter);
			sliport_status = ioread32(adapter->db +
							SLIPORT_STATUS_OFFSET);
			sliport_status &= (SLIPORT_STATUS_ERR_MASK |
						SLIPORT_STATUS_RN_MASK);
			if (status || sliport_status)
				status = -1;
		} else if (err || reset_needed) {
			status = -1;
		}
	}
	return status;
}

3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497
static void lancer_test_and_recover_fn_err(struct be_adapter *adapter)
{
	int status;
	u32 sliport_status;

	if (adapter->eeh_err || adapter->ue_detected)
		return;

	sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);

	if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
		dev_err(&adapter->pdev->dev,
				"Adapter in error state."
				"Trying to recover.\n");

		status = lancer_test_and_set_rdy_state(adapter);
		if (status)
			goto err;

		netif_device_detach(adapter->netdev);

		if (netif_running(adapter->netdev))
			be_close(adapter->netdev);

		be_clear(adapter);

		adapter->fw_timeout = false;

		status = be_setup(adapter);
		if (status)
			goto err;

		if (netif_running(adapter->netdev)) {
			status = be_open(adapter->netdev);
			if (status)
				goto err;
		}

		netif_device_attach(adapter->netdev);

		dev_err(&adapter->pdev->dev,
				"Adapter error recovery succeeded\n");
	}
	return;
err:
	dev_err(&adapter->pdev->dev,
			"Adapter error recovery failed\n");
}

static void be_worker(struct work_struct *work)
{
	struct be_adapter *adapter =
		container_of(work, struct be_adapter, work.work);
	struct be_rx_obj *rxo;
S
Sathya Perla 已提交
3498
	struct be_eq_obj *eqo;
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508
	int i;

	if (lancer_chip(adapter))
		lancer_test_and_recover_fn_err(adapter);

	be_detect_dump_ue(adapter);

	/* when interrupts are not yet enabled, just reap any pending
	* mcc completions */
	if (!netif_running(adapter->netdev)) {
S
Sathya Perla 已提交
3509
		be_process_mcc(adapter);
3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
		goto reschedule;
	}

	if (!adapter->stats_cmd_sent) {
		if (lancer_chip(adapter))
			lancer_cmd_get_pport_stats(adapter,
						&adapter->stats_cmd);
		else
			be_cmd_get_stats(adapter, &adapter->stats_cmd);
	}

	for_all_rx_queues(adapter, rxo, i) {
		if (rxo->rx_post_starved) {
			rxo->rx_post_starved = false;
			be_post_rx_frags(rxo, GFP_KERNEL);
		}
	}

S
Sathya Perla 已提交
3528 3529 3530
	for_all_evt_queues(adapter, eqo, i)
		be_eqd_update(adapter, eqo);

3531 3532 3533 3534 3535
reschedule:
	adapter->work_counter++;
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
}

S
Sathya Perla 已提交
3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551
static int __devinit be_probe(struct pci_dev *pdev,
			const struct pci_device_id *pdev_id)
{
	int status = 0;
	struct be_adapter *adapter;
	struct net_device *netdev;

	status = pci_enable_device(pdev);
	if (status)
		goto do_none;

	status = pci_request_regions(pdev, DRV_NAME);
	if (status)
		goto disable_dev;
	pci_set_master(pdev);

3552
	netdev = alloc_etherdev_mq(sizeof(struct be_adapter), MAX_TX_QS);
S
Sathya Perla 已提交
3553 3554 3555 3556 3557 3558 3559
	if (netdev == NULL) {
		status = -ENOMEM;
		goto rel_reg;
	}
	adapter = netdev_priv(netdev);
	adapter->pdev = pdev;
	pci_set_drvdata(pdev, adapter);
3560 3561

	status = be_dev_family_check(adapter);
3562
	if (status)
3563 3564
		goto free_netdev;

S
Sathya Perla 已提交
3565
	adapter->netdev = netdev;
3566
	SET_NETDEV_DEV(netdev, &pdev->dev);
S
Sathya Perla 已提交
3567

I
Ivan Vecera 已提交
3568
	status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
S
Sathya Perla 已提交
3569 3570 3571
	if (!status) {
		netdev->features |= NETIF_F_HIGHDMA;
	} else {
I
Ivan Vecera 已提交
3572
		status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
S
Sathya Perla 已提交
3573 3574 3575 3576 3577 3578
		if (status) {
			dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
			goto free_netdev;
		}
	}

3579 3580 3581
	status = be_sriov_enable(adapter);
	if (status)
		goto free_netdev;
3582

S
Sathya Perla 已提交
3583 3584
	status = be_ctrl_init(adapter);
	if (status)
3585
		goto disable_sriov;
S
Sathya Perla 已提交
3586

3587
	if (lancer_chip(adapter)) {
3588 3589 3590 3591 3592 3593
		status = lancer_wait_ready(adapter);
		if (!status) {
			iowrite32(SLI_PORT_CONTROL_IP_MASK,
					adapter->db + SLIPORT_CONTROL_OFFSET);
			status = lancer_test_and_set_rdy_state(adapter);
		}
3594 3595
		if (status) {
			dev_err(&pdev->dev, "Adapter in non recoverable error\n");
3596
			goto ctrl_clean;
3597 3598 3599
		}
	}

3600
	/* sync up with fw's ready state */
3601 3602 3603 3604 3605
	if (be_physfn(adapter)) {
		status = be_cmd_POST(adapter);
		if (status)
			goto ctrl_clean;
	}
S
Sathya Perla 已提交
3606

3607 3608
	/* tell fw we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
S
Sathya Perla 已提交
3609
	if (status)
3610 3611
		goto ctrl_clean;

3612 3613 3614
	status = be_cmd_reset_function(adapter);
	if (status)
		goto ctrl_clean;
3615

S
Sathya Perla 已提交
3616 3617 3618 3619 3620 3621
	/* The INTR bit may be set in the card when probed by a kdump kernel
	 * after a crash.
	 */
	if (!lancer_chip(adapter))
		be_intr_set(adapter, false);

3622 3623 3624 3625 3626
	status = be_stats_init(adapter);
	if (status)
		goto ctrl_clean;

	status = be_get_config(adapter);
S
Sathya Perla 已提交
3627 3628 3629 3630
	if (status)
		goto stats_clean;

	INIT_DELAYED_WORK(&adapter->work, be_worker);
3631
	adapter->rx_fc = adapter->tx_fc = true;
S
Sathya Perla 已提交
3632

3633 3634
	status = be_setup(adapter);
	if (status)
3635
		goto msix_disable;
3636

3637
	be_netdev_init(netdev);
S
Sathya Perla 已提交
3638 3639
	status = register_netdev(netdev);
	if (status != 0)
3640
		goto unsetup;
S
Sathya Perla 已提交
3641

S
Sathya Perla 已提交
3642 3643
	dev_info(&pdev->dev, "%s: %s port %d\n", netdev->name, nic_name(pdev),
		adapter->port_num);
3644

S
Sathya Perla 已提交
3645 3646
	return 0;

3647 3648
unsetup:
	be_clear(adapter);
3649 3650
msix_disable:
	be_msix_disable(adapter);
S
Sathya Perla 已提交
3651 3652 3653 3654
stats_clean:
	be_stats_cleanup(adapter);
ctrl_clean:
	be_ctrl_cleanup(adapter);
3655
disable_sriov:
3656
	be_sriov_disable(adapter);
3657
free_netdev:
3658
	free_netdev(netdev);
3659
	pci_set_drvdata(pdev, NULL);
S
Sathya Perla 已提交
3660 3661 3662 3663 3664
rel_reg:
	pci_release_regions(pdev);
disable_dev:
	pci_disable_device(pdev);
do_none:
3665
	dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
S
Sathya Perla 已提交
3666 3667 3668 3669 3670 3671 3672 3673
	return status;
}

static int be_suspend(struct pci_dev *pdev, pm_message_t state)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev =  adapter->netdev;

3674 3675 3676
	if (adapter->wol)
		be_setup_wol(adapter, true);

S
Sathya Perla 已提交
3677 3678 3679 3680 3681 3682
	netif_device_detach(netdev);
	if (netif_running(netdev)) {
		rtnl_lock();
		be_close(netdev);
		rtnl_unlock();
	}
3683
	be_clear(adapter);
S
Sathya Perla 已提交
3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705

	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	return 0;
}

static int be_resume(struct pci_dev *pdev)
{
	int status = 0;
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev =  adapter->netdev;

	netif_device_detach(netdev);

	status = pci_enable_device(pdev);
	if (status)
		return status;

	pci_set_power_state(pdev, 0);
	pci_restore_state(pdev);

3706 3707 3708 3709 3710
	/* tell fw we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
	if (status)
		return status;

3711
	be_setup(adapter);
S
Sathya Perla 已提交
3712 3713 3714 3715 3716 3717
	if (netif_running(netdev)) {
		rtnl_lock();
		be_open(netdev);
		rtnl_unlock();
	}
	netif_device_attach(netdev);
3718 3719 3720

	if (adapter->wol)
		be_setup_wol(adapter, false);
3721

S
Sathya Perla 已提交
3722 3723 3724
	return 0;
}

3725 3726 3727 3728 3729 3730 3731
/*
 * An FLR will stop BE from DMAing any data.
 */
static void be_shutdown(struct pci_dev *pdev)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);

3732 3733
	if (!adapter)
		return;
3734

3735
	cancel_delayed_work_sync(&adapter->work);
3736

3737
	netif_device_detach(adapter->netdev);
3738 3739 3740 3741

	if (adapter->wol)
		be_setup_wol(adapter, true);

3742 3743
	be_cmd_reset_function(adapter);

3744 3745 3746
	pci_disable_device(pdev);
}

3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780
static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
				pci_channel_state_t state)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev =  adapter->netdev;

	dev_err(&adapter->pdev->dev, "EEH error detected\n");

	adapter->eeh_err = true;

	netif_device_detach(netdev);

	if (netif_running(netdev)) {
		rtnl_lock();
		be_close(netdev);
		rtnl_unlock();
	}
	be_clear(adapter);

	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

	pci_disable_device(pdev);

	return PCI_ERS_RESULT_NEED_RESET;
}

static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	int status;

	dev_info(&adapter->pdev->dev, "EEH reset\n");
	adapter->eeh_err = false;
3781 3782
	adapter->ue_detected = false;
	adapter->fw_timeout = false;
3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835

	status = pci_enable_device(pdev);
	if (status)
		return PCI_ERS_RESULT_DISCONNECT;

	pci_set_master(pdev);
	pci_set_power_state(pdev, 0);
	pci_restore_state(pdev);

	/* Check if card is ok and fw is ready */
	status = be_cmd_POST(adapter);
	if (status)
		return PCI_ERS_RESULT_DISCONNECT;

	return PCI_ERS_RESULT_RECOVERED;
}

static void be_eeh_resume(struct pci_dev *pdev)
{
	int status = 0;
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev =  adapter->netdev;

	dev_info(&adapter->pdev->dev, "EEH resume\n");

	pci_save_state(pdev);

	/* tell fw we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
	if (status)
		goto err;

	status = be_setup(adapter);
	if (status)
		goto err;

	if (netif_running(netdev)) {
		status = be_open(netdev);
		if (status)
			goto err;
	}
	netif_device_attach(netdev);
	return;
err:
	dev_err(&adapter->pdev->dev, "EEH resume failed\n");
}

static struct pci_error_handlers be_eeh_handlers = {
	.error_detected = be_eeh_err_detected,
	.slot_reset = be_eeh_reset,
	.resume = be_eeh_resume,
};

S
Sathya Perla 已提交
3836 3837 3838 3839 3840 3841
static struct pci_driver be_driver = {
	.name = DRV_NAME,
	.id_table = be_dev_ids,
	.probe = be_probe,
	.remove = be_remove,
	.suspend = be_suspend,
3842
	.resume = be_resume,
3843
	.shutdown = be_shutdown,
3844
	.err_handler = &be_eeh_handlers
S
Sathya Perla 已提交
3845 3846 3847 3848
};

static int __init be_init_module(void)
{
3849 3850
	if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
	    rx_frag_size != 2048) {
S
Sathya Perla 已提交
3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865
		printk(KERN_WARNING DRV_NAME
			" : Module param rx_frag_size must be 2048/4096/8192."
			" Using 2048\n");
		rx_frag_size = 2048;
	}

	return pci_register_driver(&be_driver);
}
module_init(be_init_module);

static void __exit be_exit_module(void)
{
	pci_unregister_driver(&be_driver);
}
module_exit(be_exit_module);