be_main.c 92.0 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>
S
Sathya Perla 已提交
19
#include "be.h"
20
#include "be_cmds.h"
21
#include <asm/div64.h>
S
Sathya Perla 已提交
22 23 24 25 26 27 28

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

29
static ushort rx_frag_size = 2048;
30
static unsigned int num_vfs;
31
module_param(rx_frag_size, ushort, S_IRUGO);
32
module_param(num_vfs, uint, S_IRUGO);
S
Sathya Perla 已提交
33
MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
34
MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
S
Sathya Perla 已提交
35 36

static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
37
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
38
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
39 40
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
41
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
42
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
S
Sathya Perla 已提交
43 44 45
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, be_dev_ids);
46
/* UE Status Low CSR */
47
static const char * const ue_status_low_desc[] = {
48 49 50 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
	"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 */
82
static const char * const ue_status_hi_desc[] = {
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
	"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",
106
	"NETC",
107 108 109 110 111 112 113 114 115
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown",
	"Unknown"
};
S
Sathya Perla 已提交
116

117 118 119 120 121 122 123
/* 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 已提交
124 125 126 127
static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
{
	struct be_dma_mem *mem = &q->dma_mem;
	if (mem->va)
I
Ivan Vecera 已提交
128 129
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
S
Sathya Perla 已提交
130 131 132 133 134 135 136 137 138 139 140
}

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 已提交
141 142
	mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
				     GFP_KERNEL);
S
Sathya Perla 已提交
143 144 145 146 147 148
	if (!mem->va)
		return -1;
	memset(mem->va, 0, mem->size);
	return 0;
}

149
static void be_intr_set(struct be_adapter *adapter, bool enable)
S
Sathya Perla 已提交
150
{
151
	u32 reg, enabled;
152

153 154 155
	if (adapter->eeh_err)
		return;

156 157 158 159
	pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
				&reg);
	enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;

160
	if (!enabled && enable)
S
Sathya Perla 已提交
161
		reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
162
	else if (enabled && !enable)
S
Sathya Perla 已提交
163
		reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
164
	else
S
Sathya Perla 已提交
165
		return;
166

167 168
	pci_write_config_dword(adapter->pdev,
			PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
S
Sathya Perla 已提交
169 170
}

171
static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
S
Sathya Perla 已提交
172 173 174 175
{
	u32 val = 0;
	val |= qid & DB_RQ_RING_ID_MASK;
	val |= posted << DB_RQ_NUM_POSTED_SHIFT;
176 177

	wmb();
178
	iowrite32(val, adapter->db + DB_RQ_OFFSET);
S
Sathya Perla 已提交
179 180
}

181
static void be_txq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
S
Sathya Perla 已提交
182 183 184 185
{
	u32 val = 0;
	val |= qid & DB_TXULP_RING_ID_MASK;
	val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
186 187

	wmb();
188
	iowrite32(val, adapter->db + DB_TXULP1_OFFSET);
S
Sathya Perla 已提交
189 190
}

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

	if (adapter->eeh_err)
		return;

S
Sathya Perla 已提交
202 203 204 205 206 207
	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;
208
	iowrite32(val, adapter->db + DB_EQ_OFFSET);
S
Sathya Perla 已提交
209 210
}

211
void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
S
Sathya Perla 已提交
212 213 214
{
	u32 val = 0;
	val |= qid & DB_CQ_RING_ID_MASK;
215 216
	val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
			DB_CQ_RING_ID_EXT_MASK_SHIFT);
217 218 219 220

	if (adapter->eeh_err)
		return;

S
Sathya Perla 已提交
221 222 223
	if (arm)
		val |= 1 << DB_CQ_REARM_SHIFT;
	val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
224
	iowrite32(val, adapter->db + DB_CQ_OFFSET);
S
Sathya Perla 已提交
225 226 227 228 229 230 231
}

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;
232 233
	u8 current_mac[ETH_ALEN];
	u32 pmac_id = adapter->pmac_id;
S
Sathya Perla 已提交
234

235 236 237
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

238 239
	status = be_cmd_mac_addr_query(adapter, current_mac,
			MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
240
	if (status)
241
		goto err;
S
Sathya Perla 已提交
242

243 244
	if (memcmp(addr->sa_data, current_mac, ETH_ALEN)) {
		status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
245
				adapter->if_handle, &adapter->pmac_id, 0);
246 247
		if (status)
			goto err;
S
Sathya Perla 已提交
248

249 250 251 252 253 254
		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 已提交
255 256 257
	return status;
}

258 259
static void populate_be2_stats(struct be_adapter *adapter)
{
260 261 262
	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;
263
	struct be_port_rxf_stats_v0 *port_stats =
264 265
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
266

267
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
268 269 270 271 272 273 274 275 276 277 278 279 280 281
	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;
282
	drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
283 284
	drvs->rx_dropped_header_too_small =
		port_stats->rx_dropped_header_too_small;
285
	drvs->rx_address_match_errors = port_stats->rx_address_match_errors;
286 287 288 289 290 291 292
	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)
293
		drvs->jabber_events = rxf_stats->port1_jabber_events;
294
	else
295
		drvs->jabber_events = rxf_stats->port0_jabber_events;
296 297 298 299 300 301
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
302 303
	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;
304 305 306 307 308
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

static void populate_be3_stats(struct be_adapter *adapter)
{
309 310 311
	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;
312
	struct be_port_rxf_stats_v1 *port_stats =
313 314
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
315

316
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
	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;
334
	drvs->rx_address_match_errors = port_stats->rx_address_match_errors;
335 336
	drvs->rx_alignment_symbol_errors =
		port_stats->rx_alignment_symbol_errors;
337
	drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
338 339 340 341 342 343 344 345 346
	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_txpb = rxf_stats->rx_drops_no_txpb;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
347 348
	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;
349 350 351
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

S
Selvin Xavier 已提交
352 353
static void populate_lancer_stats(struct be_adapter *adapter)
{
354

S
Selvin Xavier 已提交
355
	struct be_drv_stats *drvs = &adapter->drv_stats;
356 357 358 359 360 361 362
	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 已提交
363
	drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
364
	drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
S
Selvin Xavier 已提交
365 366 367 368 369 370 371 372 373 374 375 376 377
	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;
	drvs->rx_address_match_errors = pport_stats->rx_address_match_errors;
378
	drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
S
Selvin Xavier 已提交
379
	drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
380 381
	drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
	drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
S
Selvin Xavier 已提交
382 383
	drvs->jabber_events = pport_stats->rx_jabbers;
	drvs->rx_drops_invalid_ring = pport_stats->rx_drops_invalid_queue;
384 385
	drvs->forwarded_packets = pport_stats->num_forwards_lo;
	drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
S
Selvin Xavier 已提交
386
	drvs->rx_drops_too_many_frags =
387
				pport_stats->rx_drops_too_many_frags_lo;
S
Selvin Xavier 已提交
388
}
389

390 391 392 393 394 395 396 397 398 399 400 401
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;
}

402 403
void be_parse_stats(struct be_adapter *adapter)
{
404 405 406 407
	struct be_erx_stats_v1 *erx = be_erx_stats_from_cmd(adapter);
	struct be_rx_obj *rxo;
	int i;

S
Selvin Xavier 已提交
408 409 410 411 412 413
	if (adapter->generation == BE_GEN3) {
		if (lancer_chip(adapter))
			populate_lancer_stats(adapter);
		 else
			populate_be3_stats(adapter);
	} else {
414
		populate_be2_stats(adapter);
S
Selvin Xavier 已提交
415
	}
416 417

	/* as erx_v1 is longer than v0, ok to use v1 defn for v0 access */
418 419 420 421 422 423 424
	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]);
	}
425 426
}

427 428
static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
					struct rtnl_link_stats64 *stats)
S
Sathya Perla 已提交
429
{
430
	struct be_adapter *adapter = netdev_priv(netdev);
431
	struct be_drv_stats *drvs = &adapter->drv_stats;
432
	struct be_rx_obj *rxo;
433
	struct be_tx_obj *txo;
434 435
	u64 pkts, bytes;
	unsigned int start;
436
	int i;
S
Sathya Perla 已提交
437

438
	for_all_rx_queues(adapter, rxo, i) {
439 440 441 442 443 444 445 446 447 448 449
		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;
450 451
	}

452
	for_all_tx_queues(adapter, txo, i) {
453 454 455 456 457 458 459 460
		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;
461
	}
S
Sathya Perla 已提交
462 463

	/* bad pkts received */
464
	stats->rx_errors = drvs->rx_crc_errors +
465 466 467 468 469 470 471 472
		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 +
473
		drvs->rx_dropped_runt;
474

S
Sathya Perla 已提交
475
	/* detailed rx errors */
476
	stats->rx_length_errors = drvs->rx_in_range_errors +
477 478
		drvs->rx_out_range_errors +
		drvs->rx_frame_too_long;
479

480
	stats->rx_crc_errors = drvs->rx_crc_errors;
S
Sathya Perla 已提交
481 482

	/* frame alignment errors */
483
	stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
484

S
Sathya Perla 已提交
485 486
	/* receiver fifo overrun */
	/* drops_no_pbuf is no per i/f, it's per BE card */
487
	stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
488 489
				drvs->rx_input_fifo_overflow_drop +
				drvs->rx_drops_no_pbuf;
490
	return stats;
S
Sathya Perla 已提交
491 492
}

493
void be_link_status_update(struct be_adapter *adapter, u32 link_status)
S
Sathya Perla 已提交
494 495 496
{
	struct net_device *netdev = adapter->netdev;

497 498 499 500 501 502 503 504
	/* when link status changes, link speed must be re-queried from card */
	adapter->link_speed = -1;
	if ((link_status & LINK_STATUS_MASK) == LINK_UP) {
		netif_carrier_on(netdev);
		dev_info(&adapter->pdev->dev, "%s: Link up\n", netdev->name);
	} else {
		netif_carrier_off(netdev);
		dev_info(&adapter->pdev->dev, "%s: Link down\n", netdev->name);
S
Sathya Perla 已提交
505 506 507
	}
}

508
static void be_tx_stats_update(struct be_tx_obj *txo,
509
			u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
S
Sathya Perla 已提交
510
{
511 512
	struct be_tx_stats *stats = tx_stats(txo);

513
	u64_stats_update_begin(&stats->sync);
514 515 516 517
	stats->tx_reqs++;
	stats->tx_wrbs += wrb_cnt;
	stats->tx_bytes += copied;
	stats->tx_pkts += (gso_segs ? gso_segs : 1);
S
Sathya Perla 已提交
518
	if (stopped)
519
		stats->tx_stops++;
520
	u64_stats_update_end(&stats->sync);
S
Sathya Perla 已提交
521 522 523
}

/* Determine number of WRB entries needed to xmit data in an skb */
524 525
static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
								bool *dummy)
S
Sathya Perla 已提交
526
{
527 528 529 530
	int cnt = (skb->len > skb->data_len);

	cnt += skb_shinfo(skb)->nr_frags;

S
Sathya Perla 已提交
531 532
	/* to account for hdr wrb */
	cnt++;
533 534 535
	if (lancer_chip(adapter) || !(cnt & 1)) {
		*dummy = false;
	} else {
S
Sathya Perla 已提交
536 537 538
		/* add a dummy to make it an even num */
		cnt++;
		*dummy = true;
539
	}
S
Sathya Perla 已提交
540 541 542 543 544 545 546 547 548 549 550
	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;
}

551 552
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 已提交
553
{
554 555 556
	u8 vlan_prio = 0;
	u16 vlan_tag = 0;

S
Sathya Perla 已提交
557 558 559 560
	memset(hdr, 0, sizeof(*hdr));

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

A
Ajit Khaparde 已提交
561
	if (skb_is_gso(skb)) {
S
Sathya Perla 已提交
562 563 564
		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);
565
		if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
A
Ajit Khaparde 已提交
566
			AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
567 568 569 570 571 572 573 574 575 576
		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 已提交
577 578 579 580 581 582 583
	} 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 已提交
584
	if (vlan_tx_tag_present(skb)) {
S
Sathya Perla 已提交
585
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
586 587 588 589 590 591 592
		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;
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
S
Sathya Perla 已提交
593 594 595 596 597 598 599 600
	}

	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 已提交
601
static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
602 603 604 605 606 607 608
		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;
609
	if (wrb->frag_len) {
610
		if (unmap_single)
I
Ivan Vecera 已提交
611 612
			dma_unmap_single(dev, dma, wrb->frag_len,
					 DMA_TO_DEVICE);
613
		else
I
Ivan Vecera 已提交
614
			dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
615 616
	}
}
S
Sathya Perla 已提交
617

618
static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
S
Sathya Perla 已提交
619 620
		struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
{
621 622
	dma_addr_t busaddr;
	int i, copied = 0;
I
Ivan Vecera 已提交
623
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
624 625 626
	struct sk_buff *first_skb = skb;
	struct be_eth_wrb *wrb;
	struct be_eth_hdr_wrb *hdr;
627 628
	bool map_single = false;
	u16 map_head;
S
Sathya Perla 已提交
629 630 631

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

634
	if (skb->len > skb->data_len) {
E
Eric Dumazet 已提交
635
		int len = skb_headlen(skb);
I
Ivan Vecera 已提交
636 637
		busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
		if (dma_mapping_error(dev, busaddr))
638 639
			goto dma_err;
		map_single = true;
640 641 642 643 644 645
		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 已提交
646

647
	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
E
Eric Dumazet 已提交
648
		const struct skb_frag_struct *frag =
649
			&skb_shinfo(skb)->frags[i];
650
		busaddr = skb_frag_dma_map(dev, frag, 0,
E
Eric Dumazet 已提交
651
					   skb_frag_size(frag), DMA_TO_DEVICE);
I
Ivan Vecera 已提交
652
		if (dma_mapping_error(dev, busaddr))
653
			goto dma_err;
654
		wrb = queue_head_node(txq);
E
Eric Dumazet 已提交
655
		wrb_fill(wrb, busaddr, skb_frag_size(frag));
656 657
		be_dws_cpu_to_le(wrb, sizeof(*wrb));
		queue_head_inc(txq);
E
Eric Dumazet 已提交
658
		copied += skb_frag_size(frag);
S
Sathya Perla 已提交
659 660 661 662 663 664 665 666 667
	}

	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);
	}

668
	wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied);
S
Sathya Perla 已提交
669 670 671
	be_dws_cpu_to_le(hdr, sizeof(*hdr));

	return copied;
672 673 674 675
dma_err:
	txq->head = map_head;
	while (copied) {
		wrb = queue_head_node(txq);
I
Ivan Vecera 已提交
676
		unmap_tx_frag(dev, wrb, map_single);
677 678 679 680 681
		map_single = false;
		copied -= wrb->frag_len;
		queue_head_inc(txq);
	}
	return 0;
S
Sathya Perla 已提交
682 683
}

684
static netdev_tx_t be_xmit(struct sk_buff *skb,
685
			struct net_device *netdev)
S
Sathya Perla 已提交
686 687
{
	struct be_adapter *adapter = netdev_priv(netdev);
688 689
	struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
	struct be_queue_info *txq = &txo->q;
S
Sathya Perla 已提交
690 691 692 693
	u32 wrb_cnt = 0, copied = 0;
	u32 start = txq->head;
	bool dummy_wrb, stopped = false;

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

696
	copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb);
697 698
	if (copied) {
		/* record the sent skb in the sent_skb table */
699 700
		BUG_ON(txo->sent_skb_list[start]);
		txo->sent_skb_list[start] = skb;
701 702 703 704 705

		/* 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
		 */
706
		atomic_add(wrb_cnt, &txq->used);
707 708
		if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
								txq->len) {
709
			netif_stop_subqueue(netdev, skb_get_queue_mapping(skb));
710 711
			stopped = true;
		}
S
Sathya Perla 已提交
712

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

715
		be_tx_stats_update(txo, wrb_cnt, copied,
716
				skb_shinfo(skb)->gso_segs, stopped);
717 718 719
	} else {
		txq->head = start;
		dev_kfree_skb_any(skb);
S
Sathya Perla 已提交
720 721 722 723 724 725 726 727
	}
	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 已提交
728 729
			new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
					(ETH_HLEN + ETH_FCS_LEN))) {
S
Sathya Perla 已提交
730 731
		dev_info(&adapter->pdev->dev,
			"MTU must be between %d and %d bytes\n",
A
Ajit Khaparde 已提交
732 733
			BE_MIN_MTU,
			(BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
S
Sathya Perla 已提交
734 735 736 737 738 739 740 741 742
		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;
}

/*
743 744
 * 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 已提交
745
 */
746
static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
S
Sathya Perla 已提交
747 748 749
{
	u16 vtag[BE_NUM_VLANS_SUPPORTED];
	u16 ntags = 0, i;
750
	int status = 0;
751 752 753 754 755 756 757
	u32 if_handle;

	if (vf) {
		if_handle = adapter->vf_cfg[vf_num].vf_if_handle;
		vtag[0] = cpu_to_le16(adapter->vf_cfg[vf_num].vf_vlan_tag);
		status = be_cmd_vlan_config(adapter, if_handle, vtag, 1, 1, 0);
	}
S
Sathya Perla 已提交
758

759 760 761 762
	/* No need to further configure vids if in promiscuous mode */
	if (adapter->promiscuous)
		return 0;

763
	if (adapter->vlans_added <= adapter->max_vlans)  {
S
Sathya Perla 已提交
764
		/* Construct VLAN Table to give to HW */
765
		for (i = 0; i < VLAN_N_VID; i++) {
S
Sathya Perla 已提交
766 767 768 769 770
			if (adapter->vlan_tag[i]) {
				vtag[ntags] = cpu_to_le16(i);
				ntags++;
			}
		}
771 772
		status = be_cmd_vlan_config(adapter, adapter->if_handle,
					vtag, ntags, 1, 0);
S
Sathya Perla 已提交
773
	} else {
774 775
		status = be_cmd_vlan_config(adapter, adapter->if_handle,
					NULL, 0, 1, 1);
S
Sathya Perla 已提交
776
	}
777

778
	return status;
S
Sathya Perla 已提交
779 780 781 782 783 784
}

static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
{
	struct be_adapter *adapter = netdev_priv(netdev);

785
	adapter->vlans_added++;
786 787 788
	if (!be_physfn(adapter))
		return;

S
Sathya Perla 已提交
789
	adapter->vlan_tag[vid] = 1;
790
	if (adapter->vlans_added <= (adapter->max_vlans + 1))
791
		be_vid_config(adapter, false, 0);
S
Sathya Perla 已提交
792 793 794 795 796 797
}

static void be_vlan_rem_vid(struct net_device *netdev, u16 vid)
{
	struct be_adapter *adapter = netdev_priv(netdev);

798 799
	adapter->vlans_added--;

800 801 802
	if (!be_physfn(adapter))
		return;

S
Sathya Perla 已提交
803
	adapter->vlan_tag[vid] = 0;
804
	if (adapter->vlans_added <= adapter->max_vlans)
805
		be_vid_config(adapter, false, 0);
S
Sathya Perla 已提交
806 807
}

808
static void be_set_rx_mode(struct net_device *netdev)
S
Sathya Perla 已提交
809 810 811
{
	struct be_adapter *adapter = netdev_priv(netdev);

812
	if (netdev->flags & IFF_PROMISC) {
813
		be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
814 815
		adapter->promiscuous = true;
		goto done;
S
Sathya Perla 已提交
816 817
	}

L
Lucas De Marchi 已提交
818
	/* BE was previously in promiscuous mode; disable it */
819 820
	if (adapter->promiscuous) {
		adapter->promiscuous = false;
821
		be_cmd_rx_filter(adapter, IFF_PROMISC, OFF);
822 823 824

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

827
	/* Enable multicast promisc if num configured exceeds what we support */
828
	if (netdev->flags & IFF_ALLMULTI ||
829 830
			netdev_mc_count(netdev) > BE_MAX_MC) {
		be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
831
		goto done;
S
Sathya Perla 已提交
832 833
	}

834
	be_cmd_rx_filter(adapter, IFF_MULTICAST, ON);
835 836
done:
	return;
S
Sathya Perla 已提交
837 838
}

839 840 841 842 843 844 845 846 847 848 849
static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	int status;

	if (!adapter->sriov_enabled)
		return -EPERM;

	if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
		return -EINVAL;

850 851 852
	if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
		status = be_cmd_pmac_del(adapter,
					adapter->vf_cfg[vf].vf_if_handle,
853
					adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
854

855 856
	status = be_cmd_pmac_add(adapter, mac,
				adapter->vf_cfg[vf].vf_if_handle,
857
				&adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
858 859

	if (status)
860 861
		dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
				mac, vf);
862 863 864
	else
		memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);

865 866 867
	return status;
}

868 869 870 871 872 873 874 875 876 877 878 879
static int be_get_vf_config(struct net_device *netdev, int vf,
			struct ifla_vf_info *vi)
{
	struct be_adapter *adapter = netdev_priv(netdev);

	if (!adapter->sriov_enabled)
		return -EPERM;

	if (vf >= num_vfs)
		return -EINVAL;

	vi->vf = vf;
880
	vi->tx_rate = adapter->vf_cfg[vf].vf_tx_rate;
881
	vi->vlan = adapter->vf_cfg[vf].vf_vlan_tag;
882 883 884 885 886 887
	vi->qos = 0;
	memcpy(&vi->mac, adapter->vf_cfg[vf].vf_mac_addr, ETH_ALEN);

	return 0;
}

888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
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;

	if (!adapter->sriov_enabled)
		return -EPERM;

	if ((vf >= num_vfs) || (vlan > 4095))
		return -EINVAL;

	if (vlan) {
		adapter->vf_cfg[vf].vf_vlan_tag = vlan;
		adapter->vlans_added++;
	} else {
		adapter->vf_cfg[vf].vf_vlan_tag = 0;
		adapter->vlans_added--;
	}

	status = be_vid_config(adapter, true, vf);

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

916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
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;

	if (!adapter->sriov_enabled)
		return -EPERM;

	if ((vf >= num_vfs) || (rate < 0))
		return -EINVAL;

	if (rate > 10000)
		rate = 10000;

	adapter->vf_cfg[vf].vf_tx_rate = rate;
932
	status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
933 934 935 936 937 938 939

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

940
static void be_rx_eqd_update(struct be_adapter *adapter, struct be_rx_obj *rxo)
S
Sathya Perla 已提交
941
{
942 943
	struct be_eq_obj *rx_eq = &rxo->rx_eq;
	struct be_rx_stats *stats = rx_stats(rxo);
944
	ulong now = jiffies;
945
	ulong delta = now - stats->rx_jiffies;
946 947
	u64 pkts;
	unsigned int start, eqd;
948 949 950

	if (!rx_eq->enable_aic)
		return;
S
Sathya Perla 已提交
951

952
	/* Wrapped around */
953 954
	if (time_before(now, stats->rx_jiffies)) {
		stats->rx_jiffies = now;
955 956
		return;
	}
S
Sathya Perla 已提交
957

958 959
	/* Update once a second */
	if (delta < HZ)
S
Sathya Perla 已提交
960 961
		return;

962 963 964 965 966
	do {
		start = u64_stats_fetch_begin_bh(&stats->sync);
		pkts = stats->rx_pkts;
	} while (u64_stats_fetch_retry_bh(&stats->sync, start));

967
	stats->rx_pps = (unsigned long)(pkts - stats->rx_pkts_prev) / (delta / HZ);
968
	stats->rx_pkts_prev = pkts;
969
	stats->rx_jiffies = now;
970 971 972 973 974 975 976 977 978 979 980 981
	eqd = stats->rx_pps / 110000;
	eqd = eqd << 3;
	if (eqd > rx_eq->max_eqd)
		eqd = rx_eq->max_eqd;
	if (eqd < rx_eq->min_eqd)
		eqd = rx_eq->min_eqd;
	if (eqd < 10)
		eqd = 0;
	if (eqd != rx_eq->cur_eqd) {
		be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);
		rx_eq->cur_eqd = eqd;
	}
S
Sathya Perla 已提交
982 983
}

984
static void be_rx_stats_update(struct be_rx_obj *rxo,
985
		struct be_rx_compl_info *rxcp)
986
{
987
	struct be_rx_stats *stats = rx_stats(rxo);
988

989
	u64_stats_update_begin(&stats->sync);
990
	stats->rx_compl++;
991
	stats->rx_bytes += rxcp->pkt_size;
992
	stats->rx_pkts++;
993
	if (rxcp->pkt_type == BE_MULTICAST_PACKET)
994
		stats->rx_mcast_pkts++;
995
	if (rxcp->err)
996
		stats->rx_compl_err++;
997
	u64_stats_update_end(&stats->sync);
998 999
}

1000
static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1001
{
1002 1003
	/* L4 checksum is not reliable for non TCP/UDP packets.
	 * Also ignore ipcksm for ipv6 pkts */
1004 1005
	return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
				(rxcp->ip_csum || rxcp->ipv6);
1006 1007
}

S
Sathya Perla 已提交
1008
static struct be_rx_page_info *
1009 1010 1011
get_rx_page_info(struct be_adapter *adapter,
		struct be_rx_obj *rxo,
		u16 frag_idx)
S
Sathya Perla 已提交
1012 1013
{
	struct be_rx_page_info *rx_page_info;
1014
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1015

1016
	rx_page_info = &rxo->page_info_tbl[frag_idx];
S
Sathya Perla 已提交
1017 1018
	BUG_ON(!rx_page_info->page);

A
Ajit Khaparde 已提交
1019
	if (rx_page_info->last_page_user) {
I
Ivan Vecera 已提交
1020 1021 1022
		dma_unmap_page(&adapter->pdev->dev,
			       dma_unmap_addr(rx_page_info, bus),
			       adapter->big_page_size, DMA_FROM_DEVICE);
A
Ajit Khaparde 已提交
1023 1024
		rx_page_info->last_page_user = false;
	}
S
Sathya Perla 已提交
1025 1026 1027 1028 1029 1030 1031

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

/* Throwaway the data in the Rx completion */
static void be_rx_compl_discard(struct be_adapter *adapter,
1032
		struct be_rx_obj *rxo,
1033
		struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1034
{
1035
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1036
	struct be_rx_page_info *page_info;
1037
	u16 i, num_rcvd = rxcp->num_rcvd;
S
Sathya Perla 已提交
1038

1039
	for (i = 0; i < num_rcvd; i++) {
1040
		page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
1041 1042
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
1043
		index_inc(&rxcp->rxq_idx, rxq->len);
S
Sathya Perla 已提交
1044 1045 1046 1047 1048 1049 1050
	}
}

/*
 * skb_fill_rx_data forms a complete skb for an ether frame
 * indicated by rxcp.
 */
1051
static void skb_fill_rx_data(struct be_adapter *adapter, struct be_rx_obj *rxo,
1052
			struct sk_buff *skb, struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1053
{
1054
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1055
	struct be_rx_page_info *page_info;
1056 1057
	u16 i, j;
	u16 hdr_len, curr_frag_len, remaining;
S
Sathya Perla 已提交
1058 1059
	u8 *start;

1060
	page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
S
Sathya Perla 已提交
1061 1062 1063 1064
	start = page_address(page_info->page) + page_info->page_offset;
	prefetch(start);

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

	/* Copy the header portion into skb_data */
1068
	hdr_len = min(BE_HDR_LEN, curr_frag_len);
S
Sathya Perla 已提交
1069 1070 1071 1072 1073 1074 1075 1076 1077
	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;
1078
		skb_frag_set_page(skb, 0, page_info->page);
S
Sathya Perla 已提交
1079 1080
		skb_shinfo(skb)->frags[0].page_offset =
					page_info->page_offset + hdr_len;
E
Eric Dumazet 已提交
1081
		skb_frag_size_set(&skb_shinfo(skb)->frags[0], curr_frag_len - hdr_len);
S
Sathya Perla 已提交
1082
		skb->data_len = curr_frag_len - hdr_len;
E
Eric Dumazet 已提交
1083
		skb->truesize += rx_frag_size;
S
Sathya Perla 已提交
1084 1085
		skb->tail += hdr_len;
	}
A
Ajit Khaparde 已提交
1086
	page_info->page = NULL;
S
Sathya Perla 已提交
1087

1088 1089 1090
	if (rxcp->pkt_size <= rx_frag_size) {
		BUG_ON(rxcp->num_rcvd != 1);
		return;
S
Sathya Perla 已提交
1091 1092 1093
	}

	/* More frags present for this completion */
1094 1095 1096 1097 1098
	index_inc(&rxcp->rxq_idx, rxq->len);
	remaining = rxcp->pkt_size - curr_frag_len;
	for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
		page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
		curr_frag_len = min(remaining, rx_frag_size);
S
Sathya Perla 已提交
1099

1100 1101 1102 1103
		/* Coalesce all frags from the same physical page in one slot */
		if (page_info->page_offset == 0) {
			/* Fresh page */
			j++;
1104
			skb_frag_set_page(skb, j, page_info->page);
1105 1106
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
1107
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1108 1109 1110 1111 1112
			skb_shinfo(skb)->nr_frags++;
		} else {
			put_page(page_info->page);
		}

E
Eric Dumazet 已提交
1113
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
S
Sathya Perla 已提交
1114 1115
		skb->len += curr_frag_len;
		skb->data_len += curr_frag_len;
E
Eric Dumazet 已提交
1116
		skb->truesize += rx_frag_size;
1117 1118
		remaining -= curr_frag_len;
		index_inc(&rxcp->rxq_idx, rxq->len);
A
Ajit Khaparde 已提交
1119
		page_info->page = NULL;
S
Sathya Perla 已提交
1120
	}
1121
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
1122 1123
}

1124
/* Process the RX completion indicated by rxcp when GRO is disabled */
S
Sathya Perla 已提交
1125
static void be_rx_compl_process(struct be_adapter *adapter,
1126
			struct be_rx_obj *rxo,
1127
			struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1128
{
1129
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
1130
	struct sk_buff *skb;
1131

1132
	skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);
1133
	if (unlikely(!skb)) {
1134
		rx_stats(rxo)->rx_drops_no_skbs++;
1135
		be_rx_compl_discard(adapter, rxo, rxcp);
S
Sathya Perla 已提交
1136 1137 1138
		return;
	}

1139
	skb_fill_rx_data(adapter, rxo, skb, rxcp);
S
Sathya Perla 已提交
1140

1141
	if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1142
		skb->ip_summed = CHECKSUM_UNNECESSARY;
S
Somnath Kotur 已提交
1143 1144
	else
		skb_checksum_none_assert(skb);
S
Sathya Perla 已提交
1145

1146
	skb->protocol = eth_type_trans(skb, netdev);
A
Ajit Khaparde 已提交
1147 1148 1149
	if (adapter->netdev->features & NETIF_F_RXHASH)
		skb->rxhash = rxcp->rss_hash;

S
Sathya Perla 已提交
1150

1151
	if (rxcp->vlanf)
A
Ajit Khaparde 已提交
1152 1153 1154
		__vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);

	netif_receive_skb(skb);
S
Sathya Perla 已提交
1155 1156
}

1157 1158
/* Process the RX completion indicated by rxcp when GRO is enabled */
static void be_rx_compl_process_gro(struct be_adapter *adapter,
1159
		struct be_rx_obj *rxo,
1160
		struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1161 1162
{
	struct be_rx_page_info *page_info;
1163
	struct sk_buff *skb = NULL;
1164 1165
	struct be_queue_info *rxq = &rxo->q;
	struct be_eq_obj *eq_obj =  &rxo->rx_eq;
1166 1167
	u16 remaining, curr_frag_len;
	u16 i, j;
1168

1169 1170
	skb = napi_get_frags(&eq_obj->napi);
	if (!skb) {
1171
		be_rx_compl_discard(adapter, rxo, rxcp);
1172 1173 1174
		return;
	}

1175 1176 1177
	remaining = rxcp->pkt_size;
	for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
		page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
S
Sathya Perla 已提交
1178 1179 1180

		curr_frag_len = min(remaining, rx_frag_size);

1181 1182 1183 1184
		/* 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++;
1185
			skb_frag_set_page(skb, j, page_info->page);
1186 1187
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
1188
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1189 1190 1191
		} else {
			put_page(page_info->page);
		}
E
Eric Dumazet 已提交
1192
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
E
Eric Dumazet 已提交
1193
		skb->truesize += rx_frag_size;
1194
		remaining -= curr_frag_len;
1195
		index_inc(&rxcp->rxq_idx, rxq->len);
S
Sathya Perla 已提交
1196 1197
		memset(page_info, 0, sizeof(*page_info));
	}
1198
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
1199

1200
	skb_shinfo(skb)->nr_frags = j + 1;
1201 1202
	skb->len = rxcp->pkt_size;
	skb->data_len = rxcp->pkt_size;
1203
	skb->ip_summed = CHECKSUM_UNNECESSARY;
A
Ajit Khaparde 已提交
1204 1205
	if (adapter->netdev->features & NETIF_F_RXHASH)
		skb->rxhash = rxcp->rss_hash;
1206

1207
	if (rxcp->vlanf)
A
Ajit Khaparde 已提交
1208 1209 1210
		__vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);

	napi_gro_frags(&eq_obj->napi);
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
}

static void be_parse_rx_compl_v1(struct be_adapter *adapter,
				struct be_eth_rx_compl *compl,
				struct be_rx_compl_info *rxcp)
{
	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);
1222
	rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
	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 已提交
1235 1236
	rxcp->rss_hash =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, rxcp);
1237 1238
	if (rxcp->vlanf) {
		rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1239 1240 1241
					  compl);
		rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
					       compl);
1242
	}
1243
	rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, port, compl);
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
}

static void be_parse_rx_compl_v0(struct be_adapter *adapter,
				struct be_eth_rx_compl *compl,
				struct be_rx_compl_info *rxcp)
{
	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);
1255
	rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
	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 已提交
1268 1269
	rxcp->rss_hash =
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, rxcp);
1270 1271
	if (rxcp->vlanf) {
		rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1272 1273 1274
					  compl);
		rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
					       compl);
1275
	}
1276
	rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, port, compl);
1277 1278 1279 1280 1281 1282 1283
}

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 已提交
1284

1285 1286 1287 1288
	/* 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 已提交
1289

1290 1291
	rmb();
	be_dws_le_to_cpu(compl, sizeof(*compl));
S
Sathya Perla 已提交
1292

1293 1294 1295 1296
	if (adapter->be3_native)
		be_parse_rx_compl_v1(adapter, compl, rxcp);
	else
		be_parse_rx_compl_v0(adapter, compl, rxcp);
S
Sathya Perla 已提交
1297

1298 1299 1300
	if (rxcp->vlanf) {
		/* vlanf could be wrongly set in some cards.
		 * ignore if vtm is not set */
1301
		if ((adapter->function_mode & FLEX10_MODE) && !rxcp->vtm)
1302
			rxcp->vlanf = 0;
S
Sathya Perla 已提交
1303

1304
		if (!lancer_chip(adapter))
1305
			rxcp->vlan_tag = swab16(rxcp->vlan_tag);
S
Sathya Perla 已提交
1306

1307
		if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
1308
		    !adapter->vlan_tag[rxcp->vlan_tag])
1309 1310
			rxcp->vlanf = 0;
	}
1311 1312 1313

	/* 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 已提交
1314

1315
	queue_tail_inc(&rxo->cq);
S
Sathya Perla 已提交
1316 1317 1318
	return rxcp;
}

1319
static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
S
Sathya Perla 已提交
1320 1321
{
	u32 order = get_order(size);
1322

S
Sathya Perla 已提交
1323
	if (order > 0)
1324 1325
		gfp |= __GFP_COMP;
	return  alloc_pages(gfp, order);
S
Sathya Perla 已提交
1326 1327 1328 1329 1330 1331
}

/*
 * Allocate a page, split it to fragments of size rx_frag_size and post as
 * receive buffers to BE
 */
1332
static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
S
Sathya Perla 已提交
1333
{
1334 1335
	struct be_adapter *adapter = rxo->adapter;
	struct be_rx_page_info *page_info_tbl = rxo->page_info_tbl;
1336
	struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1337
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
1338 1339 1340 1341 1342
	struct page *pagep = NULL;
	struct be_eth_rx_d *rxd;
	u64 page_dmaaddr = 0, frag_dmaaddr;
	u32 posted, page_offset = 0;

1343
	page_info = &rxo->page_info_tbl[rxq->head];
S
Sathya Perla 已提交
1344 1345
	for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
		if (!pagep) {
1346
			pagep = be_alloc_pages(adapter->big_page_size, gfp);
S
Sathya Perla 已提交
1347
			if (unlikely(!pagep)) {
1348
				rx_stats(rxo)->rx_post_fail++;
S
Sathya Perla 已提交
1349 1350
				break;
			}
I
Ivan Vecera 已提交
1351 1352 1353
			page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
						    0, adapter->big_page_size,
						    DMA_FROM_DEVICE);
S
Sathya Perla 已提交
1354 1355 1356 1357 1358 1359 1360
			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;
1361
		dma_unmap_addr_set(page_info, bus, page_dmaaddr);
S
Sathya Perla 已提交
1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
		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;
		}
1374 1375 1376

		prev_page_info = page_info;
		queue_head_inc(rxq);
S
Sathya Perla 已提交
1377 1378 1379
		page_info = &page_info_tbl[rxq->head];
	}
	if (pagep)
1380
		prev_page_info->last_page_user = true;
S
Sathya Perla 已提交
1381 1382 1383

	if (posted) {
		atomic_add(posted, &rxq->used);
1384
		be_rxq_notify(adapter, rxq->id, posted);
1385 1386
	} else if (atomic_read(&rxq->used) == 0) {
		/* Let be_worker replenish when memory is available */
1387
		rxo->rx_post_starved = true;
S
Sathya Perla 已提交
1388 1389 1390
	}
}

1391
static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
S
Sathya Perla 已提交
1392 1393 1394 1395 1396 1397
{
	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;

1398
	rmb();
S
Sathya Perla 已提交
1399 1400 1401 1402 1403 1404 1405 1406
	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;
}

1407 1408
static u16 be_tx_compl_process(struct be_adapter *adapter,
		struct be_tx_obj *txo, u16 last_index)
S
Sathya Perla 已提交
1409
{
1410
	struct be_queue_info *txq = &txo->q;
1411
	struct be_eth_wrb *wrb;
1412
	struct sk_buff **sent_skbs = txo->sent_skb_list;
S
Sathya Perla 已提交
1413
	struct sk_buff *sent_skb;
1414 1415
	u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
	bool unmap_skb_hdr = true;
S
Sathya Perla 已提交
1416

1417
	sent_skb = sent_skbs[txq->tail];
S
Sathya Perla 已提交
1418
	BUG_ON(!sent_skb);
1419 1420 1421
	sent_skbs[txq->tail] = NULL;

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

1424
	do {
S
Sathya Perla 已提交
1425
		cur_index = txq->tail;
1426
		wrb = queue_tail_node(txq);
I
Ivan Vecera 已提交
1427 1428
		unmap_tx_frag(&adapter->pdev->dev, wrb,
			      (unmap_skb_hdr && skb_headlen(sent_skb)));
1429 1430
		unmap_skb_hdr = false;

S
Sathya Perla 已提交
1431 1432
		num_wrbs++;
		queue_tail_inc(txq);
1433
	} while (cur_index != last_index);
S
Sathya Perla 已提交
1434 1435

	kfree_skb(sent_skb);
1436
	return num_wrbs;
S
Sathya Perla 已提交
1437 1438
}

1439 1440 1441 1442 1443 1444 1445
static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj)
{
	struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);

	if (!eqe->evt)
		return NULL;

1446
	rmb();
1447 1448 1449 1450 1451 1452
	eqe->evt = le32_to_cpu(eqe->evt);
	queue_tail_inc(&eq_obj->q);
	return eqe;
}

static int event_handle(struct be_adapter *adapter,
1453 1454
			struct be_eq_obj *eq_obj,
			bool rearm)
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
{
	struct be_eq_entry *eqe;
	u16 num = 0;

	while ((eqe = event_get(eq_obj)) != NULL) {
		eqe->evt = 0;
		num++;
	}

	/* Deal with any spurious interrupts that come
	 * without events
	 */
1467 1468 1469 1470
	if (!num)
		rearm = true;

	be_eq_notify(adapter, eq_obj->q.id, rearm, true, num);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
	if (num)
		napi_schedule(&eq_obj->napi);

	return num;
}

/* Just read and notify events without processing them.
 * Used at the time of destroying event queues */
static void be_eq_clean(struct be_adapter *adapter,
			struct be_eq_obj *eq_obj)
{
	struct be_eq_entry *eqe;
	u16 num = 0;

	while ((eqe = event_get(eq_obj)) != NULL) {
		eqe->evt = 0;
		num++;
	}

	if (num)
		be_eq_notify(adapter, eq_obj->q.id, false, true, num);
}

1494
static void be_rx_q_clean(struct be_adapter *adapter, struct be_rx_obj *rxo)
S
Sathya Perla 已提交
1495 1496
{
	struct be_rx_page_info *page_info;
1497 1498
	struct be_queue_info *rxq = &rxo->q;
	struct be_queue_info *rx_cq = &rxo->cq;
1499
	struct be_rx_compl_info *rxcp;
S
Sathya Perla 已提交
1500 1501 1502
	u16 tail;

	/* First cleanup pending rx completions */
1503 1504
	while ((rxcp = be_rx_compl_get(rxo)) != NULL) {
		be_rx_compl_discard(adapter, rxo, rxcp);
1505
		be_cq_notify(adapter, rx_cq->id, false, 1);
S
Sathya Perla 已提交
1506 1507 1508 1509
	}

	/* Then free posted rx buffer that were not used */
	tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1510
	for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1511
		page_info = get_rx_page_info(adapter, rxo, tail);
S
Sathya Perla 已提交
1512 1513 1514 1515
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
	}
	BUG_ON(atomic_read(&rxq->used));
1516
	rxq->tail = rxq->head = 0;
S
Sathya Perla 已提交
1517 1518
}

1519 1520
static void be_tx_compl_clean(struct be_adapter *adapter,
				struct be_tx_obj *txo)
S
Sathya Perla 已提交
1521
{
1522 1523
	struct be_queue_info *tx_cq = &txo->cq;
	struct be_queue_info *txq = &txo->q;
1524
	struct be_eth_tx_compl *txcp;
1525
	u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
1526
	struct sk_buff **sent_skbs = txo->sent_skb_list;
1527 1528
	struct sk_buff *sent_skb;
	bool dummy_wrb;
1529 1530 1531 1532 1533 1534

	/* Wait for a max of 200ms for all the tx-completions to arrive. */
	do {
		while ((txcp = be_tx_compl_get(tx_cq))) {
			end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
					wrb_index, txcp);
1535
			num_wrbs += be_tx_compl_process(adapter, txo, end_idx);
1536 1537 1538 1539
			cmpl++;
		}
		if (cmpl) {
			be_cq_notify(adapter, tx_cq->id, false, cmpl);
1540
			atomic_sub(num_wrbs, &txq->used);
1541
			cmpl = 0;
1542
			num_wrbs = 0;
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
		}

		if (atomic_read(&txq->used) == 0 || ++timeo > 200)
			break;

		mdelay(1);
	} while (true);

	if (atomic_read(&txq->used))
		dev_err(&adapter->pdev->dev, "%d pending tx-completions\n",
			atomic_read(&txq->used));
1554 1555 1556 1557 1558 1559

	/* free posted tx for which compls will never arrive */
	while (atomic_read(&txq->used)) {
		sent_skb = sent_skbs[txq->tail];
		end_idx = txq->tail;
		index_adv(&end_idx,
1560 1561
			wrb_cnt_for_skb(adapter, sent_skb, &dummy_wrb) - 1,
			txq->len);
1562
		num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
1563
		atomic_sub(num_wrbs, &txq->used);
1564
	}
S
Sathya Perla 已提交
1565 1566
}

1567 1568 1569 1570
static void be_mcc_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;

1571
	q = &adapter->mcc_obj.q;
1572
	if (q->created)
1573
		be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1574 1575
	be_queue_free(adapter, q);

1576
	q = &adapter->mcc_obj.cq;
1577
	if (q->created)
1578
		be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1579 1580 1581 1582 1583 1584 1585 1586 1587
	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;

	/* Alloc MCC compl queue */
1588
	cq = &adapter->mcc_obj.cq;
1589
	if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1590
			sizeof(struct be_mcc_compl)))
1591 1592 1593
		goto err;

	/* Ask BE to create MCC compl queue; share TX's eq */
1594
	if (be_cmd_cq_create(adapter, cq, &adapter->tx_eq.q, false, true, 0))
1595 1596 1597
		goto mcc_cq_free;

	/* Alloc MCC queue */
1598
	q = &adapter->mcc_obj.q;
1599 1600 1601 1602
	if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
		goto mcc_cq_destroy;

	/* Ask BE to create MCC queue */
1603
	if (be_cmd_mccq_create(adapter, q, cq))
1604 1605 1606 1607 1608 1609 1610
		goto mcc_q_free;

	return 0;

mcc_q_free:
	be_queue_free(adapter, q);
mcc_cq_destroy:
1611
	be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1612 1613 1614 1615 1616 1617
mcc_cq_free:
	be_queue_free(adapter, cq);
err:
	return -1;
}

S
Sathya Perla 已提交
1618 1619 1620
static void be_tx_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;
1621 1622
	struct be_tx_obj *txo;
	u8 i;
S
Sathya Perla 已提交
1623

1624 1625 1626 1627 1628
	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 已提交
1629

1630 1631 1632 1633 1634
		q = &txo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);
	}
S
Sathya Perla 已提交
1635

1636 1637 1638
	/* Clear any residual events */
	be_eq_clean(adapter, &adapter->tx_eq);

S
Sathya Perla 已提交
1639 1640
	q = &adapter->tx_eq.q;
	if (q->created)
1641
		be_cmd_q_destroy(adapter, q, QTYPE_EQ);
S
Sathya Perla 已提交
1642 1643 1644
	be_queue_free(adapter, q);
}

1645 1646 1647
static int be_num_txqs_want(struct be_adapter *adapter)
{
	if ((num_vfs && adapter->sriov_enabled) ||
1648
		be_is_mc(adapter) ||
1649 1650 1651 1652 1653 1654 1655
		lancer_chip(adapter) || !be_physfn(adapter) ||
		adapter->generation == BE_GEN2)
		return 1;
	else
		return MAX_TX_QS;
}

1656
/* One TX event queue is shared by all TX compl qs */
S
Sathya Perla 已提交
1657 1658 1659
static int be_tx_queues_create(struct be_adapter *adapter)
{
	struct be_queue_info *eq, *q, *cq;
1660 1661
	struct be_tx_obj *txo;
	u8 i;
S
Sathya Perla 已提交
1662

1663 1664 1665 1666 1667
	adapter->num_tx_qs = be_num_txqs_want(adapter);
	if (adapter->num_tx_qs != MAX_TX_QS)
		netif_set_real_num_tx_queues(adapter->netdev,
			adapter->num_tx_qs);

S
Sathya Perla 已提交
1668 1669 1670 1671
	adapter->tx_eq.max_eqd = 0;
	adapter->tx_eq.min_eqd = 0;
	adapter->tx_eq.cur_eqd = 96;
	adapter->tx_eq.enable_aic = false;
1672

S
Sathya Perla 已提交
1673
	eq = &adapter->tx_eq.q;
1674 1675
	if (be_queue_alloc(adapter, eq, EVNT_Q_LEN,
		sizeof(struct be_eq_entry)))
S
Sathya Perla 已提交
1676 1677
		return -1;

1678
	if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd))
1679
		goto err;
1680
	adapter->tx_eq.eq_idx = adapter->eq_next_idx++;
1681

1682 1683 1684
	for_all_tx_queues(adapter, txo, i) {
		cq = &txo->cq;
		if (be_queue_alloc(adapter, cq, TX_CQ_LEN,
S
Sathya Perla 已提交
1685
			sizeof(struct be_eth_tx_compl)))
1686
			goto err;
S
Sathya Perla 已提交
1687

1688 1689
		if (be_cmd_cq_create(adapter, cq, eq, false, false, 3))
			goto err;
S
Sathya Perla 已提交
1690

1691 1692 1693 1694
		q = &txo->q;
		if (be_queue_alloc(adapter, q, TX_Q_LEN,
			sizeof(struct be_eth_wrb)))
			goto err;
S
Sathya Perla 已提交
1695

1696 1697 1698
		if (be_cmd_txq_create(adapter, q, cq))
			goto err;
	}
S
Sathya Perla 已提交
1699 1700
	return 0;

1701 1702
err:
	be_tx_queues_destroy(adapter);
S
Sathya Perla 已提交
1703 1704 1705 1706 1707 1708
	return -1;
}

static void be_rx_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;
1709 1710 1711 1712
	struct be_rx_obj *rxo;
	int i;

	for_all_rx_queues(adapter, rxo, i) {
1713
		be_queue_free(adapter, &rxo->q);
1714 1715 1716 1717 1718 1719 1720

		q = &rxo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);

		q = &rxo->rx_eq.q;
1721
		if (q->created)
1722 1723
			be_cmd_q_destroy(adapter, q, QTYPE_EQ);
		be_queue_free(adapter, q);
S
Sathya Perla 已提交
1724 1725 1726
	}
}

1727 1728
static u32 be_num_rxqs_want(struct be_adapter *adapter)
{
1729
	if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
1730 1731
		!adapter->sriov_enabled && be_physfn(adapter) &&
		!be_is_mc(adapter)) {
1732 1733 1734 1735 1736 1737 1738 1739
		return 1 + MAX_RSS_QS; /* one default non-RSS queue */
	} else {
		dev_warn(&adapter->pdev->dev,
			"No support for multiple RX queues\n");
		return 1;
	}
}

S
Sathya Perla 已提交
1740 1741 1742
static int be_rx_queues_create(struct be_adapter *adapter)
{
	struct be_queue_info *eq, *q, *cq;
1743 1744
	struct be_rx_obj *rxo;
	int rc, i;
S
Sathya Perla 已提交
1745

1746 1747 1748 1749 1750 1751 1752
	adapter->num_rx_qs = min(be_num_rxqs_want(adapter),
				msix_enabled(adapter) ?
					adapter->num_msix_vec - 1 : 1);
	if (adapter->num_rx_qs != MAX_RX_QS)
		dev_warn(&adapter->pdev->dev,
			"Can create only %d RX queues", adapter->num_rx_qs);

S
Sathya Perla 已提交
1753
	adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	for_all_rx_queues(adapter, rxo, i) {
		rxo->adapter = adapter;
		rxo->rx_eq.max_eqd = BE_MAX_EQD;
		rxo->rx_eq.enable_aic = true;

		/* EQ */
		eq = &rxo->rx_eq.q;
		rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
					sizeof(struct be_eq_entry));
		if (rc)
			goto err;

		rc = be_cmd_eq_create(adapter, eq, rxo->rx_eq.cur_eqd);
		if (rc)
			goto err;

1770
		rxo->rx_eq.eq_idx = adapter->eq_next_idx++;
1771

1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
		/* CQ */
		cq = &rxo->cq;
		rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
				sizeof(struct be_eth_rx_compl));
		if (rc)
			goto err;

		rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3);
		if (rc)
			goto err;
1782 1783

		/* Rx Q - will be created in be_open() */
1784 1785 1786 1787 1788 1789 1790
		q = &rxo->q;
		rc = be_queue_alloc(adapter, q, RX_Q_LEN,
				sizeof(struct be_eth_rx_d));
		if (rc)
			goto err;

	}
S
Sathya Perla 已提交
1791 1792

	return 0;
1793 1794 1795
err:
	be_rx_queues_destroy(adapter);
	return -1;
S
Sathya Perla 已提交
1796 1797
}

1798
static bool event_peek(struct be_eq_obj *eq_obj)
1799
{
1800 1801 1802 1803 1804
	struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
	if (!eqe->evt)
		return false;
	else
		return true;
1805 1806
}

S
Sathya Perla 已提交
1807 1808 1809
static irqreturn_t be_intx(int irq, void *dev)
{
	struct be_adapter *adapter = dev;
1810
	struct be_rx_obj *rxo;
1811
	int isr, i, tx = 0 , rx = 0;
S
Sathya Perla 已提交
1812

1813 1814
	if (lancer_chip(adapter)) {
		if (event_peek(&adapter->tx_eq))
1815
			tx = event_handle(adapter, &adapter->tx_eq, false);
1816 1817
		for_all_rx_queues(adapter, rxo, i) {
			if (event_peek(&rxo->rx_eq))
1818
				rx |= event_handle(adapter, &rxo->rx_eq, true);
1819
		}
S
Sathya Perla 已提交
1820

1821 1822
		if (!(tx || rx))
			return IRQ_NONE;
1823

1824 1825 1826 1827 1828 1829
	} else {
		isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
			(adapter->tx_eq.q.id / 8) * CEV_ISR_SIZE);
		if (!isr)
			return IRQ_NONE;

1830
		if ((1 << adapter->tx_eq.eq_idx & isr))
1831
			event_handle(adapter, &adapter->tx_eq, false);
1832 1833

		for_all_rx_queues(adapter, rxo, i) {
1834
			if ((1 << rxo->rx_eq.eq_idx & isr))
1835
				event_handle(adapter, &rxo->rx_eq, true);
1836
		}
1837
	}
1838

1839
	return IRQ_HANDLED;
S
Sathya Perla 已提交
1840 1841 1842 1843
}

static irqreturn_t be_msix_rx(int irq, void *dev)
{
1844 1845
	struct be_rx_obj *rxo = dev;
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
1846

1847
	event_handle(adapter, &rxo->rx_eq, true);
S
Sathya Perla 已提交
1848 1849 1850 1851

	return IRQ_HANDLED;
}

1852
static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
S
Sathya Perla 已提交
1853 1854 1855
{
	struct be_adapter *adapter = dev;

1856
	event_handle(adapter, &adapter->tx_eq, false);
S
Sathya Perla 已提交
1857 1858 1859 1860

	return IRQ_HANDLED;
}

1861
static inline bool do_gro(struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
1862
{
1863
	return (rxcp->tcpf && !rxcp->err) ? true : false;
S
Sathya Perla 已提交
1864 1865
}

S
stephen hemminger 已提交
1866
static int be_poll_rx(struct napi_struct *napi, int budget)
S
Sathya Perla 已提交
1867 1868
{
	struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1869 1870 1871
	struct be_rx_obj *rxo = container_of(rx_eq, struct be_rx_obj, rx_eq);
	struct be_adapter *adapter = rxo->adapter;
	struct be_queue_info *rx_cq = &rxo->cq;
1872
	struct be_rx_compl_info *rxcp;
S
Sathya Perla 已提交
1873 1874
	u32 work_done;

1875
	rx_stats(rxo)->rx_polls++;
S
Sathya Perla 已提交
1876
	for (work_done = 0; work_done < budget; work_done++) {
1877
		rxcp = be_rx_compl_get(rxo);
S
Sathya Perla 已提交
1878 1879 1880
		if (!rxcp)
			break;

1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
		/* 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)) {
			be_rx_compl_discard(adapter, rxo, rxcp);
			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))) {
1896
			be_rx_compl_discard(adapter, rxo, rxcp);
1897
			goto loop_continue;
1898
		}
1899

1900 1901 1902 1903 1904
		if (do_gro(rxcp))
			be_rx_compl_process_gro(adapter, rxo, rxcp);
		else
			be_rx_compl_process(adapter, rxo, rxcp);
loop_continue:
1905
		be_rx_stats_update(rxo, rxcp);
S
Sathya Perla 已提交
1906 1907 1908
	}

	/* Refill the queue */
1909
	if (work_done && atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
1910
		be_post_rx_frags(rxo, GFP_ATOMIC);
S
Sathya Perla 已提交
1911 1912 1913 1914

	/* All consumed */
	if (work_done < budget) {
		napi_complete(napi);
1915
		be_cq_notify(adapter, rx_cq->id, true, work_done);
S
Sathya Perla 已提交
1916 1917
	} else {
		/* More to be consumed; continue with interrupts disabled */
1918
		be_cq_notify(adapter, rx_cq->id, false, work_done);
S
Sathya Perla 已提交
1919 1920 1921 1922
	}
	return work_done;
}

S
Sathya Perla 已提交
1923 1924 1925 1926
/* As TX and MCC share the same EQ check for both TX and MCC completions.
 * For TX/MCC we don't honour budget; consume everything
 */
static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
S
Sathya Perla 已提交
1927
{
S
Sathya Perla 已提交
1928 1929 1930
	struct be_eq_obj *tx_eq = container_of(napi, struct be_eq_obj, napi);
	struct be_adapter *adapter =
		container_of(tx_eq, struct be_adapter, tx_eq);
1931
	struct be_tx_obj *txo;
S
Sathya Perla 已提交
1932
	struct be_eth_tx_compl *txcp;
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949
	int tx_compl, mcc_compl, status = 0;
	u8 i;
	u16 num_wrbs;

	for_all_tx_queues(adapter, txo, i) {
		tx_compl = 0;
		num_wrbs = 0;
		while ((txcp = be_tx_compl_get(&txo->cq))) {
			num_wrbs += be_tx_compl_process(adapter, txo,
				AMAP_GET_BITS(struct amap_eth_tx_compl,
					wrb_index, txcp));
			tx_compl++;
		}
		if (tx_compl) {
			be_cq_notify(adapter, txo->cq.id, true, tx_compl);

			atomic_sub(num_wrbs, &txo->q.used);
S
Sathya Perla 已提交
1950

1951 1952 1953 1954 1955 1956 1957
			/* 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, i) &&
				atomic_read(&txo->q.used) < txo->q.len / 2) {
				netif_wake_subqueue(adapter->netdev, i);
			}

1958
			u64_stats_update_begin(&tx_stats(txo)->sync_compl);
1959
			tx_stats(txo)->tx_compl += tx_compl;
1960
			u64_stats_update_end(&tx_stats(txo)->sync_compl);
1961
		}
S
Sathya Perla 已提交
1962 1963
	}

S
Sathya Perla 已提交
1964 1965 1966 1967 1968 1969 1970
	mcc_compl = be_process_mcc(adapter, &status);

	if (mcc_compl) {
		struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
		be_cq_notify(adapter, mcc_obj->cq.id, true, mcc_compl);
	}

1971
	napi_complete(napi);
S
Sathya Perla 已提交
1972

1973
	be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
1974
	adapter->drv_stats.tx_events++;
S
Sathya Perla 已提交
1975 1976 1977
	return 1;
}

1978
void be_detect_dump_ue(struct be_adapter *adapter)
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
{
	u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
	u32 i;

	pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_LOW, &ue_status_lo);
	pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_HIGH, &ue_status_hi);
	pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_LOW_MASK, &ue_status_lo_mask);
	pci_read_config_dword(adapter->pdev,
				PCICFG_UE_STATUS_HI_MASK, &ue_status_hi_mask);

	ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
	ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));

1995 1996
	if (ue_status_lo || ue_status_hi) {
		adapter->ue_detected = true;
1997
		adapter->eeh_err = true;
1998 1999 2000
		dev_err(&adapter->pdev->dev, "UE Detected!!\n");
	}

2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
	if (ue_status_lo) {
		for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
			if (ue_status_lo & 1)
				dev_err(&adapter->pdev->dev,
				"UE: %s bit set\n", ue_status_low_desc[i]);
		}
	}
	if (ue_status_hi) {
		for (i = 0; ue_status_hi; ue_status_hi >>= 1, i++) {
			if (ue_status_hi & 1)
				dev_err(&adapter->pdev->dev,
				"UE: %s bit set\n", ue_status_hi_desc[i]);
		}
	}

}

2018 2019 2020 2021
static void be_worker(struct work_struct *work)
{
	struct be_adapter *adapter =
		container_of(work, struct be_adapter, work.work);
2022 2023
	struct be_rx_obj *rxo;
	int i;
2024

2025 2026 2027
	if (!adapter->ue_detected && !lancer_chip(adapter))
		be_detect_dump_ue(adapter);

2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
	/* when interrupts are not yet enabled, just reap any pending
	* mcc completions */
	if (!netif_running(adapter->netdev)) {
		int mcc_compl, status = 0;

		mcc_compl = be_process_mcc(adapter, &status);

		if (mcc_compl) {
			struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
			be_cq_notify(adapter, mcc_obj->cq.id, false, mcc_compl);
		}
2039

2040 2041 2042
		goto reschedule;
	}

S
Selvin Xavier 已提交
2043 2044 2045 2046 2047 2048 2049
	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);
	}
2050

2051 2052 2053 2054 2055
	for_all_rx_queues(adapter, rxo, i) {
		be_rx_eqd_update(adapter, rxo);

		if (rxo->rx_post_starved) {
			rxo->rx_post_starved = false;
2056
			be_post_rx_frags(rxo, GFP_KERNEL);
2057
		}
2058 2059
	}

2060
reschedule:
2061
	adapter->work_counter++;
2062 2063 2064
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
}

2065 2066
static void be_msix_disable(struct be_adapter *adapter)
{
2067
	if (msix_enabled(adapter)) {
2068
		pci_disable_msix(adapter->pdev);
2069
		adapter->num_msix_vec = 0;
2070 2071 2072
	}
}

S
Sathya Perla 已提交
2073 2074
static void be_msix_enable(struct be_adapter *adapter)
{
2075
#define BE_MIN_MSIX_VECTORS	(1 + 1) /* Rx + Tx */
2076
	int i, status, num_vec;
S
Sathya Perla 已提交
2077

2078
	num_vec = be_num_rxqs_want(adapter) + 1;
2079

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

2083
	status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
2084 2085 2086
	if (status == 0) {
		goto done;
	} else if (status >= BE_MIN_MSIX_VECTORS) {
2087
		num_vec = status;
2088
		if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
2089
				num_vec) == 0)
2090 2091 2092 2093
			goto done;
	}
	return;
done:
2094 2095
	adapter->num_msix_vec = num_vec;
	return;
S
Sathya Perla 已提交
2096 2097
}

2098
static int be_sriov_enable(struct be_adapter *adapter)
2099
{
2100
	be_check_sriov_fn_type(adapter);
2101
#ifdef CONFIG_PCI_IOV
2102
	if (be_physfn(adapter) && num_vfs) {
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
		int status, pos;
		u16 nvfs;

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

		if (num_vfs > nvfs) {
			dev_info(&adapter->pdev->dev,
					"Device supports %d VFs and not %d\n",
					nvfs, num_vfs);
			num_vfs = nvfs;
		}
2117

2118 2119
		status = pci_enable_sriov(adapter->pdev, num_vfs);
		adapter->sriov_enabled = status ? false : true;
2120 2121 2122 2123 2124 2125 2126 2127

		if (adapter->sriov_enabled) {
			adapter->vf_cfg = kcalloc(num_vfs,
						sizeof(struct be_vf_cfg),
						GFP_KERNEL);
			if (!adapter->vf_cfg)
				return -ENOMEM;
		}
2128 2129
	}
#endif
2130
	return 0;
2131 2132 2133 2134 2135 2136 2137
}

static void be_sriov_disable(struct be_adapter *adapter)
{
#ifdef CONFIG_PCI_IOV
	if (adapter->sriov_enabled) {
		pci_disable_sriov(adapter->pdev);
2138
		kfree(adapter->vf_cfg);
2139 2140 2141 2142 2143
		adapter->sriov_enabled = false;
	}
#endif
}

2144 2145
static inline int be_msix_vec_get(struct be_adapter *adapter,
					struct be_eq_obj *eq_obj)
S
Sathya Perla 已提交
2146
{
2147
	return adapter->msix_entries[eq_obj->eq_idx].vector;
S
Sathya Perla 已提交
2148 2149
}

2150 2151
static int be_request_irq(struct be_adapter *adapter,
		struct be_eq_obj *eq_obj,
2152
		void *handler, char *desc, void *context)
S
Sathya Perla 已提交
2153 2154
{
	struct net_device *netdev = adapter->netdev;
2155 2156 2157
	int vec;

	sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
2158
	vec = be_msix_vec_get(adapter, eq_obj);
2159
	return request_irq(vec, handler, 0, eq_obj->desc, context);
2160 2161
}

2162 2163
static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj,
			void *context)
2164
{
2165
	int vec = be_msix_vec_get(adapter, eq_obj);
2166
	free_irq(vec, context);
2167
}
S
Sathya Perla 已提交
2168

2169 2170
static int be_msix_register(struct be_adapter *adapter)
{
2171 2172 2173
	struct be_rx_obj *rxo;
	int status, i;
	char qname[10];
2174

2175 2176
	status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx",
				adapter);
S
Sathya Perla 已提交
2177 2178 2179
	if (status)
		goto err;

2180 2181 2182 2183 2184 2185 2186
	for_all_rx_queues(adapter, rxo, i) {
		sprintf(qname, "rxq%d", i);
		status = be_request_irq(adapter, &rxo->rx_eq, be_msix_rx,
				qname, rxo);
		if (status)
			goto err_msix;
	}
2187

S
Sathya Perla 已提交
2188
	return 0;
2189

2190 2191 2192 2193 2194 2195
err_msix:
	be_free_irq(adapter, &adapter->tx_eq, adapter);

	for (i--, rxo = &adapter->rx_obj[i]; i >= 0; i--, rxo--)
		be_free_irq(adapter, &rxo->rx_eq, rxo);

S
Sathya Perla 已提交
2196 2197 2198
err:
	dev_warn(&adapter->pdev->dev,
		"MSIX Request IRQ failed - err %d\n", status);
2199
	be_msix_disable(adapter);
S
Sathya Perla 已提交
2200 2201 2202 2203 2204 2205 2206 2207
	return status;
}

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

2208
	if (msix_enabled(adapter)) {
S
Sathya Perla 已提交
2209 2210 2211
		status = be_msix_register(adapter);
		if (status == 0)
			goto done;
2212 2213 2214
		/* INTx is not supported for VF */
		if (!be_physfn(adapter))
			return status;
S
Sathya Perla 已提交
2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
	}

	/* 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;
2234 2235
	struct be_rx_obj *rxo;
	int i;
S
Sathya Perla 已提交
2236 2237 2238 2239 2240

	if (!adapter->isr_registered)
		return;

	/* INTx */
2241
	if (!msix_enabled(adapter)) {
S
Sathya Perla 已提交
2242 2243 2244 2245 2246
		free_irq(netdev->irq, adapter);
		goto done;
	}

	/* MSIx */
2247 2248 2249 2250 2251
	be_free_irq(adapter, &adapter->tx_eq, adapter);

	for_all_rx_queues(adapter, rxo, i)
		be_free_irq(adapter, &rxo->rx_eq, rxo);

S
Sathya Perla 已提交
2252 2253 2254 2255
done:
	adapter->isr_registered = false;
}

2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
static void be_rx_queues_clear(struct be_adapter *adapter)
{
	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);
			be_rx_q_clean(adapter, rxo);
		}

		/* Clear any residual events */
		q = &rxo->rx_eq.q;
		if (q->created)
			be_eq_clean(adapter, &rxo->rx_eq);
	}
}

2281 2282 2283
static int be_close(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
2284
	struct be_rx_obj *rxo;
2285
	struct be_tx_obj *txo;
2286
	struct be_eq_obj *tx_eq = &adapter->tx_eq;
2287
	int vec, i;
2288 2289 2290

	be_async_mcc_disable(adapter);

2291 2292
	if (!lancer_chip(adapter))
		be_intr_set(adapter, false);
2293

2294 2295 2296 2297 2298 2299 2300 2301 2302
	for_all_rx_queues(adapter, rxo, i)
		napi_disable(&rxo->rx_eq.napi);

	napi_disable(&tx_eq->napi);

	if (lancer_chip(adapter)) {
		be_cq_notify(adapter, adapter->mcc_obj.cq.id, false, 0);
		for_all_rx_queues(adapter, rxo, i)
			 be_cq_notify(adapter, rxo->cq.id, false, 0);
2303 2304
		for_all_tx_queues(adapter, txo, i)
			 be_cq_notify(adapter, txo->cq.id, false, 0);
2305 2306
	}

2307
	if (msix_enabled(adapter)) {
2308
		vec = be_msix_vec_get(adapter, tx_eq);
2309
		synchronize_irq(vec);
2310 2311

		for_all_rx_queues(adapter, rxo, i) {
2312
			vec = be_msix_vec_get(adapter, &rxo->rx_eq);
2313 2314
			synchronize_irq(vec);
		}
2315 2316 2317 2318 2319 2320 2321 2322
	} else {
		synchronize_irq(netdev->irq);
	}
	be_irq_unregister(adapter);

	/* Wait for all pending tx completions to arrive so that
	 * all tx skbs are freed.
	 */
2323 2324
	for_all_tx_queues(adapter, txo, i)
		be_tx_compl_clean(adapter, txo);
2325

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359
	be_rx_queues_clear(adapter);
	return 0;
}

static int be_rx_queues_setup(struct be_adapter *adapter)
{
	struct be_rx_obj *rxo;
	int rc, i;
	u8 rsstable[MAX_RSS_QS];

	for_all_rx_queues(adapter, rxo, i) {
		rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
			rx_frag_size, BE_MAX_JUMBO_FRAME_SIZE,
			adapter->if_handle,
			(i > 0) ? 1 : 0/* rss enable */, &rxo->rss_id);
		if (rc)
			return rc;
	}

	if (be_multi_rxq(adapter)) {
		for_all_rss_queues(adapter, rxo, i)
			rsstable[i] = rxo->rss_id;

		rc = be_cmd_rss_config(adapter, rsstable,
			adapter->num_rx_qs - 1);
		if (rc)
			return rc;
	}

	/* First time posting */
	for_all_rx_queues(adapter, rxo, i) {
		be_post_rx_frags(rxo, GFP_KERNEL);
		napi_enable(&rxo->rx_eq.napi);
	}
2360 2361 2362
	return 0;
}

S
Sathya Perla 已提交
2363 2364 2365 2366
static int be_open(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	struct be_eq_obj *tx_eq = &adapter->tx_eq;
2367 2368
	struct be_rx_obj *rxo;
	int status, i;
2369

2370 2371 2372 2373
	status = be_rx_queues_setup(adapter);
	if (status)
		goto err;

2374 2375 2376 2377
	napi_enable(&tx_eq->napi);

	be_irq_register(adapter);

2378 2379
	if (!lancer_chip(adapter))
		be_intr_set(adapter, true);
2380 2381

	/* The evt queues are created in unarmed state; arm them */
2382 2383 2384 2385
	for_all_rx_queues(adapter, rxo, i) {
		be_eq_notify(adapter, rxo->rx_eq.q.id, true, false, 0);
		be_cq_notify(adapter, rxo->cq.id, true, 0);
	}
2386
	be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
2387

2388 2389 2390
	/* Now that interrupts are on we can process async mcc */
	be_async_mcc_enable(adapter);

2391 2392 2393 2394
	return 0;
err:
	be_close(adapter->netdev);
	return -EIO;
2395 2396
}

2397 2398 2399 2400 2401 2402 2403 2404 2405
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 已提交
2406 2407
	cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
				    GFP_KERNEL);
2408 2409 2410 2411 2412 2413 2414 2415 2416
	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,
2417
				"Could not enable Wake-on-lan\n");
I
Ivan Vecera 已提交
2418 2419
			dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
					  cmd.dma);
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
			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 已提交
2432
	dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2433 2434 2435
	return status;
}

2436 2437 2438 2439 2440 2441 2442 2443
/*
 * 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)
{
2444
	u32 vf;
2445
	int status = 0;
2446 2447 2448 2449 2450 2451 2452
	u8 mac[ETH_ALEN];

	be_vf_eth_addr_generate(adapter, mac);

	for (vf = 0; vf < num_vfs; vf++) {
		status = be_cmd_pmac_add(adapter, mac,
					adapter->vf_cfg[vf].vf_if_handle,
2453 2454
					&adapter->vf_cfg[vf].vf_pmac_id,
					vf + 1);
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
		if (status)
			dev_err(&adapter->pdev->dev,
				"Mac address add failed for VF %d\n", vf);
		else
			memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);

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

2466
static void be_vf_clear(struct be_adapter *adapter)
2467 2468 2469 2470 2471 2472 2473
{
	u32 vf;

	for (vf = 0; vf < num_vfs; vf++) {
		if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
			be_cmd_pmac_del(adapter,
					adapter->vf_cfg[vf].vf_if_handle,
2474
					adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
2475
	}
2476 2477 2478 2479 2480

	for (vf = 0; vf < num_vfs; vf++)
		if (adapter->vf_cfg[vf].vf_if_handle)
			be_cmd_if_destroy(adapter,
				adapter->vf_cfg[vf].vf_if_handle, vf + 1);
2481 2482
}

2483 2484 2485
static int be_clear(struct be_adapter *adapter)
{
	if (be_physfn(adapter) && adapter->sriov_enabled)
2486 2487 2488
		be_vf_clear(adapter);

	be_cmd_if_destroy(adapter, adapter->if_handle,  0);
2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502

	be_mcc_queues_destroy(adapter);
	be_rx_queues_destroy(adapter);
	be_tx_queues_destroy(adapter);
	adapter->eq_next_idx = 0;

	adapter->be3_native = false;
	adapter->promiscuous = false;

	/* tell fw we're done with firing cmds */
	be_cmd_fw_clean(adapter);
	return 0;
}

2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
static int be_vf_setup(struct be_adapter *adapter)
{
	u32 cap_flags, en_flags, vf;
	u16 lnk_speed;
	int status;

	cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST;
	for (vf = 0; vf < num_vfs; vf++) {
		status = be_cmd_if_create(adapter, cap_flags, en_flags, NULL,
					&adapter->vf_cfg[vf].vf_if_handle,
					NULL, vf+1);
		if (status)
			goto err;
		adapter->vf_cfg[vf].vf_pmac_id = BE_INVALID_PMAC_ID;
	}

	if (!lancer_chip(adapter)) {
		status = be_vf_eth_addr_config(adapter);
		if (status)
			goto err;
	}

	for (vf = 0; vf < num_vfs; vf++) {
		status = be_cmd_link_status_query(adapter, NULL, &lnk_speed,
				vf + 1);
		if (status)
			goto err;
		adapter->vf_cfg[vf].vf_tx_rate = lnk_speed * 10;
	}
	return 0;
err:
	return status;
}

2537 2538 2539
static int be_setup(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
2540
	u32 cap_flags, en_flags;
2541
	u32 tx_fc, rx_fc;
S
Sathya Perla 已提交
2542
	int status;
2543 2544
	u8 mac[ETH_ALEN];

2545 2546 2547
	/* Allow all priorities by default. A GRP5 evt may modify this */
	adapter->vlan_prio_bmap = 0xff;
	adapter->link_speed = -1;
S
Sathya Perla 已提交
2548

2549
	be_cmd_req_native_mode(adapter);
2550

2551
	status = be_tx_queues_create(adapter);
S
Sathya Perla 已提交
2552
	if (status != 0)
2553
		goto err;
S
Sathya Perla 已提交
2554

2555
	status = be_rx_queues_create(adapter);
S
Sathya Perla 已提交
2556
	if (status != 0)
2557
		goto err;
S
Sathya Perla 已提交
2558

2559
	status = be_mcc_queues_create(adapter);
S
Sathya Perla 已提交
2560
	if (status != 0)
2561
		goto err;
S
Sathya Perla 已提交
2562

2563 2564 2565 2566 2567 2568 2569
	memset(mac, 0, ETH_ALEN);
	status = be_cmd_mac_addr_query(adapter, mac, MAC_ADDRESS_TYPE_NETWORK,
			true /*permanent */, 0);
	if (status)
		return status;
	memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
	memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2570

2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
	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 |
			BE_IF_FLAGS_PROMISCUOUS;
	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,
			&adapter->pmac_id, 0);
2582
	if (status != 0)
2583
		goto err;
S
Sathya Perla 已提交
2584

2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
	/* For BEx, the VF's permanent mac queried from card is incorrect.
	 * Query the mac configued by the PF using if_handle
	 */
	if (!be_physfn(adapter) && !lancer_chip(adapter)) {
		status = be_cmd_mac_addr_query(adapter, mac,
			MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
		if (!status) {
			memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
			memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
		}
	}
2596

2597
	be_cmd_get_fw_ver(adapter, adapter->fw_ver, NULL);
2598

2599 2600 2601
	status = be_vid_config(adapter, false, 0);
	if (status)
		goto err;
2602

2603
	be_set_rx_mode(adapter->netdev);
2604

2605 2606 2607 2608 2609 2610 2611 2612 2613
	status = be_cmd_get_flow_control(adapter, &tx_fc, &rx_fc);
	if (status)
		goto err;
	if (rx_fc != adapter->rx_fc || tx_fc != adapter->tx_fc) {
		status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
					adapter->rx_fc);
		if (status)
			goto err;
	}
2614

2615
	pcie_set_readrq(adapter->pdev, 4096);
2616

2617 2618 2619 2620 2621 2622 2623
	if (be_physfn(adapter) && adapter->sriov_enabled) {
		status = be_vf_setup(adapter);
		if (status)
			goto err;
	}

	return 0;
2624 2625 2626 2627
err:
	be_clear(adapter);
	return status;
}
S
Sathya Perla 已提交
2628

2629
#define FW_FILE_HDR_SIGN 	"ServerEngines Corp. "
2630
static bool be_flash_redboot(struct be_adapter *adapter,
2631 2632
			const u8 *p, u32 img_start, int image_size,
			int hdr_size)
2633 2634 2635 2636
{
	u32 crc_offset;
	u8 flashed_crc[4];
	int status;
2637 2638 2639

	crc_offset = hdr_size + img_start + image_size - 4;

2640
	p += crc_offset;
2641 2642

	status = be_cmd_get_flash_crc(adapter, flashed_crc,
2643
			(image_size - 4));
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
	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;
}

2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671
static bool phy_flashing_required(struct be_adapter *adapter)
{
	int status = 0;
	struct be_phy_info phy_info;

	status = be_cmd_get_phy_info(adapter, &phy_info);
	if (status)
		return false;
	if ((phy_info.phy_type == TN_8022) &&
		(phy_info.interface_type == PHY_TYPE_BASET_10GB)) {
		return true;
	}
	return false;
}

2672
static int be_flash_data(struct be_adapter *adapter,
2673
			const struct firmware *fw,
2674 2675
			struct be_dma_mem *flash_cmd, int num_of_images)

2676
{
2677 2678
	int status = 0, i, filehdr_size = 0;
	u32 total_bytes = 0, flash_op;
2679 2680 2681
	int num_bytes;
	const u8 *p = fw->data;
	struct be_cmd_write_flashrom *req = flash_cmd->va;
J
Joe Perches 已提交
2682
	const struct flash_comp *pflashcomp;
2683
	int num_comp;
2684

2685
	static const struct flash_comp gen3_flash_types[10] = {
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
		{ 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,
2701 2702
			FLASH_IMAGE_MAX_SIZE_g3},
		{ FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2703 2704 2705
			FLASH_NCSI_IMAGE_MAX_SIZE_g3},
		{ FLASH_PHY_FW_START_g3, IMG_TYPE_PHY_FW,
			FLASH_PHY_FW_IMAGE_MAX_SIZE_g3}
2706
	};
J
Joe Perches 已提交
2707
	static const struct flash_comp gen2_flash_types[8] = {
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
		{ 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 已提交
2729
		num_comp = ARRAY_SIZE(gen3_flash_types);
2730 2731 2732
	} else {
		pflashcomp = gen2_flash_types;
		filehdr_size = sizeof(struct flash_file_hdr_g2);
J
Joe Perches 已提交
2733
		num_comp = ARRAY_SIZE(gen2_flash_types);
2734
	}
2735 2736 2737 2738
	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;
2739 2740 2741 2742
		if (pflashcomp[i].optype == IMG_TYPE_PHY_FW) {
			if (!phy_flashing_required(adapter))
				continue;
		}
2743 2744
		if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
			(!be_flash_redboot(adapter, fw->data,
2745 2746
			pflashcomp[i].offset, pflashcomp[i].size, filehdr_size +
			(num_of_images * sizeof(struct image_hdr)))))
2747 2748 2749 2750
			continue;
		p = fw->data;
		p += filehdr_size + pflashcomp[i].offset
			+ (num_of_images * sizeof(struct image_hdr));
2751 2752 2753
		if (p + pflashcomp[i].size > fw->data + fw->size)
			return -1;
		total_bytes = pflashcomp[i].size;
2754 2755 2756 2757 2758 2759
		while (total_bytes) {
			if (total_bytes > 32*1024)
				num_bytes = 32*1024;
			else
				num_bytes = total_bytes;
			total_bytes -= num_bytes;
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
			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;
			}
2771 2772 2773 2774 2775
			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) {
2776 2777 2778 2779
				if ((status == ILLEGAL_IOCTL_REQ) &&
					(pflashcomp[i].optype ==
						IMG_TYPE_PHY_FW))
					break;
2780 2781 2782 2783
				dev_err(&adapter->pdev->dev,
					"cmd to write to flash rom failed.\n");
				return -1;
			}
2784 2785 2786 2787 2788
		}
	}
	return 0;
}

2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
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;
}

2801 2802
static int lancer_fw_download(struct be_adapter *adapter,
				const struct firmware *fw)
2803
{
2804 2805
#define LANCER_FW_DOWNLOAD_CHUNK      (32 * 1024)
#define LANCER_FW_DOWNLOAD_LOCATION   "/prg"
2806
	struct be_dma_mem flash_cmd;
2807 2808 2809 2810 2811 2812 2813 2814
	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;
2815

2816
	if (!IS_ALIGNED(fw->size, sizeof(u32))) {
2817
		dev_err(&adapter->pdev->dev,
2818 2819 2820 2821
			"FW Image not properly aligned. "
			"Length must be 4 byte aligned.\n");
		status = -EINVAL;
		goto lancer_fw_exit;
2822 2823
	}

2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
	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;
	}
2834

2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
	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;
2888 2889

	p = fw->data;
2890
	fhdr = (struct flash_file_hdr_g2 *) p;
2891 2892

	flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
I
Ivan Vecera 已提交
2893 2894
	flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
					  &flash_cmd.dma, GFP_KERNEL);
2895 2896 2897 2898
	if (!flash_cmd.va) {
		status = -ENOMEM;
		dev_err(&adapter->pdev->dev,
			"Memory allocation failure while flashing\n");
2899
		goto be_fw_exit;
2900 2901
	}

2902 2903 2904
	if ((adapter->generation == BE_GEN3) &&
			(get_ufigen_type(fhdr) == BE_GEN3)) {
		fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
2905 2906
		num_imgs = le32_to_cpu(fhdr3->num_imgs);
		for (i = 0; i < num_imgs; i++) {
2907 2908
			img_hdr_ptr = (struct image_hdr *) (fw->data +
					(sizeof(struct flash_file_hdr_g3) +
2909 2910 2911 2912
					 i * sizeof(struct image_hdr)));
			if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
				status = be_flash_data(adapter, fw, &flash_cmd,
							num_imgs);
2913 2914 2915 2916 2917 2918 2919 2920
		}
	} 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;
2921 2922
	}

I
Ivan Vecera 已提交
2923 2924
	dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
			  flash_cmd.dma);
2925 2926
	if (status) {
		dev_err(&adapter->pdev->dev, "Firmware load error\n");
2927
		goto be_fw_exit;
2928 2929
	}

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

2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957
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);

2958 2959 2960 2961 2962
fw_exit:
	release_firmware(fw);
	return status;
}

S
Sathya Perla 已提交
2963 2964 2965 2966
static struct net_device_ops be_netdev_ops = {
	.ndo_open		= be_open,
	.ndo_stop		= be_close,
	.ndo_start_xmit		= be_xmit,
2967
	.ndo_set_rx_mode	= be_set_rx_mode,
S
Sathya Perla 已提交
2968 2969
	.ndo_set_mac_address	= be_mac_addr_set,
	.ndo_change_mtu		= be_change_mtu,
2970
	.ndo_get_stats64	= be_get_stats64,
S
Sathya Perla 已提交
2971 2972 2973
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_vlan_rx_add_vid	= be_vlan_add_vid,
	.ndo_vlan_rx_kill_vid	= be_vlan_rem_vid,
2974
	.ndo_set_vf_mac		= be_set_vf_mac,
2975
	.ndo_set_vf_vlan	= be_set_vf_vlan,
2976
	.ndo_set_vf_tx_rate	= be_set_vf_tx_rate,
2977
	.ndo_get_vf_config	= be_get_vf_config
S
Sathya Perla 已提交
2978 2979 2980 2981 2982
};

static void be_netdev_init(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
2983 2984
	struct be_rx_obj *rxo;
	int i;
S
Sathya Perla 已提交
2985

2986
	netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2987 2988 2989 2990
		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;
2991 2992

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

2995
	netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2996
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
2997

S
Sathya Perla 已提交
2998 2999
	netdev->flags |= IFF_MULTICAST;

3000 3001
	netif_set_gso_max_size(netdev, 65535);

S
Sathya Perla 已提交
3002 3003 3004 3005
	BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);

	SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);

3006 3007 3008 3009
	for_all_rx_queues(adapter, rxo, i)
		netif_napi_add(netdev, &rxo->rx_eq.napi, be_poll_rx,
				BE_NAPI_WEIGHT);

3010
	netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
S
Sathya Perla 已提交
3011 3012 3013 3014 3015
		BE_NAPI_WEIGHT);
}

static void be_unmap_pci_bars(struct be_adapter *adapter)
{
3016 3017 3018 3019
	if (adapter->csr)
		iounmap(adapter->csr);
	if (adapter->db)
		iounmap(adapter->db);
S
Sathya Perla 已提交
3020 3021 3022 3023 3024
}

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

3027 3028 3029 3030 3031 3032 3033 3034 3035
	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;
	}

3036 3037 3038 3039 3040 3041 3042
	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 已提交
3043

3044 3045 3046 3047 3048 3049 3050 3051 3052 3053
	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 已提交
3054 3055
	if (addr == NULL)
		goto pci_map_err;
3056 3057
	adapter->db = addr;

S
Sathya Perla 已提交
3058 3059 3060 3061 3062 3063 3064 3065 3066
	return 0;
pci_map_err:
	be_unmap_pci_bars(adapter);
	return -ENOMEM;
}


static void be_ctrl_cleanup(struct be_adapter *adapter)
{
3067
	struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
S
Sathya Perla 已提交
3068 3069 3070 3071

	be_unmap_pci_bars(adapter);

	if (mem->va)
I
Ivan Vecera 已提交
3072 3073
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
3074

3075
	mem = &adapter->rx_filter;
3076
	if (mem->va)
I
Ivan Vecera 已提交
3077 3078
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
S
Sathya Perla 已提交
3079 3080 3081 3082
}

static int be_ctrl_init(struct be_adapter *adapter)
{
3083 3084
	struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
	struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
3085
	struct be_dma_mem *rx_filter = &adapter->rx_filter;
S
Sathya Perla 已提交
3086 3087 3088 3089
	int status;

	status = be_map_pci_bars(adapter);
	if (status)
3090
		goto done;
S
Sathya Perla 已提交
3091 3092

	mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
I
Ivan Vecera 已提交
3093 3094 3095 3096
	mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
						mbox_mem_alloc->size,
						&mbox_mem_alloc->dma,
						GFP_KERNEL);
S
Sathya Perla 已提交
3097
	if (!mbox_mem_alloc->va) {
3098 3099
		status = -ENOMEM;
		goto unmap_pci_bars;
S
Sathya Perla 已提交
3100 3101 3102 3103 3104
	}
	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));
3105

3106 3107 3108 3109
	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) {
3110 3111 3112
		status = -ENOMEM;
		goto free_mbox;
	}
3113
	memset(rx_filter->va, 0, rx_filter->size);
3114

3115
	mutex_init(&adapter->mbox_lock);
3116 3117
	spin_lock_init(&adapter->mcc_lock);
	spin_lock_init(&adapter->mcc_cq_lock);
3118

3119
	init_completion(&adapter->flash_compl);
3120
	pci_save_state(adapter->pdev);
S
Sathya Perla 已提交
3121
	return 0;
3122 3123

free_mbox:
I
Ivan Vecera 已提交
3124 3125
	dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
			  mbox_mem_alloc->va, mbox_mem_alloc->dma);
3126 3127 3128 3129 3130 3131

unmap_pci_bars:
	be_unmap_pci_bars(adapter);

done:
	return status;
S
Sathya Perla 已提交
3132 3133 3134 3135
}

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

	if (cmd->va)
I
Ivan Vecera 已提交
3139 3140
		dma_free_coherent(&adapter->pdev->dev, cmd->size,
				  cmd->va, cmd->dma);
S
Sathya Perla 已提交
3141 3142 3143 3144
}

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

S
Selvin Xavier 已提交
3147
	if (adapter->generation == BE_GEN2) {
3148
		cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
S
Selvin Xavier 已提交
3149 3150 3151 3152 3153 3154
	} 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 已提交
3155 3156
	cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
				     GFP_KERNEL);
S
Sathya Perla 已提交
3157 3158
	if (cmd->va == NULL)
		return -1;
3159
	memset(cmd->va, 0, cmd->size);
S
Sathya Perla 已提交
3160 3161 3162 3163 3164 3165
	return 0;
}

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

S
Sathya Perla 已提交
3167 3168 3169
	if (!adapter)
		return;

3170 3171
	cancel_delayed_work_sync(&adapter->work);

S
Sathya Perla 已提交
3172 3173
	unregister_netdev(adapter->netdev);

3174 3175
	be_clear(adapter);

S
Sathya Perla 已提交
3176 3177 3178 3179
	be_stats_cleanup(adapter);

	be_ctrl_cleanup(adapter);

3180 3181
	be_sriov_disable(adapter);

3182
	be_msix_disable(adapter);
S
Sathya Perla 已提交
3183 3184 3185 3186 3187 3188 3189 3190

	pci_set_drvdata(pdev, NULL);
	pci_release_regions(pdev);
	pci_disable_device(pdev);

	free_netdev(adapter->netdev);
}

3191
static int be_get_config(struct be_adapter *adapter)
S
Sathya Perla 已提交
3192 3193 3194
{
	int status;

3195 3196
	status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
			&adapter->function_mode, &adapter->function_caps);
3197 3198 3199
	if (status)
		return status;

3200
	if (adapter->function_mode & FLEX10_MODE)
3201 3202 3203 3204
		adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/4;
	else
		adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;

3205 3206 3207 3208
	status = be_cmd_get_cntl_attributes(adapter);
	if (status)
		return status;

3209
	return 0;
S
Sathya Perla 已提交
3210 3211
}

3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
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:
		adapter->generation = BE_GEN3;
		break;
	case OC_DEVICE_ID3:
3227
	case OC_DEVICE_ID4:
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246
		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;
}

3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294
static int lancer_wait_ready(struct be_adapter *adapter)
{
#define SLIPORT_READY_TIMEOUT 500
	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;

		msleep(20);
	}

	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;
}

S
Sathya Perla 已提交
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
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);

3311
	netdev = alloc_etherdev_mq(sizeof(struct be_adapter), MAX_TX_QS);
S
Sathya Perla 已提交
3312 3313 3314 3315 3316 3317 3318
	if (netdev == NULL) {
		status = -ENOMEM;
		goto rel_reg;
	}
	adapter = netdev_priv(netdev);
	adapter->pdev = pdev;
	pci_set_drvdata(pdev, adapter);
3319 3320

	status = be_dev_family_check(adapter);
3321
	if (status)
3322 3323
		goto free_netdev;

S
Sathya Perla 已提交
3324
	adapter->netdev = netdev;
3325
	SET_NETDEV_DEV(netdev, &pdev->dev);
S
Sathya Perla 已提交
3326

I
Ivan Vecera 已提交
3327
	status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
S
Sathya Perla 已提交
3328 3329 3330
	if (!status) {
		netdev->features |= NETIF_F_HIGHDMA;
	} else {
I
Ivan Vecera 已提交
3331
		status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
S
Sathya Perla 已提交
3332 3333 3334 3335 3336 3337
		if (status) {
			dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
			goto free_netdev;
		}
	}

3338 3339 3340
	status = be_sriov_enable(adapter);
	if (status)
		goto free_netdev;
3341

S
Sathya Perla 已提交
3342 3343
	status = be_ctrl_init(adapter);
	if (status)
3344
		goto disable_sriov;
S
Sathya Perla 已提交
3345

3346 3347 3348 3349
	if (lancer_chip(adapter)) {
		status = lancer_test_and_set_rdy_state(adapter);
		if (status) {
			dev_err(&pdev->dev, "Adapter in non recoverable error\n");
3350
			goto ctrl_clean;
3351 3352 3353
		}
	}

3354
	/* sync up with fw's ready state */
3355 3356 3357 3358 3359
	if (be_physfn(adapter)) {
		status = be_cmd_POST(adapter);
		if (status)
			goto ctrl_clean;
	}
S
Sathya Perla 已提交
3360

3361 3362
	/* tell fw we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
S
Sathya Perla 已提交
3363
	if (status)
3364 3365
		goto ctrl_clean;

3366 3367 3368
	status = be_cmd_reset_function(adapter);
	if (status)
		goto ctrl_clean;
3369

3370 3371 3372 3373 3374
	status = be_stats_init(adapter);
	if (status)
		goto ctrl_clean;

	status = be_get_config(adapter);
S
Sathya Perla 已提交
3375 3376 3377
	if (status)
		goto stats_clean;

3378 3379 3380 3381 3382 3383
	/* 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);

3384 3385
	be_msix_enable(adapter);

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

3389 3390
	status = be_setup(adapter);
	if (status)
3391
		goto msix_disable;
3392

3393
	be_netdev_init(netdev);
S
Sathya Perla 已提交
3394 3395
	status = register_netdev(netdev);
	if (status != 0)
3396
		goto unsetup;
S
Sathya Perla 已提交
3397

3398
	dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
3399

3400
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
S
Sathya Perla 已提交
3401 3402
	return 0;

3403 3404
unsetup:
	be_clear(adapter);
3405 3406
msix_disable:
	be_msix_disable(adapter);
S
Sathya Perla 已提交
3407 3408 3409 3410
stats_clean:
	be_stats_cleanup(adapter);
ctrl_clean:
	be_ctrl_cleanup(adapter);
3411
disable_sriov:
3412
	be_sriov_disable(adapter);
3413
free_netdev:
3414
	free_netdev(netdev);
3415
	pci_set_drvdata(pdev, NULL);
S
Sathya Perla 已提交
3416 3417 3418 3419 3420
rel_reg:
	pci_release_regions(pdev);
disable_dev:
	pci_disable_device(pdev);
do_none:
3421
	dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
S
Sathya Perla 已提交
3422 3423 3424 3425 3426 3427 3428 3429
	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;

3430
	cancel_delayed_work_sync(&adapter->work);
3431 3432 3433
	if (adapter->wol)
		be_setup_wol(adapter, true);

S
Sathya Perla 已提交
3434 3435 3436 3437 3438 3439
	netif_device_detach(netdev);
	if (netif_running(netdev)) {
		rtnl_lock();
		be_close(netdev);
		rtnl_unlock();
	}
3440
	be_clear(adapter);
S
Sathya Perla 已提交
3441

3442
	be_msix_disable(adapter);
S
Sathya Perla 已提交
3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
	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);

3464
	be_msix_enable(adapter);
3465 3466 3467 3468 3469
	/* tell fw we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
	if (status)
		return status;

3470
	be_setup(adapter);
S
Sathya Perla 已提交
3471 3472 3473 3474 3475 3476
	if (netif_running(netdev)) {
		rtnl_lock();
		be_open(netdev);
		rtnl_unlock();
	}
	netif_device_attach(netdev);
3477 3478 3479

	if (adapter->wol)
		be_setup_wol(adapter, false);
3480 3481

	schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
S
Sathya Perla 已提交
3482 3483 3484
	return 0;
}

3485 3486 3487 3488 3489 3490 3491
/*
 * 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);

3492 3493
	if (!adapter)
		return;
3494

3495
	cancel_delayed_work_sync(&adapter->work);
3496

3497
	netif_device_detach(adapter->netdev);
3498 3499 3500 3501

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

3502 3503
	be_cmd_reset_function(adapter);

3504 3505 3506
	pci_disable_device(pdev);
}

3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
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;

	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 已提交
3594 3595 3596 3597 3598 3599
static struct pci_driver be_driver = {
	.name = DRV_NAME,
	.id_table = be_dev_ids,
	.probe = be_probe,
	.remove = be_remove,
	.suspend = be_suspend,
3600
	.resume = be_resume,
3601
	.shutdown = be_shutdown,
3602
	.err_handler = &be_eeh_handlers
S
Sathya Perla 已提交
3603 3604 3605 3606
};

static int __init be_init_module(void)
{
3607 3608
	if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
	    rx_frag_size != 2048) {
S
Sathya Perla 已提交
3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623
		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);