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

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

MODULE_VERSION(DRV_VER);
MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
30
MODULE_AUTHOR("Emulex Corporation");
S
Sathya Perla 已提交
31 32
MODULE_LICENSE("GPL");

33 34 35
/* num_vfs module param is obsolete.
 * Use sysfs method to enable/disable VFs.
 */
36 37 38
static unsigned int num_vfs;
module_param(num_vfs, uint, S_IRUGO);
MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
S
Sathya Perla 已提交
39

40 41 42 43
static ushort rx_frag_size = 2048;
module_param(rx_frag_size, ushort, S_IRUGO);
MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");

44
static const struct pci_device_id be_dev_ids[] = {
45
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
46
	{ PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
47 48
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
	{ PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
49
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
50
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
51
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
52
	{ PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
S
Sathya Perla 已提交
53 54 55
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, be_dev_ids);
56
/* UE Status Low CSR */
57
static const char * const ue_status_low_desc[] = {
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
	"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 ",
86 87 88 89
	"ERX2 ",
	"SPARE ",
	"JTAG ",
	"MPU_INTPEND "
90
};
91

92
/* UE Status High CSR */
93
static const char * const ue_status_hi_desc[] = {
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
	"LPCMEMHOST",
	"MGMT_MAC",
	"PCS0ONLINE",
	"MPU_IRAM",
	"PCS1ONLINE",
	"PCTL0",
	"PCTL1",
	"PMEM",
	"RR",
	"TXPB",
	"RXPP",
	"XAUI",
	"TXP",
	"ARM",
	"IPC",
	"HOST2",
	"HOST3",
	"HOST4",
	"HOST5",
	"HOST6",
	"HOST7",
115 116
	"ECRC",
	"Poison TLP",
117
	"NETC",
118 119 120 121 122 123 124
	"PERIPH",
	"LLTXULP",
	"D2P",
	"RCON",
	"LDMA",
	"LLTXP",
	"LLTXPB",
125 126
	"Unknown"
};
S
Sathya Perla 已提交
127 128 129 130

static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
{
	struct be_dma_mem *mem = &q->dma_mem;
131

132
	if (mem->va) {
I
Ivan Vecera 已提交
133 134
		dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
				  mem->dma);
135 136
		mem->va = NULL;
	}
S
Sathya Perla 已提交
137 138 139
}

static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
140
			  u16 len, u16 entry_size)
S
Sathya Perla 已提交
141 142 143 144 145 146 147
{
	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;
148 149
	mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
				      GFP_KERNEL);
S
Sathya Perla 已提交
150
	if (!mem->va)
S
Sathya Perla 已提交
151
		return -ENOMEM;
S
Sathya Perla 已提交
152 153 154
	return 0;
}

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

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

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

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

174 175 176 177 178 179 180 181
static void be_intr_set(struct be_adapter *adapter, bool enable)
{
	int status = 0;

	/* On lancer interrupts can't be controlled via this register */
	if (lancer_chip(adapter))
		return;

182
	if (be_check_error(adapter, BE_ERROR_EEH))
183 184 185 186 187 188 189
		return;

	status = be_cmd_intr_set(adapter, enable);
	if (status)
		be_reg_intr_set(adapter, enable);
}

190
static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
S
Sathya Perla 已提交
191 192
{
	u32 val = 0;
193

194 195 196
	if (be_check_error(adapter, BE_ERROR_HW))
		return;

S
Sathya Perla 已提交
197 198
	val |= qid & DB_RQ_RING_ID_MASK;
	val |= posted << DB_RQ_NUM_POSTED_SHIFT;
199 200

	wmb();
201
	iowrite32(val, adapter->db + DB_RQ_OFFSET);
S
Sathya Perla 已提交
202 203
}

V
Vasundhara Volam 已提交
204 205
static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
			  u16 posted)
S
Sathya Perla 已提交
206 207
{
	u32 val = 0;
208

209 210 211
	if (be_check_error(adapter, BE_ERROR_HW))
		return;

V
Vasundhara Volam 已提交
212
	val |= txo->q.id & DB_TXULP_RING_ID_MASK;
S
Sathya Perla 已提交
213
	val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
214 215

	wmb();
V
Vasundhara Volam 已提交
216
	iowrite32(val, adapter->db + txo->db_offset);
S
Sathya Perla 已提交
217 218
}

219
static void be_eq_notify(struct be_adapter *adapter, u16 qid,
220 221
			 bool arm, bool clear_int, u16 num_popped,
			 u32 eq_delay_mult_enc)
S
Sathya Perla 已提交
222 223
{
	u32 val = 0;
224

S
Sathya Perla 已提交
225
	val |= qid & DB_EQ_RING_ID_MASK;
226
	val |= ((qid & DB_EQ_RING_ID_EXT_MASK) << DB_EQ_RING_ID_EXT_MASK_SHIFT);
227

228
	if (be_check_error(adapter, BE_ERROR_HW))
229 230
		return;

S
Sathya Perla 已提交
231 232 233 234 235 236
	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;
237
	val |= eq_delay_mult_enc << DB_EQ_R2I_DLY_SHIFT;
238
	iowrite32(val, adapter->db + DB_EQ_OFFSET);
S
Sathya Perla 已提交
239 240
}

241
void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
S
Sathya Perla 已提交
242 243
{
	u32 val = 0;
244

S
Sathya Perla 已提交
245
	val |= qid & DB_CQ_RING_ID_MASK;
246 247
	val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
			DB_CQ_RING_ID_EXT_MASK_SHIFT);
248

249
	if (be_check_error(adapter, BE_ERROR_HW))
250 251
		return;

S
Sathya Perla 已提交
252 253 254
	if (arm)
		val |= 1 << DB_CQ_REARM_SHIFT;
	val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
255
	iowrite32(val, adapter->db + DB_CQ_OFFSET);
S
Sathya Perla 已提交
256 257 258 259 260
}

static int be_mac_addr_set(struct net_device *netdev, void *p)
{
	struct be_adapter *adapter = netdev_priv(netdev);
261
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
262
	struct sockaddr *addr = p;
263 264 265
	int status;
	u8 mac[ETH_ALEN];
	u32 old_pmac_id = adapter->pmac_id[0], curr_pmac_id = 0;
S
Sathya Perla 已提交
266

267 268 269
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

270 271 272 273 274 275
	/* Proceed further only if, User provided MAC is different
	 * from active MAC
	 */
	if (ether_addr_equal(addr->sa_data, netdev->dev_addr))
		return 0;

276 277 278 279
	/* if device is not running, copy MAC to netdev->dev_addr */
	if (!netif_running(netdev))
		goto done;

280 281 282 283 284
	/* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT
	 * privilege or if PF did not provision the new MAC address.
	 * On BE3, this cmd will always fail if the VF doesn't have the
	 * FILTMGMT privilege. This failure is OK, only if the PF programmed
	 * the MAC for the VF.
285
	 */
286 287 288 289 290 291 292 293 294 295 296
	status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
				 adapter->if_handle, &adapter->pmac_id[0], 0);
	if (!status) {
		curr_pmac_id = adapter->pmac_id[0];

		/* Delete the old programmed MAC. This call may fail if the
		 * old MAC was already deleted by the PF driver.
		 */
		if (adapter->pmac_id[0] != old_pmac_id)
			be_cmd_pmac_del(adapter, adapter->if_handle,
					old_pmac_id, 0);
297 298
	}

299 300
	/* Decide if the new MAC is successfully activated only after
	 * querying the FW
301
	 */
302 303
	status = be_cmd_get_active_mac(adapter, curr_pmac_id, mac,
				       adapter->if_handle, true, 0);
304
	if (status)
305
		goto err;
S
Sathya Perla 已提交
306

307 308 309
	/* The MAC change did not happen, either due to lack of privilege
	 * or PF didn't pre-provision.
	 */
310
	if (!ether_addr_equal(addr->sa_data, mac)) {
311 312 313
		status = -EPERM;
		goto err;
	}
314 315 316
done:
	ether_addr_copy(netdev->dev_addr, addr->sa_data);
	dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
317 318
	return 0;
err:
319
	dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data);
S
Sathya Perla 已提交
320 321 322
	return status;
}

323 324 325 326 327 328 329
/* BE2 supports only v0 cmd */
static void *hw_stats_from_cmd(struct be_adapter *adapter)
{
	if (BE2_chip(adapter)) {
		struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;

		return &cmd->hw_stats;
330
	} else if (BE3_chip(adapter)) {
331 332
		struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;

333 334 335 336
		return &cmd->hw_stats;
	} else {
		struct be_cmd_resp_get_stats_v2 *cmd = adapter->stats_cmd.va;

337 338 339 340 341 342 343 344 345 346 347
		return &cmd->hw_stats;
	}
}

/* BE2 supports only v0 cmd */
static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
{
	if (BE2_chip(adapter)) {
		struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);

		return &hw_stats->erx;
348
	} else if (BE3_chip(adapter)) {
349 350
		struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);

351 352 353 354
		return &hw_stats->erx;
	} else {
		struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);

355 356 357 358 359
		return &hw_stats->erx;
	}
}

static void populate_be_v0_stats(struct be_adapter *adapter)
360
{
361 362 363
	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;
364
	struct be_port_rxf_stats_v0 *port_stats =
365 366
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
367

368
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
369 370 371 372 373 374 375 376 377 378 379 380 381 382
	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;
383
	drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
384 385
	drvs->rx_dropped_header_too_small =
		port_stats->rx_dropped_header_too_small;
386 387 388
	drvs->rx_address_filtered =
					port_stats->rx_address_filtered +
					port_stats->rx_vlan_filtered;
389 390 391 392 393 394 395
	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)
396
		drvs->jabber_events = rxf_stats->port1_jabber_events;
397
	else
398
		drvs->jabber_events = rxf_stats->port0_jabber_events;
399 400 401 402
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
403 404
	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;
405 406 407
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

408
static void populate_be_v1_stats(struct be_adapter *adapter)
409
{
410 411 412
	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;
413
	struct be_port_rxf_stats_v1 *port_stats =
414 415
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;
416

417
	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
418 419
	drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
	drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
	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;
437
	drvs->rx_address_filtered = port_stats->rx_address_filtered;
438 439
	drvs->rx_alignment_symbol_errors =
		port_stats->rx_alignment_symbol_errors;
440
	drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
441 442
	drvs->tx_pauseframes = port_stats->tx_pauseframes;
	drvs->tx_controlframes = port_stats->tx_controlframes;
443
	drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
444 445 446 447 448
	drvs->jabber_events = port_stats->jabber_events;
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
449 450
	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;
451 452 453
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
static void populate_be_v2_stats(struct be_adapter *adapter)
{
	struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
	struct be_rxf_stats_v2 *rxf_stats = &hw_stats->rxf;
	struct be_port_rxf_stats_v2 *port_stats =
					&rxf_stats->port[adapter->port_num];
	struct be_drv_stats *drvs = &adapter->drv_stats;

	be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
	drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
	drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
	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;
	drvs->rx_address_filtered = port_stats->rx_address_filtered;
	drvs->rx_alignment_symbol_errors =
		port_stats->rx_alignment_symbol_errors;
	drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
	drvs->tx_pauseframes = port_stats->tx_pauseframes;
	drvs->tx_controlframes = port_stats->tx_controlframes;
	drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
	drvs->jabber_events = port_stats->jabber_events;
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
	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;
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
498
	if (be_roce_supported(adapter)) {
499 500 501 502 503 504 505
		drvs->rx_roce_bytes_lsd = port_stats->roce_bytes_received_lsd;
		drvs->rx_roce_bytes_msd = port_stats->roce_bytes_received_msd;
		drvs->rx_roce_frames = port_stats->roce_frames_received;
		drvs->roce_drops_crc = port_stats->roce_drops_crc;
		drvs->roce_drops_payload_len =
			port_stats->roce_drops_payload_len;
	}
506 507
}

S
Selvin Xavier 已提交
508 509 510
static void populate_lancer_stats(struct be_adapter *adapter)
{
	struct be_drv_stats *drvs = &adapter->drv_stats;
511
	struct lancer_pport_stats *pport_stats = pport_stats_from_cmd(adapter);
512 513 514 515 516

	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 已提交
517
	drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
518
	drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
S
Selvin Xavier 已提交
519 520 521 522 523 524 525 526 527 528 529 530
	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;
531 532 533
	drvs->rx_address_filtered =
					pport_stats->rx_address_filtered +
					pport_stats->rx_vlan_filtered;
534
	drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
S
Selvin Xavier 已提交
535
	drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
536 537
	drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
	drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
S
Selvin Xavier 已提交
538
	drvs->jabber_events = pport_stats->rx_jabbers;
539 540
	drvs->forwarded_packets = pport_stats->num_forwards_lo;
	drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
S
Selvin Xavier 已提交
541
	drvs->rx_drops_too_many_frags =
542
				pport_stats->rx_drops_too_many_frags_lo;
S
Selvin Xavier 已提交
543
}
544

545 546 547 548 549 550 551 552 553 554 555 556
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;
}

J
Jingoo Han 已提交
557
static void populate_erx_stats(struct be_adapter *adapter,
558
			       struct be_rx_obj *rxo, u32 erx_stat)
559 560 561 562 563 564 565 566 567 568 569
{
	if (!BEx_chip(adapter))
		rx_stats(rxo)->rx_drops_no_frags = erx_stat;
	else
		/* 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_stat);
}

570 571
void be_parse_stats(struct be_adapter *adapter)
{
572
	struct be_erx_stats_v2 *erx = be_erx_stats_from_cmd(adapter);
573 574
	struct be_rx_obj *rxo;
	int i;
575
	u32 erx_stat;
576

577 578
	if (lancer_chip(adapter)) {
		populate_lancer_stats(adapter);
S
Selvin Xavier 已提交
579
	} else {
580 581
		if (BE2_chip(adapter))
			populate_be_v0_stats(adapter);
582 583
		else if (BE3_chip(adapter))
			/* for BE3 */
584
			populate_be_v1_stats(adapter);
585 586
		else
			populate_be_v2_stats(adapter);
587

588
		/* erx_v2 is longer than v0, v1. use v2 for v0, v1 access */
589
		for_all_rx_queues(adapter, rxo, i) {
590 591
			erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
			populate_erx_stats(adapter, rxo, erx_stat);
592
		}
593
	}
594 595
}

596
static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
597
						struct rtnl_link_stats64 *stats)
S
Sathya Perla 已提交
598
{
599
	struct be_adapter *adapter = netdev_priv(netdev);
600
	struct be_drv_stats *drvs = &adapter->drv_stats;
601
	struct be_rx_obj *rxo;
602
	struct be_tx_obj *txo;
603 604
	u64 pkts, bytes;
	unsigned int start;
605
	int i;
S
Sathya Perla 已提交
606

607
	for_all_rx_queues(adapter, rxo, i) {
608
		const struct be_rx_stats *rx_stats = rx_stats(rxo);
609

610
		do {
611
			start = u64_stats_fetch_begin_irq(&rx_stats->sync);
612 613
			pkts = rx_stats(rxo)->rx_pkts;
			bytes = rx_stats(rxo)->rx_bytes;
614
		} while (u64_stats_fetch_retry_irq(&rx_stats->sync, start));
615 616 617 618 619
		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;
620 621
	}

622
	for_all_tx_queues(adapter, txo, i) {
623
		const struct be_tx_stats *tx_stats = tx_stats(txo);
624

625
		do {
626
			start = u64_stats_fetch_begin_irq(&tx_stats->sync);
627 628
			pkts = tx_stats(txo)->tx_pkts;
			bytes = tx_stats(txo)->tx_bytes;
629
		} while (u64_stats_fetch_retry_irq(&tx_stats->sync, start));
630 631
		stats->tx_packets += pkts;
		stats->tx_bytes += bytes;
632
	}
S
Sathya Perla 已提交
633 634

	/* bad pkts received */
635
	stats->rx_errors = drvs->rx_crc_errors +
636 637 638 639 640 641 642 643
		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 +
644
		drvs->rx_dropped_runt;
645

S
Sathya Perla 已提交
646
	/* detailed rx errors */
647
	stats->rx_length_errors = drvs->rx_in_range_errors +
648 649
		drvs->rx_out_range_errors +
		drvs->rx_frame_too_long;
650

651
	stats->rx_crc_errors = drvs->rx_crc_errors;
S
Sathya Perla 已提交
652 653

	/* frame alignment errors */
654
	stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
655

S
Sathya Perla 已提交
656 657
	/* receiver fifo overrun */
	/* drops_no_pbuf is no per i/f, it's per BE card */
658
	stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
659 660
				drvs->rx_input_fifo_overflow_drop +
				drvs->rx_drops_no_pbuf;
661
	return stats;
S
Sathya Perla 已提交
662 663
}

664
void be_link_status_update(struct be_adapter *adapter, u8 link_status)
S
Sathya Perla 已提交
665 666 667
{
	struct net_device *netdev = adapter->netdev;

668
	if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
669
		netif_carrier_off(netdev);
670
		adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
S
Sathya Perla 已提交
671
	}
672

673
	if (link_status)
674 675 676
		netif_carrier_on(netdev);
	else
		netif_carrier_off(netdev);
I
Ivan Vecera 已提交
677 678

	netdev_info(netdev, "Link is %s\n", link_status ? "Up" : "Down");
S
Sathya Perla 已提交
679 680
}

681
static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb)
S
Sathya Perla 已提交
682
{
683
	struct be_tx_stats *stats = tx_stats(txo);
684
	u64 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1;
685

686
	u64_stats_update_begin(&stats->sync);
687
	stats->tx_reqs++;
688
	stats->tx_bytes += skb->len;
689 690 691
	stats->tx_pkts += tx_pkts;
	if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL)
		stats->tx_vxlan_offload_pkts += tx_pkts;
692
	u64_stats_update_end(&stats->sync);
S
Sathya Perla 已提交
693 694
}

695 696
/* Returns number of WRBs needed for the skb */
static u32 skb_wrb_cnt(struct sk_buff *skb)
S
Sathya Perla 已提交
697
{
698 699
	/* +1 for the header wrb */
	return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags;
S
Sathya Perla 已提交
700 701 702 703
}

static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
{
704 705 706 707 708 709 710 711 712 713 714 715 716 717
	wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr));
	wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr));
	wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK);
	wrb->rsvd0 = 0;
}

/* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb
 * to avoid the swap and shift/mask operations in wrb_fill().
 */
static inline void wrb_fill_dummy(struct be_eth_wrb *wrb)
{
	wrb->frag_pa_hi = 0;
	wrb->frag_pa_lo = 0;
	wrb->frag_len = 0;
718
	wrb->rsvd0 = 0;
S
Sathya Perla 已提交
719 720
}

721
static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
722
				     struct sk_buff *skb)
723 724 725 726
{
	u8 vlan_prio;
	u16 vlan_tag;

727
	vlan_tag = skb_vlan_tag_get(skb);
728 729 730 731 732 733 734 735 736
	vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
	/* If vlan priority provided by OS is NOT in available bmap */
	if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
		vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
				adapter->recommended_prio;

	return vlan_tag;
}

737 738 739 740 741 742 743 744 745 746 747 748 749
/* Used only for IP tunnel packets */
static u16 skb_inner_ip_proto(struct sk_buff *skb)
{
	return (inner_ip_hdr(skb)->version == 4) ?
		inner_ip_hdr(skb)->protocol : inner_ipv6_hdr(skb)->nexthdr;
}

static u16 skb_ip_proto(struct sk_buff *skb)
{
	return (ip_hdr(skb)->version == 4) ?
		ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr;
}

750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
static inline bool be_is_txq_full(struct be_tx_obj *txo)
{
	return atomic_read(&txo->q.used) + BE_MAX_TX_FRAG_COUNT >= txo->q.len;
}

static inline bool be_can_txq_wake(struct be_tx_obj *txo)
{
	return atomic_read(&txo->q.used) < txo->q.len / 2;
}

static inline bool be_is_tx_compl_pending(struct be_tx_obj *txo)
{
	return atomic_read(&txo->q.used) > txo->pend_wrb_cnt;
}

765 766 767
static void be_get_wrb_params_from_skb(struct be_adapter *adapter,
				       struct sk_buff *skb,
				       struct be_wrb_params *wrb_params)
S
Sathya Perla 已提交
768
{
769
	u16 proto;
S
Sathya Perla 已提交
770

A
Ajit Khaparde 已提交
771
	if (skb_is_gso(skb)) {
772 773
		BE_WRB_F_SET(wrb_params->features, LSO, 1);
		wrb_params->lso_mss = skb_shinfo(skb)->gso_size;
774
		if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
775
			BE_WRB_F_SET(wrb_params->features, LSO6, 1);
S
Sathya Perla 已提交
776
	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
777
		if (skb->encapsulation) {
778
			BE_WRB_F_SET(wrb_params->features, IPCS, 1);
779 780 781 782 783
			proto = skb_inner_ip_proto(skb);
		} else {
			proto = skb_ip_proto(skb);
		}
		if (proto == IPPROTO_TCP)
784
			BE_WRB_F_SET(wrb_params->features, TCPCS, 1);
785
		else if (proto == IPPROTO_UDP)
786
			BE_WRB_F_SET(wrb_params->features, UDPCS, 1);
S
Sathya Perla 已提交
787 788
	}

789
	if (skb_vlan_tag_present(skb)) {
790 791
		BE_WRB_F_SET(wrb_params->features, VLAN, 1);
		wrb_params->vlan_tag = be_get_tx_vlan_tag(adapter, skb);
S
Sathya Perla 已提交
792 793
	}

794 795
	BE_WRB_F_SET(wrb_params->features, CRC, 1);
}
796

797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
static void wrb_fill_hdr(struct be_adapter *adapter,
			 struct be_eth_hdr_wrb *hdr,
			 struct be_wrb_params *wrb_params,
			 struct sk_buff *skb)
{
	memset(hdr, 0, sizeof(*hdr));

	SET_TX_WRB_HDR_BITS(crc, hdr,
			    BE_WRB_F_GET(wrb_params->features, CRC));
	SET_TX_WRB_HDR_BITS(ipcs, hdr,
			    BE_WRB_F_GET(wrb_params->features, IPCS));
	SET_TX_WRB_HDR_BITS(tcpcs, hdr,
			    BE_WRB_F_GET(wrb_params->features, TCPCS));
	SET_TX_WRB_HDR_BITS(udpcs, hdr,
			    BE_WRB_F_GET(wrb_params->features, UDPCS));

	SET_TX_WRB_HDR_BITS(lso, hdr,
			    BE_WRB_F_GET(wrb_params->features, LSO));
	SET_TX_WRB_HDR_BITS(lso6, hdr,
			    BE_WRB_F_GET(wrb_params->features, LSO6));
	SET_TX_WRB_HDR_BITS(lso_mss, hdr, wrb_params->lso_mss);

	/* Hack to skip HW VLAN tagging needs evt = 1, compl = 0. When this
	 * hack is not needed, the evt bit is set while ringing DB.
821
	 */
822 823 824 825 826 827 828 829
	SET_TX_WRB_HDR_BITS(event, hdr,
			    BE_WRB_F_GET(wrb_params->features, VLAN_SKIP_HW));
	SET_TX_WRB_HDR_BITS(vlan, hdr,
			    BE_WRB_F_GET(wrb_params->features, VLAN));
	SET_TX_WRB_HDR_BITS(vlan_tag, hdr, wrb_params->vlan_tag);

	SET_TX_WRB_HDR_BITS(num_wrb, hdr, skb_wrb_cnt(skb));
	SET_TX_WRB_HDR_BITS(len, hdr, skb->len);
V
Venkata Duvvuru 已提交
830 831
	SET_TX_WRB_HDR_BITS(mgmt, hdr,
			    BE_WRB_F_GET(wrb_params->features, OS2BMC));
S
Sathya Perla 已提交
832 833
}

I
Ivan Vecera 已提交
834
static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
835
			  bool unmap_single)
836 837
{
	dma_addr_t dma;
838
	u32 frag_len = le32_to_cpu(wrb->frag_len);
839 840


841 842 843
	dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 |
		(u64)le32_to_cpu(wrb->frag_pa_lo);
	if (frag_len) {
844
		if (unmap_single)
845
			dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE);
846
		else
847
			dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE);
848 849
	}
}
S
Sathya Perla 已提交
850

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 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 916 917 918 919 920 921 922 923 924
/* Grab a WRB header for xmit */
static u16 be_tx_get_wrb_hdr(struct be_tx_obj *txo)
{
	u16 head = txo->q.head;

	queue_head_inc(&txo->q);
	return head;
}

/* Set up the WRB header for xmit */
static void be_tx_setup_wrb_hdr(struct be_adapter *adapter,
				struct be_tx_obj *txo,
				struct be_wrb_params *wrb_params,
				struct sk_buff *skb, u16 head)
{
	u32 num_frags = skb_wrb_cnt(skb);
	struct be_queue_info *txq = &txo->q;
	struct be_eth_hdr_wrb *hdr = queue_index_node(txq, head);

	wrb_fill_hdr(adapter, hdr, wrb_params, skb);
	be_dws_cpu_to_le(hdr, sizeof(*hdr));

	BUG_ON(txo->sent_skb_list[head]);
	txo->sent_skb_list[head] = skb;
	txo->last_req_hdr = head;
	atomic_add(num_frags, &txq->used);
	txo->last_req_wrb_cnt = num_frags;
	txo->pend_wrb_cnt += num_frags;
}

/* Setup a WRB fragment (buffer descriptor) for xmit */
static void be_tx_setup_wrb_frag(struct be_tx_obj *txo, dma_addr_t busaddr,
				 int len)
{
	struct be_eth_wrb *wrb;
	struct be_queue_info *txq = &txo->q;

	wrb = queue_head_node(txq);
	wrb_fill(wrb, busaddr, len);
	queue_head_inc(txq);
}

/* Bring the queue back to the state it was in before be_xmit_enqueue() routine
 * was invoked. The producer index is restored to the previous packet and the
 * WRBs of the current packet are unmapped. Invoked to handle tx setup errors.
 */
static void be_xmit_restore(struct be_adapter *adapter,
			    struct be_tx_obj *txo, u16 head, bool map_single,
			    u32 copied)
{
	struct device *dev;
	struct be_eth_wrb *wrb;
	struct be_queue_info *txq = &txo->q;

	dev = &adapter->pdev->dev;
	txq->head = head;

	/* skip the first wrb (hdr); it's not mapped */
	queue_head_inc(txq);
	while (copied) {
		wrb = queue_head_node(txq);
		unmap_tx_frag(dev, wrb, map_single);
		map_single = false;
		copied -= le32_to_cpu(wrb->frag_len);
		queue_head_inc(txq);
	}

	txq->head = head;
}

/* Enqueue the given packet for transmit. This routine allocates WRBs for the
 * packet, dma maps the packet buffers and sets up the WRBs. Returns the number
 * of WRBs used up by the packet.
 */
925
static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo,
926 927
			   struct sk_buff *skb,
			   struct be_wrb_params *wrb_params)
S
Sathya Perla 已提交
928
{
929
	u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb);
I
Ivan Vecera 已提交
930
	struct device *dev = &adapter->pdev->dev;
931
	struct be_queue_info *txq = &txo->q;
932
	bool map_single = false;
933
	u16 head = txq->head;
934 935
	dma_addr_t busaddr;
	int len;
S
Sathya Perla 已提交
936

937
	head = be_tx_get_wrb_hdr(txo);
S
Sathya Perla 已提交
938

939
	if (skb->len > skb->data_len) {
940
		len = skb_headlen(skb);
941

I
Ivan Vecera 已提交
942 943
		busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
		if (dma_mapping_error(dev, busaddr))
944 945
			goto dma_err;
		map_single = true;
946
		be_tx_setup_wrb_frag(txo, busaddr, len);
947 948
		copied += len;
	}
S
Sathya Perla 已提交
949

950
	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
951
		const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
952
		len = skb_frag_size(frag);
953

954
		busaddr = skb_frag_dma_map(dev, frag, 0, len, DMA_TO_DEVICE);
I
Ivan Vecera 已提交
955
		if (dma_mapping_error(dev, busaddr))
956
			goto dma_err;
957 958
		be_tx_setup_wrb_frag(txo, busaddr, len);
		copied += len;
S
Sathya Perla 已提交
959 960
	}

961
	be_tx_setup_wrb_hdr(adapter, txo, wrb_params, skb, head);
S
Sathya Perla 已提交
962

963 964
	be_tx_stats_update(txo, skb);
	return wrb_cnt;
S
Sathya Perla 已提交
965

966
dma_err:
967 968
	adapter->drv_stats.dma_map_errors++;
	be_xmit_restore(adapter, txo, head, map_single, copied);
969
	return 0;
S
Sathya Perla 已提交
970 971
}

972 973 974 975 976
static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
{
	return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
}

977
static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
978
					     struct sk_buff *skb,
979 980
					     struct be_wrb_params
					     *wrb_params)
981 982 983 984 985 986 987
{
	u16 vlan_tag = 0;

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (unlikely(!skb))
		return skb;

988
	if (skb_vlan_tag_present(skb))
989
		vlan_tag = be_get_tx_vlan_tag(adapter, skb);
990 991 992 993 994 995 996

	if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
		if (!vlan_tag)
			vlan_tag = adapter->pvid;
		/* f/w workaround to set skip_hw_vlan = 1, informs the F/W to
		 * skip VLAN insertion
		 */
997
		BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
998
	}
999 1000

	if (vlan_tag) {
1001 1002
		skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
						vlan_tag);
1003 1004 1005 1006 1007 1008 1009 1010
		if (unlikely(!skb))
			return skb;
		skb->vlan_tci = 0;
	}

	/* Insert the outer VLAN, if any */
	if (adapter->qnq_vid) {
		vlan_tag = adapter->qnq_vid;
1011 1012
		skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
						vlan_tag);
1013 1014
		if (unlikely(!skb))
			return skb;
1015
		BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1016 1017
	}

1018 1019 1020
	return skb;
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
static bool be_ipv6_exthdr_check(struct sk_buff *skb)
{
	struct ethhdr *eh = (struct ethhdr *)skb->data;
	u16 offset = ETH_HLEN;

	if (eh->h_proto == htons(ETH_P_IPV6)) {
		struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);

		offset += sizeof(struct ipv6hdr);
		if (ip6h->nexthdr != NEXTHDR_TCP &&
		    ip6h->nexthdr != NEXTHDR_UDP) {
			struct ipv6_opt_hdr *ehdr =
K
Kalesh AP 已提交
1033
				(struct ipv6_opt_hdr *)(skb->data + offset);
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044

			/* offending pkt: 2nd byte following IPv6 hdr is 0xff */
			if (ehdr->hdrlen == 0xff)
				return true;
		}
	}
	return false;
}

static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
{
1045
	return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
1046 1047
}

1048
static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
1049
{
1050
	return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
1051 1052
}

1053 1054
static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
						  struct sk_buff *skb,
1055 1056
						  struct be_wrb_params
						  *wrb_params)
S
Sathya Perla 已提交
1057
{
1058
	struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1059 1060
	unsigned int eth_hdr_len;
	struct iphdr *ip;
1061

1062 1063
	/* For padded packets, BE HW modifies tot_len field in IP header
	 * incorrecly when VLAN tag is inserted by HW.
1064
	 * For padded packets, Lancer computes incorrect checksum.
1065
	 */
1066 1067
	eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
						VLAN_ETH_HLEN : ETH_HLEN;
1068
	if (skb->len <= 60 &&
1069
	    (lancer_chip(adapter) || skb_vlan_tag_present(skb)) &&
1070
	    is_ipv4_pkt(skb)) {
1071 1072 1073
		ip = (struct iphdr *)ip_hdr(skb);
		pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
	}
1074

1075
	/* If vlan tag is already inlined in the packet, skip HW VLAN
1076
	 * tagging in pvid-tagging mode
1077
	 */
1078
	if (be_pvid_tagging_enabled(adapter) &&
1079
	    veh->h_vlan_proto == htons(ETH_P_8021Q))
1080
		BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1081

1082 1083 1084 1085 1086
	/* HW has a bug wherein it will calculate CSUM for VLAN
	 * pkts even though it is disabled.
	 * Manually insert VLAN in pkt.
	 */
	if (skb->ip_summed != CHECKSUM_PARTIAL &&
1087
	    skb_vlan_tag_present(skb)) {
1088
		skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1089
		if (unlikely(!skb))
1090
			goto err;
1091 1092 1093 1094 1095 1096 1097
	}

	/* HW may lockup when VLAN HW tagging is requested on
	 * certain ipv6 packets. Drop such pkts if the HW workaround to
	 * skip HW tagging is not enabled by FW.
	 */
	if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
K
Kalesh AP 已提交
1098 1099
		     (adapter->pvid || adapter->qnq_vid) &&
		     !qnq_async_evt_rcvd(adapter)))
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
		goto tx_drop;

	/* Manual VLAN tag insertion to prevent:
	 * ASIC lockup when the ASIC inserts VLAN tag into
	 * certain ipv6 packets. Insert VLAN tags in driver,
	 * and set event, completion, vlan bits accordingly
	 * in the Tx WRB.
	 */
	if (be_ipv6_tx_stall_chk(adapter, skb) &&
	    be_vlan_tag_tx_chk(adapter, skb)) {
1110
		skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1111
		if (unlikely(!skb))
1112
			goto err;
1113 1114
	}

1115 1116 1117
	return skb;
tx_drop:
	dev_kfree_skb_any(skb);
1118
err:
1119 1120 1121
	return NULL;
}

1122 1123
static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
					   struct sk_buff *skb,
1124
					   struct be_wrb_params *wrb_params)
1125
{
1126 1127 1128 1129
	/* Lancer, SH and BE3 in SRIOV mode have a bug wherein
	 * packets that are 32b or less may cause a transmit stall
	 * on that port. The workaround is to pad such packets
	 * (len <= 32 bytes) to a minimum length of 36b.
1130
	 */
1131
	if (skb->len <= 32) {
1132
		if (skb_put_padto(skb, 36))
1133 1134 1135 1136
			return NULL;
	}

	if (BEx_chip(adapter) || lancer_chip(adapter)) {
1137
		skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params);
1138 1139 1140 1141 1142 1143 1144
		if (!skb)
			return NULL;
	}

	return skb;
}

1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo)
{
	struct be_queue_info *txq = &txo->q;
	struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr);

	/* Mark the last request eventable if it hasn't been marked already */
	if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT)))
		hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL);

	/* compose a dummy wrb if there are odd set of wrbs to notify */
	if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) {
1156
		wrb_fill_dummy(queue_head_node(txq));
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		queue_head_inc(txq);
		atomic_inc(&txq->used);
		txo->pend_wrb_cnt++;
		hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK <<
					   TX_HDR_WRB_NUM_SHIFT);
		hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) <<
					  TX_HDR_WRB_NUM_SHIFT);
	}
	be_txq_notify(adapter, txo, txo->pend_wrb_cnt);
	txo->pend_wrb_cnt = 0;
}

V
Venkata Duvvuru 已提交
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
/* OS2BMC related */

#define DHCP_CLIENT_PORT	68
#define DHCP_SERVER_PORT	67
#define NET_BIOS_PORT1		137
#define NET_BIOS_PORT2		138
#define DHCPV6_RAS_PORT		547

#define is_mc_allowed_on_bmc(adapter, eh)	\
	(!is_multicast_filt_enabled(adapter) &&	\
	 is_multicast_ether_addr(eh->h_dest) &&	\
	 !is_broadcast_ether_addr(eh->h_dest))

#define is_bc_allowed_on_bmc(adapter, eh)	\
	(!is_broadcast_filt_enabled(adapter) &&	\
	 is_broadcast_ether_addr(eh->h_dest))

#define is_arp_allowed_on_bmc(adapter, skb)	\
	(is_arp(skb) && is_arp_filt_enabled(adapter))

#define is_broadcast_packet(eh, adapter)	\
		(is_multicast_ether_addr(eh->h_dest) && \
		!compare_ether_addr(eh->h_dest, adapter->netdev->broadcast))

#define is_arp(skb)	(skb->protocol == htons(ETH_P_ARP))

#define is_arp_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP))

#define is_dhcp_client_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT)

#define is_dhcp_srvr_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER)

#define is_nbios_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS)

#define is_ipv6_na_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask &	\
			BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER)

#define is_ipv6_ra_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA)

#define is_ipv6_ras_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS)

#define is_broadcast_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_BROADCAST)

#define is_multicast_filt_enabled(adapter)	\
		(adapter->bmc_filt_mask & BMC_FILT_MULTICAST)

static bool be_send_pkt_to_bmc(struct be_adapter *adapter,
			       struct sk_buff **skb)
{
	struct ethhdr *eh = (struct ethhdr *)(*skb)->data;
	bool os2bmc = false;

	if (!be_is_os2bmc_enabled(adapter))
		goto done;

	if (!is_multicast_ether_addr(eh->h_dest))
		goto done;

	if (is_mc_allowed_on_bmc(adapter, eh) ||
	    is_bc_allowed_on_bmc(adapter, eh) ||
	    is_arp_allowed_on_bmc(adapter, (*skb))) {
		os2bmc = true;
		goto done;
	}

	if ((*skb)->protocol == htons(ETH_P_IPV6)) {
		struct ipv6hdr *hdr = ipv6_hdr((*skb));
		u8 nexthdr = hdr->nexthdr;

		if (nexthdr == IPPROTO_ICMPV6) {
			struct icmp6hdr *icmp6 = icmp6_hdr((*skb));

			switch (icmp6->icmp6_type) {
			case NDISC_ROUTER_ADVERTISEMENT:
				os2bmc = is_ipv6_ra_filt_enabled(adapter);
				goto done;
			case NDISC_NEIGHBOUR_ADVERTISEMENT:
				os2bmc = is_ipv6_na_filt_enabled(adapter);
				goto done;
			default:
				break;
			}
		}
	}

	if (is_udp_pkt((*skb))) {
		struct udphdr *udp = udp_hdr((*skb));

1265
		switch (ntohs(udp->dest)) {
V
Venkata Duvvuru 已提交
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
		case DHCP_CLIENT_PORT:
			os2bmc = is_dhcp_client_filt_enabled(adapter);
			goto done;
		case DHCP_SERVER_PORT:
			os2bmc = is_dhcp_srvr_filt_enabled(adapter);
			goto done;
		case NET_BIOS_PORT1:
		case NET_BIOS_PORT2:
			os2bmc = is_nbios_filt_enabled(adapter);
			goto done;
		case DHCPV6_RAS_PORT:
			os2bmc = is_ipv6_ras_filt_enabled(adapter);
			goto done;
		default:
			break;
		}
	}
done:
	/* For packets over a vlan, which are destined
	 * to BMC, asic expects the vlan to be inline in the packet.
	 */
	if (os2bmc)
		*skb = be_insert_vlan_in_pkt(adapter, *skb, NULL);

	return os2bmc;
}

1293 1294 1295
static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
1296 1297
	u16 q_idx = skb_get_queue_mapping(skb);
	struct be_tx_obj *txo = &adapter->tx_obj[q_idx];
1298 1299
	struct be_wrb_params wrb_params = { 0 };
	bool flush = !skb->xmit_more;
1300
	u16 wrb_cnt;
1301

1302
	skb = be_xmit_workarounds(adapter, skb, &wrb_params);
1303 1304
	if (unlikely(!skb))
		goto drop;
S
Sathya Perla 已提交
1305

1306 1307 1308
	be_get_wrb_params_from_skb(adapter, skb, &wrb_params);

	wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1309 1310 1311 1312
	if (unlikely(!wrb_cnt)) {
		dev_kfree_skb_any(skb);
		goto drop;
	}
E
Eric Dumazet 已提交
1313

V
Venkata Duvvuru 已提交
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
	/* if os2bmc is enabled and if the pkt is destined to bmc,
	 * enqueue the pkt a 2nd time with mgmt bit set.
	 */
	if (be_send_pkt_to_bmc(adapter, &skb)) {
		BE_WRB_F_SET(wrb_params.features, OS2BMC, 1);
		wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
		if (unlikely(!wrb_cnt))
			goto drop;
		else
			skb_get(skb);
	}

1326
	if (be_is_txq_full(txo)) {
1327 1328 1329
		netif_stop_subqueue(netdev, q_idx);
		tx_stats(txo)->tx_stops++;
	}
1330

1331 1332
	if (flush || __netif_subqueue_stopped(netdev, q_idx))
		be_xmit_flush(adapter, txo);
S
Sathya Perla 已提交
1333

1334 1335 1336 1337 1338 1339
	return NETDEV_TX_OK;
drop:
	tx_stats(txo)->tx_drv_drops++;
	/* Flush the already enqueued tx requests */
	if (flush && txo->pend_wrb_cnt)
		be_xmit_flush(adapter, txo);
S
Sathya Perla 已提交
1340 1341 1342 1343 1344 1345 1346

	return NETDEV_TX_OK;
}

static int be_change_mtu(struct net_device *netdev, int new_mtu)
{
	struct be_adapter *adapter = netdev_priv(netdev);
K
Kalesh AP 已提交
1347 1348 1349 1350 1351
	struct device *dev = &adapter->pdev->dev;

	if (new_mtu < BE_MIN_MTU || new_mtu > BE_MAX_MTU) {
		dev_info(dev, "MTU must be between %d and %d bytes\n",
			 BE_MIN_MTU, BE_MAX_MTU);
S
Sathya Perla 已提交
1352 1353
		return -EINVAL;
	}
K
Kalesh AP 已提交
1354 1355

	dev_info(dev, "MTU changed from %d to %d bytes\n",
1356
		 netdev->mtu, new_mtu);
S
Sathya Perla 已提交
1357 1358 1359 1360
	netdev->mtu = new_mtu;
	return 0;
}

1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
static inline bool be_in_all_promisc(struct be_adapter *adapter)
{
	return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) ==
			BE_IF_FLAGS_ALL_PROMISCUOUS;
}

static int be_set_vlan_promisc(struct be_adapter *adapter)
{
	struct device *dev = &adapter->pdev->dev;
	int status;

	if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS)
		return 0;

	status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON);
	if (!status) {
		dev_info(dev, "Enabled VLAN promiscuous mode\n");
		adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS;
	} else {
		dev_err(dev, "Failed to enable VLAN promiscuous mode\n");
	}
	return status;
}

static int be_clear_vlan_promisc(struct be_adapter *adapter)
{
	struct device *dev = &adapter->pdev->dev;
	int status;

	status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF);
	if (!status) {
		dev_info(dev, "Disabling VLAN promiscuous mode\n");
		adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
	}
	return status;
}

S
Sathya Perla 已提交
1398
/*
1399 1400
 * 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 已提交
1401
 */
S
Sathya Perla 已提交
1402
static int be_vid_config(struct be_adapter *adapter)
S
Sathya Perla 已提交
1403
{
V
Vasundhara Volam 已提交
1404
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
1405
	u16 vids[BE_NUM_VLANS_SUPPORTED];
1406
	u16 num = 0, i = 0;
1407
	int status = 0;
1408

1409
	/* No need to further configure vids if in promiscuous mode */
1410
	if (be_in_all_promisc(adapter))
1411 1412
		return 0;

1413
	if (adapter->vlans_added > be_max_vlans(adapter))
1414
		return be_set_vlan_promisc(adapter);
1415 1416

	/* Construct VLAN Table to give to HW */
1417 1418
	for_each_set_bit(i, adapter->vids, VLAN_N_VID)
		vids[num++] = cpu_to_le16(i);
1419

1420
	status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0);
1421
	if (status) {
1422
		dev_err(dev, "Setting HW VLAN filtering failed\n");
1423
		/* Set to VLAN promisc mode as setting VLAN filter failed */
1424 1425
		if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS ||
		    addl_status(status) ==
1426
				MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES)
1427 1428 1429
			return be_set_vlan_promisc(adapter);
	} else if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
		status = be_clear_vlan_promisc(adapter);
S
Sathya Perla 已提交
1430
	}
1431
	return status;
S
Sathya Perla 已提交
1432 1433
}

1434
static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
S
Sathya Perla 已提交
1435 1436
{
	struct be_adapter *adapter = netdev_priv(netdev);
A
Ajit Khaparde 已提交
1437
	int status = 0;
S
Sathya Perla 已提交
1438

1439 1440
	/* Packets with VID 0 are always received by Lancer by default */
	if (lancer_chip(adapter) && vid == 0)
1441 1442
		return status;

1443
	if (test_bit(vid, adapter->vids))
1444
		return status;
1445

1446
	set_bit(vid, adapter->vids);
1447
	adapter->vlans_added++;
1448

1449 1450 1451
	status = be_vid_config(adapter);
	if (status) {
		adapter->vlans_added--;
1452
		clear_bit(vid, adapter->vids);
1453
	}
1454

A
Ajit Khaparde 已提交
1455
	return status;
S
Sathya Perla 已提交
1456 1457
}

1458
static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
S
Sathya Perla 已提交
1459 1460 1461
{
	struct be_adapter *adapter = netdev_priv(netdev);

1462 1463
	/* Packets with VID 0 are always received by Lancer by default */
	if (lancer_chip(adapter) && vid == 0)
1464
		return 0;
1465

1466
	clear_bit(vid, adapter->vids);
1467 1468 1469
	adapter->vlans_added--;

	return be_vid_config(adapter);
S
Sathya Perla 已提交
1470 1471
}

1472
static void be_clear_all_promisc(struct be_adapter *adapter)
1473
{
1474
	be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, OFF);
1475
	adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS;
1476 1477
}

1478 1479 1480 1481 1482 1483 1484
static void be_set_all_promisc(struct be_adapter *adapter)
{
	be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON);
	adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS;
}

static void be_set_mc_promisc(struct be_adapter *adapter)
S
Sathya Perla 已提交
1485
{
1486
	int status;
S
Sathya Perla 已提交
1487

1488 1489
	if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS)
		return;
S
Sathya Perla 已提交
1490

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
	status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON);
	if (!status)
		adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS;
}

static void be_set_mc_list(struct be_adapter *adapter)
{
	int status;

	status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON);
	if (!status)
		adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS;
	else
		be_set_mc_promisc(adapter);
}

static void be_set_uc_list(struct be_adapter *adapter)
{
	struct netdev_hw_addr *ha;
	int i = 1; /* First slot is claimed by the Primary MAC */

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

	if (netdev_uc_count(adapter->netdev) > be_max_uc(adapter)) {
		be_set_all_promisc(adapter);
		return;
S
Sathya Perla 已提交
1519 1520
	}

1521 1522 1523 1524 1525 1526
	netdev_for_each_uc_addr(ha, adapter->netdev) {
		adapter->uc_macs++; /* First slot is for Primary MAC */
		be_cmd_pmac_add(adapter, (u8 *)ha->addr, adapter->if_handle,
				&adapter->pmac_id[adapter->uc_macs], 0);
	}
}
S
Sathya Perla 已提交
1527

1528 1529 1530
static void be_clear_uc_list(struct be_adapter *adapter)
{
	int i;
1531

1532 1533 1534 1535 1536
	for (i = 1; i < (adapter->uc_macs + 1); i++)
		be_cmd_pmac_del(adapter, adapter->if_handle,
				adapter->pmac_id[i], 0);
	adapter->uc_macs = 0;
}
1537

1538 1539 1540
static void be_set_rx_mode(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
1541

1542 1543 1544
	if (netdev->flags & IFF_PROMISC) {
		be_set_all_promisc(adapter);
		return;
1545 1546
	}

1547 1548 1549 1550 1551
	/* Interface was previously in promiscuous mode; disable it */
	if (be_in_all_promisc(adapter)) {
		be_clear_all_promisc(adapter);
		if (adapter->vlans_added)
			be_vid_config(adapter);
1552
	}
1553

1554 1555 1556 1557
	/* Enable multicast promisc if num configured exceeds what we support */
	if (netdev->flags & IFF_ALLMULTI ||
	    netdev_mc_count(netdev) > be_max_mc(adapter)) {
		be_set_mc_promisc(adapter);
1558
		return;
1559
	}
1560

1561 1562 1563 1564
	if (netdev_uc_count(netdev) != adapter->uc_macs)
		be_set_uc_list(adapter);

	be_set_mc_list(adapter);
S
Sathya Perla 已提交
1565 1566
}

1567 1568 1569
static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
{
	struct be_adapter *adapter = netdev_priv(netdev);
1570
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1571 1572
	int status;

1573
	if (!sriov_enabled(adapter))
1574 1575
		return -EPERM;

1576
	if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
1577 1578
		return -EINVAL;

1579 1580 1581 1582 1583 1584
	/* Proceed further only if user provided MAC is different
	 * from active MAC
	 */
	if (ether_addr_equal(mac, vf_cfg->mac_addr))
		return 0;

1585 1586 1587
	if (BEx_chip(adapter)) {
		be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id,
				vf + 1);
1588

1589 1590
		status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
					 &vf_cfg->pmac_id, vf + 1);
1591 1592 1593
	} else {
		status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
					vf + 1);
1594 1595
	}

1596 1597 1598 1599 1600
	if (status) {
		dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x",
			mac, vf, status);
		return be_cmd_status(status);
	}
1601

1602 1603 1604
	ether_addr_copy(vf_cfg->mac_addr, mac);

	return 0;
1605 1606
}

1607
static int be_get_vf_config(struct net_device *netdev, int vf,
1608
			    struct ifla_vf_info *vi)
1609 1610
{
	struct be_adapter *adapter = netdev_priv(netdev);
1611
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1612

1613
	if (!sriov_enabled(adapter))
1614 1615
		return -EPERM;

1616
	if (vf >= adapter->num_vfs)
1617 1618 1619
		return -EINVAL;

	vi->vf = vf;
1620 1621
	vi->max_tx_rate = vf_cfg->tx_rate;
	vi->min_tx_rate = 0;
1622 1623
	vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK;
	vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT;
1624
	memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
1625
	vi->linkstate = adapter->vf_cfg[vf].plink_tracking;
1626
	vi->spoofchk = adapter->vf_cfg[vf].spoofchk;
1627 1628 1629 1630

	return 0;
}

1631 1632 1633 1634 1635 1636 1637 1638
static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan)
{
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
	u16 vids[BE_NUM_VLANS_SUPPORTED];
	int vf_if_id = vf_cfg->if_handle;
	int status;

	/* Enable Transparent VLAN Tagging */
1639
	status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0);
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
	if (status)
		return status;

	/* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */
	vids[0] = 0;
	status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1);
	if (!status)
		dev_info(&adapter->pdev->dev,
			 "Cleared guest VLANs on VF%d", vf);

	/* After TVT is enabled, disallow VFs to program VLAN filters */
	if (vf_cfg->privileges & BE_PRIV_FILTMGMT) {
		status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges &
						  ~BE_PRIV_FILTMGMT, vf + 1);
		if (!status)
			vf_cfg->privileges &= ~BE_PRIV_FILTMGMT;
	}
	return 0;
}

static int be_clear_vf_tvt(struct be_adapter *adapter, int vf)
{
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
	struct device *dev = &adapter->pdev->dev;
	int status;

	/* Reset Transparent VLAN Tagging. */
	status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1,
1668
				       vf_cfg->if_handle, 0, 0);
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
	if (status)
		return status;

	/* Allow VFs to program VLAN filtering */
	if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
		status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges |
						  BE_PRIV_FILTMGMT, vf + 1);
		if (!status) {
			vf_cfg->privileges |= BE_PRIV_FILTMGMT;
			dev_info(dev, "VF%d: FILTMGMT priv enabled", vf);
		}
	}

	dev_info(dev,
		 "Disable/re-enable i/f in VM to clear Transparent VLAN tag");
	return 0;
}

1687
static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
1688 1689
{
	struct be_adapter *adapter = netdev_priv(netdev);
1690
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1691
	int status;
1692

1693
	if (!sriov_enabled(adapter))
1694 1695
		return -EPERM;

1696
	if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7)
1697 1698
		return -EINVAL;

1699 1700
	if (vlan || qos) {
		vlan |= qos << VLAN_PRIO_SHIFT;
1701
		status = be_set_vf_tvt(adapter, vf, vlan);
1702
	} else {
1703
		status = be_clear_vf_tvt(adapter, vf);
1704 1705
	}

1706 1707
	if (status) {
		dev_err(&adapter->pdev->dev,
1708 1709
			"VLAN %d config on VF %d failed : %#x\n", vlan, vf,
			status);
1710 1711 1712 1713 1714
		return be_cmd_status(status);
	}

	vf_cfg->vlan_tag = vlan;
	return 0;
1715 1716
}

1717 1718
static int be_set_vf_tx_rate(struct net_device *netdev, int vf,
			     int min_tx_rate, int max_tx_rate)
1719 1720
{
	struct be_adapter *adapter = netdev_priv(netdev);
1721 1722 1723 1724
	struct device *dev = &adapter->pdev->dev;
	int percent_rate, status = 0;
	u16 link_speed = 0;
	u8 link_status;
1725

1726
	if (!sriov_enabled(adapter))
1727 1728
		return -EPERM;

1729
	if (vf >= adapter->num_vfs)
1730 1731
		return -EINVAL;

1732 1733 1734
	if (min_tx_rate)
		return -EINVAL;

1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
	if (!max_tx_rate)
		goto config_qos;

	status = be_cmd_link_status_query(adapter, &link_speed,
					  &link_status, 0);
	if (status)
		goto err;

	if (!link_status) {
		dev_err(dev, "TX-rate setting not allowed when link is down\n");
1745
		status = -ENETDOWN;
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
		goto err;
	}

	if (max_tx_rate < 100 || max_tx_rate > link_speed) {
		dev_err(dev, "TX-rate must be between 100 and %d Mbps\n",
			link_speed);
		status = -EINVAL;
		goto err;
	}

	/* On Skyhawk the QOS setting must be done only as a % value */
	percent_rate = link_speed / 100;
	if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) {
		dev_err(dev, "TX-rate must be a multiple of %d Mbps\n",
			percent_rate);
		status = -EINVAL;
		goto err;
1763
	}
1764

1765 1766
config_qos:
	status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1);
1767
	if (status)
1768 1769 1770 1771 1772 1773 1774 1775
		goto err;

	adapter->vf_cfg[vf].tx_rate = max_tx_rate;
	return 0;

err:
	dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n",
		max_tx_rate, vf);
1776
	return be_cmd_status(status);
1777
}
1778

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
static int be_set_vf_link_state(struct net_device *netdev, int vf,
				int link_state)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	int status;

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

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

	status = be_cmd_set_logical_link_config(adapter, link_state, vf+1);
1792 1793 1794 1795 1796
	if (status) {
		dev_err(&adapter->pdev->dev,
			"Link state change on VF %d failed: %#x\n", vf, status);
		return be_cmd_status(status);
	}
1797

1798 1799 1800
	adapter->vf_cfg[vf].plink_tracking = link_state;

	return 0;
1801
}
1802

1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
	u8 spoofchk;
	int status;

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

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

	if (BEx_chip(adapter))
		return -EOPNOTSUPP;

	if (enable == vf_cfg->spoofchk)
		return 0;

	spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK;

	status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle,
				       0, spoofchk);
	if (status) {
		dev_err(&adapter->pdev->dev,
			"Spoofchk change on VF %d failed: %#x\n", vf, status);
		return be_cmd_status(status);
	}

	vf_cfg->spoofchk = enable;
	return 0;
}

1836 1837
static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts,
			  ulong now)
S
Sathya Perla 已提交
1838
{
1839 1840 1841 1842
	aic->rx_pkts_prev = rx_pkts;
	aic->tx_reqs_prev = tx_pkts;
	aic->jiffies = now;
}
1843

1844
static int be_get_new_eqd(struct be_eq_obj *eqo)
1845
{
1846 1847
	struct be_adapter *adapter = eqo->adapter;
	int eqd, start;
1848 1849 1850
	struct be_aic_obj *aic;
	struct be_rx_obj *rxo;
	struct be_tx_obj *txo;
1851
	u64 rx_pkts = 0, tx_pkts = 0;
1852 1853
	ulong now;
	u32 pps, delta;
1854
	int i;
S
Sathya Perla 已提交
1855

1856 1857 1858 1859 1860 1861 1862
	aic = &adapter->aic_obj[eqo->idx];
	if (!aic->enable) {
		if (aic->jiffies)
			aic->jiffies = 0;
		eqd = aic->et_eqd;
		return eqd;
	}
S
Sathya Perla 已提交
1863

1864
	for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
1865
		do {
1866
			start = u64_stats_fetch_begin_irq(&rxo->stats.sync);
1867
			rx_pkts += rxo->stats.rx_pkts;
1868
		} while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start));
1869
	}
S
Sathya Perla 已提交
1870

1871
	for_all_tx_queues_on_eq(adapter, eqo, txo, i) {
1872
		do {
1873
			start = u64_stats_fetch_begin_irq(&txo->stats.sync);
1874
			tx_pkts += txo->stats.tx_reqs;
1875
		} while (u64_stats_fetch_retry_irq(&txo->stats.sync, start));
1876
	}
S
Sathya Perla 已提交
1877

1878 1879 1880 1881 1882 1883 1884 1885
	/* Skip, if wrapped around or first calculation */
	now = jiffies;
	if (!aic->jiffies || time_before(now, aic->jiffies) ||
	    rx_pkts < aic->rx_pkts_prev ||
	    tx_pkts < aic->tx_reqs_prev) {
		be_aic_update(aic, rx_pkts, tx_pkts, now);
		return aic->prev_eqd;
	}
1886

1887 1888 1889
	delta = jiffies_to_msecs(now - aic->jiffies);
	if (delta == 0)
		return aic->prev_eqd;
S
Sathya Perla 已提交
1890

1891 1892 1893
	pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) +
		(((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta);
	eqd = (pps / 15000) << 2;
1894

1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
	if (eqd < 8)
		eqd = 0;
	eqd = min_t(u32, eqd, aic->max_eqd);
	eqd = max_t(u32, eqd, aic->min_eqd);

	be_aic_update(aic, rx_pkts, tx_pkts, now);

	return eqd;
}

/* For Skyhawk-R only */
static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo)
{
	struct be_adapter *adapter = eqo->adapter;
	struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx];
	ulong now = jiffies;
	int eqd;
	u32 mult_enc;

	if (!aic->enable)
		return 0;

	if (time_before_eq(now, aic->jiffies) ||
	    jiffies_to_msecs(now - aic->jiffies) < 1)
		eqd = aic->prev_eqd;
	else
		eqd = be_get_new_eqd(eqo);

	if (eqd > 100)
		mult_enc = R2I_DLY_ENC_1;
	else if (eqd > 60)
		mult_enc = R2I_DLY_ENC_2;
	else if (eqd > 20)
		mult_enc = R2I_DLY_ENC_3;
	else
		mult_enc = R2I_DLY_ENC_0;

	aic->prev_eqd = eqd;

	return mult_enc;
}

void be_eqd_update(struct be_adapter *adapter, bool force_update)
{
	struct be_set_eqd set_eqd[MAX_EVT_QS];
	struct be_aic_obj *aic;
	struct be_eq_obj *eqo;
	int i, num = 0, eqd;

	for_all_evt_queues(adapter, eqo, i) {
		aic = &adapter->aic_obj[eqo->idx];
		eqd = be_get_new_eqd(eqo);
		if (force_update || eqd != aic->prev_eqd) {
1948 1949 1950 1951 1952
			set_eqd[num].delay_multiplier = (eqd * 65)/100;
			set_eqd[num].eq_id = eqo->q.id;
			aic->prev_eqd = eqd;
			num++;
		}
1953
	}
1954 1955 1956

	if (num)
		be_cmd_modify_eqd(adapter, set_eqd, num);
S
Sathya Perla 已提交
1957 1958
}

1959
static void be_rx_stats_update(struct be_rx_obj *rxo,
1960
			       struct be_rx_compl_info *rxcp)
1961
{
1962
	struct be_rx_stats *stats = rx_stats(rxo);
1963

1964
	u64_stats_update_begin(&stats->sync);
1965
	stats->rx_compl++;
1966
	stats->rx_bytes += rxcp->pkt_size;
1967
	stats->rx_pkts++;
1968 1969
	if (rxcp->tunneled)
		stats->rx_vxlan_offload_pkts++;
1970
	if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1971
		stats->rx_mcast_pkts++;
1972
	if (rxcp->err)
1973
		stats->rx_compl_err++;
1974
	u64_stats_update_end(&stats->sync);
1975 1976
}

1977
static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1978
{
1979
	/* L4 checksum is not reliable for non TCP/UDP packets.
1980 1981
	 * Also ignore ipcksm for ipv6 pkts
	 */
1982
	return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
1983
		(rxcp->ip_csum || rxcp->ipv6) && !rxcp->err;
1984 1985
}

1986
static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo)
S
Sathya Perla 已提交
1987
{
S
Sathya Perla 已提交
1988
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
1989
	struct be_rx_page_info *rx_page_info;
1990
	struct be_queue_info *rxq = &rxo->q;
1991
	u16 frag_idx = rxq->tail;
S
Sathya Perla 已提交
1992

1993
	rx_page_info = &rxo->page_info_tbl[frag_idx];
S
Sathya Perla 已提交
1994 1995
	BUG_ON(!rx_page_info->page);

1996
	if (rx_page_info->last_frag) {
I
Ivan Vecera 已提交
1997 1998 1999
		dma_unmap_page(&adapter->pdev->dev,
			       dma_unmap_addr(rx_page_info, bus),
			       adapter->big_page_size, DMA_FROM_DEVICE);
2000 2001 2002 2003 2004
		rx_page_info->last_frag = false;
	} else {
		dma_sync_single_for_cpu(&adapter->pdev->dev,
					dma_unmap_addr(rx_page_info, bus),
					rx_frag_size, DMA_FROM_DEVICE);
A
Ajit Khaparde 已提交
2005
	}
S
Sathya Perla 已提交
2006

2007
	queue_tail_inc(rxq);
S
Sathya Perla 已提交
2008 2009 2010 2011 2012
	atomic_dec(&rxq->used);
	return rx_page_info;
}

/* Throwaway the data in the Rx completion */
S
Sathya Perla 已提交
2013 2014
static void be_rx_compl_discard(struct be_rx_obj *rxo,
				struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
2015 2016
{
	struct be_rx_page_info *page_info;
2017
	u16 i, num_rcvd = rxcp->num_rcvd;
S
Sathya Perla 已提交
2018

2019
	for (i = 0; i < num_rcvd; i++) {
2020
		page_info = get_rx_page_info(rxo);
2021 2022
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
S
Sathya Perla 已提交
2023 2024 2025 2026 2027 2028 2029
	}
}

/*
 * skb_fill_rx_data forms a complete skb for an ether frame
 * indicated by rxcp.
 */
S
Sathya Perla 已提交
2030 2031
static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
			     struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
2032 2033
{
	struct be_rx_page_info *page_info;
2034 2035
	u16 i, j;
	u16 hdr_len, curr_frag_len, remaining;
S
Sathya Perla 已提交
2036 2037
	u8 *start;

2038
	page_info = get_rx_page_info(rxo);
S
Sathya Perla 已提交
2039 2040 2041 2042
	start = page_address(page_info->page) + page_info->page_offset;
	prefetch(start);

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

	skb->len = curr_frag_len;
	if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
2047
		memcpy(skb->data, start, curr_frag_len);
S
Sathya Perla 已提交
2048 2049 2050 2051 2052
		/* Complete packet has now been moved to data */
		put_page(page_info->page);
		skb->data_len = 0;
		skb->tail += curr_frag_len;
	} else {
2053 2054
		hdr_len = ETH_HLEN;
		memcpy(skb->data, start, hdr_len);
S
Sathya Perla 已提交
2055
		skb_shinfo(skb)->nr_frags = 1;
2056
		skb_frag_set_page(skb, 0, page_info->page);
S
Sathya Perla 已提交
2057 2058
		skb_shinfo(skb)->frags[0].page_offset =
					page_info->page_offset + hdr_len;
2059 2060
		skb_frag_size_set(&skb_shinfo(skb)->frags[0],
				  curr_frag_len - hdr_len);
S
Sathya Perla 已提交
2061
		skb->data_len = curr_frag_len - hdr_len;
E
Eric Dumazet 已提交
2062
		skb->truesize += rx_frag_size;
S
Sathya Perla 已提交
2063 2064
		skb->tail += hdr_len;
	}
A
Ajit Khaparde 已提交
2065
	page_info->page = NULL;
S
Sathya Perla 已提交
2066

2067 2068 2069
	if (rxcp->pkt_size <= rx_frag_size) {
		BUG_ON(rxcp->num_rcvd != 1);
		return;
S
Sathya Perla 已提交
2070 2071 2072
	}

	/* More frags present for this completion */
2073 2074
	remaining = rxcp->pkt_size - curr_frag_len;
	for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
2075
		page_info = get_rx_page_info(rxo);
2076
		curr_frag_len = min(remaining, rx_frag_size);
S
Sathya Perla 已提交
2077

2078 2079 2080 2081
		/* Coalesce all frags from the same physical page in one slot */
		if (page_info->page_offset == 0) {
			/* Fresh page */
			j++;
2082
			skb_frag_set_page(skb, j, page_info->page);
2083 2084
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
2085
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2086 2087 2088 2089 2090
			skb_shinfo(skb)->nr_frags++;
		} else {
			put_page(page_info->page);
		}

E
Eric Dumazet 已提交
2091
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
S
Sathya Perla 已提交
2092 2093
		skb->len += curr_frag_len;
		skb->data_len += curr_frag_len;
E
Eric Dumazet 已提交
2094
		skb->truesize += rx_frag_size;
2095
		remaining -= curr_frag_len;
A
Ajit Khaparde 已提交
2096
		page_info->page = NULL;
S
Sathya Perla 已提交
2097
	}
2098
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
2099 2100
}

2101
/* Process the RX completion indicated by rxcp when GRO is disabled */
2102
static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi,
S
Sathya Perla 已提交
2103
				struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
2104
{
S
Sathya Perla 已提交
2105
	struct be_adapter *adapter = rxo->adapter;
2106
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
2107
	struct sk_buff *skb;
2108

2109
	skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
2110
	if (unlikely(!skb)) {
2111
		rx_stats(rxo)->rx_drops_no_skbs++;
S
Sathya Perla 已提交
2112
		be_rx_compl_discard(rxo, rxcp);
S
Sathya Perla 已提交
2113 2114 2115
		return;
	}

S
Sathya Perla 已提交
2116
	skb_fill_rx_data(rxo, skb, rxcp);
S
Sathya Perla 已提交
2117

2118
	if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
2119
		skb->ip_summed = CHECKSUM_UNNECESSARY;
S
Somnath Kotur 已提交
2120 2121
	else
		skb_checksum_none_assert(skb);
S
Sathya Perla 已提交
2122

2123
	skb->protocol = eth_type_trans(skb, netdev);
2124
	skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
S
Sathya Perla 已提交
2125
	if (netdev->features & NETIF_F_RXHASH)
T
Tom Herbert 已提交
2126
		skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2127

2128
	skb->csum_level = rxcp->tunneled;
2129
	skb_mark_napi_id(skb, napi);
S
Sathya Perla 已提交
2130

2131
	if (rxcp->vlanf)
2132
		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
A
Ajit Khaparde 已提交
2133 2134

	netif_receive_skb(skb);
S
Sathya Perla 已提交
2135 2136
}

2137
/* Process the RX completion indicated by rxcp when GRO is enabled */
J
Jingoo Han 已提交
2138 2139 2140
static void be_rx_compl_process_gro(struct be_rx_obj *rxo,
				    struct napi_struct *napi,
				    struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
2141
{
S
Sathya Perla 已提交
2142
	struct be_adapter *adapter = rxo->adapter;
S
Sathya Perla 已提交
2143
	struct be_rx_page_info *page_info;
2144
	struct sk_buff *skb = NULL;
2145 2146
	u16 remaining, curr_frag_len;
	u16 i, j;
2147

S
Sathya Perla 已提交
2148
	skb = napi_get_frags(napi);
2149
	if (!skb) {
S
Sathya Perla 已提交
2150
		be_rx_compl_discard(rxo, rxcp);
2151 2152 2153
		return;
	}

2154 2155
	remaining = rxcp->pkt_size;
	for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
2156
		page_info = get_rx_page_info(rxo);
S
Sathya Perla 已提交
2157 2158 2159

		curr_frag_len = min(remaining, rx_frag_size);

2160 2161 2162 2163
		/* 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++;
2164
			skb_frag_set_page(skb, j, page_info->page);
2165 2166
			skb_shinfo(skb)->frags[j].page_offset =
							page_info->page_offset;
E
Eric Dumazet 已提交
2167
			skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2168 2169 2170
		} else {
			put_page(page_info->page);
		}
E
Eric Dumazet 已提交
2171
		skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
E
Eric Dumazet 已提交
2172
		skb->truesize += rx_frag_size;
2173
		remaining -= curr_frag_len;
S
Sathya Perla 已提交
2174 2175
		memset(page_info, 0, sizeof(*page_info));
	}
2176
	BUG_ON(j > MAX_SKB_FRAGS);
S
Sathya Perla 已提交
2177

2178
	skb_shinfo(skb)->nr_frags = j + 1;
2179 2180
	skb->len = rxcp->pkt_size;
	skb->data_len = rxcp->pkt_size;
2181
	skb->ip_summed = CHECKSUM_UNNECESSARY;
2182
	skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
A
Ajit Khaparde 已提交
2183
	if (adapter->netdev->features & NETIF_F_RXHASH)
T
Tom Herbert 已提交
2184
		skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2185

2186
	skb->csum_level = rxcp->tunneled;
2187
	skb_mark_napi_id(skb, napi);
2188

2189
	if (rxcp->vlanf)
2190
		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
A
Ajit Khaparde 已提交
2191

S
Sathya Perla 已提交
2192
	napi_gro_frags(napi);
2193 2194
}

S
Sathya Perla 已提交
2195 2196
static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
				 struct be_rx_compl_info *rxcp)
2197
{
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
	rxcp->pkt_size = GET_RX_COMPL_V1_BITS(pktsize, compl);
	rxcp->vlanf = GET_RX_COMPL_V1_BITS(vtp, compl);
	rxcp->err = GET_RX_COMPL_V1_BITS(err, compl);
	rxcp->tcpf = GET_RX_COMPL_V1_BITS(tcpf, compl);
	rxcp->udpf = GET_RX_COMPL_V1_BITS(udpf, compl);
	rxcp->ip_csum = GET_RX_COMPL_V1_BITS(ipcksm, compl);
	rxcp->l4_csum = GET_RX_COMPL_V1_BITS(l4_cksm, compl);
	rxcp->ipv6 = GET_RX_COMPL_V1_BITS(ip_version, compl);
	rxcp->num_rcvd = GET_RX_COMPL_V1_BITS(numfrags, compl);
	rxcp->pkt_type = GET_RX_COMPL_V1_BITS(cast_enc, compl);
	rxcp->rss_hash = GET_RX_COMPL_V1_BITS(rsshash, compl);
2209
	if (rxcp->vlanf) {
2210 2211
		rxcp->qnq = GET_RX_COMPL_V1_BITS(qnq, compl);
		rxcp->vlan_tag = GET_RX_COMPL_V1_BITS(vlan_tag, compl);
2212
	}
2213
	rxcp->port = GET_RX_COMPL_V1_BITS(port, compl);
2214
	rxcp->tunneled =
2215
		GET_RX_COMPL_V1_BITS(tunneled, compl);
2216 2217
}

S
Sathya Perla 已提交
2218 2219
static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
				 struct be_rx_compl_info *rxcp)
2220
{
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
	rxcp->pkt_size = GET_RX_COMPL_V0_BITS(pktsize, compl);
	rxcp->vlanf = GET_RX_COMPL_V0_BITS(vtp, compl);
	rxcp->err = GET_RX_COMPL_V0_BITS(err, compl);
	rxcp->tcpf = GET_RX_COMPL_V0_BITS(tcpf, compl);
	rxcp->udpf = GET_RX_COMPL_V0_BITS(udpf, compl);
	rxcp->ip_csum = GET_RX_COMPL_V0_BITS(ipcksm, compl);
	rxcp->l4_csum = GET_RX_COMPL_V0_BITS(l4_cksm, compl);
	rxcp->ipv6 = GET_RX_COMPL_V0_BITS(ip_version, compl);
	rxcp->num_rcvd = GET_RX_COMPL_V0_BITS(numfrags, compl);
	rxcp->pkt_type = GET_RX_COMPL_V0_BITS(cast_enc, compl);
	rxcp->rss_hash = GET_RX_COMPL_V0_BITS(rsshash, compl);
2232
	if (rxcp->vlanf) {
2233 2234
		rxcp->qnq = GET_RX_COMPL_V0_BITS(qnq, compl);
		rxcp->vlan_tag = GET_RX_COMPL_V0_BITS(vlan_tag, compl);
2235
	}
2236 2237
	rxcp->port = GET_RX_COMPL_V0_BITS(port, compl);
	rxcp->ip_frag = GET_RX_COMPL_V0_BITS(ip_frag, compl);
2238 2239 2240 2241 2242 2243 2244
}

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

2246 2247 2248 2249
	/* 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 已提交
2250

2251 2252
	rmb();
	be_dws_le_to_cpu(compl, sizeof(*compl));
S
Sathya Perla 已提交
2253

2254
	if (adapter->be3_native)
S
Sathya Perla 已提交
2255
		be_parse_rx_compl_v1(compl, rxcp);
2256
	else
S
Sathya Perla 已提交
2257
		be_parse_rx_compl_v0(compl, rxcp);
S
Sathya Perla 已提交
2258

2259 2260 2261
	if (rxcp->ip_frag)
		rxcp->l4_csum = 0;

2262
	if (rxcp->vlanf) {
2263 2264 2265 2266 2267
		/* In QNQ modes, if qnq bit is not set, then the packet was
		 * tagged only with the transparent outer vlan-tag and must
		 * not be treated as a vlan packet by host
		 */
		if (be_is_qnq_mode(adapter) && !rxcp->qnq)
2268
			rxcp->vlanf = 0;
S
Sathya Perla 已提交
2269

2270
		if (!lancer_chip(adapter))
2271
			rxcp->vlan_tag = swab16(rxcp->vlan_tag);
S
Sathya Perla 已提交
2272

2273
		if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
2274
		    !test_bit(rxcp->vlan_tag, adapter->vids))
2275 2276
			rxcp->vlanf = 0;
	}
2277 2278 2279

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

2281
	queue_tail_inc(&rxo->cq);
S
Sathya Perla 已提交
2282 2283 2284
	return rxcp;
}

2285
static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
S
Sathya Perla 已提交
2286 2287
{
	u32 order = get_order(size);
2288

S
Sathya Perla 已提交
2289
	if (order > 0)
2290 2291
		gfp |= __GFP_COMP;
	return  alloc_pages(gfp, order);
S
Sathya Perla 已提交
2292 2293 2294 2295 2296 2297
}

/*
 * Allocate a page, split it to fragments of size rx_frag_size and post as
 * receive buffers to BE
 */
2298
static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp, u32 frags_needed)
S
Sathya Perla 已提交
2299
{
2300
	struct be_adapter *adapter = rxo->adapter;
2301
	struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
2302
	struct be_queue_info *rxq = &rxo->q;
S
Sathya Perla 已提交
2303
	struct page *pagep = NULL;
2304
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
2305 2306
	struct be_eth_rx_d *rxd;
	u64 page_dmaaddr = 0, frag_dmaaddr;
2307
	u32 posted, page_offset = 0, notify = 0;
S
Sathya Perla 已提交
2308

2309
	page_info = &rxo->page_info_tbl[rxq->head];
2310
	for (posted = 0; posted < frags_needed && !page_info->page; posted++) {
S
Sathya Perla 已提交
2311
		if (!pagep) {
2312
			pagep = be_alloc_pages(adapter->big_page_size, gfp);
S
Sathya Perla 已提交
2313
			if (unlikely(!pagep)) {
2314
				rx_stats(rxo)->rx_post_fail++;
S
Sathya Perla 已提交
2315 2316
				break;
			}
2317 2318
			page_dmaaddr = dma_map_page(dev, pagep, 0,
						    adapter->big_page_size,
I
Ivan Vecera 已提交
2319
						    DMA_FROM_DEVICE);
2320 2321 2322
			if (dma_mapping_error(dev, page_dmaaddr)) {
				put_page(pagep);
				pagep = NULL;
2323
				adapter->drv_stats.dma_map_errors++;
2324 2325
				break;
			}
2326
			page_offset = 0;
S
Sathya Perla 已提交
2327 2328
		} else {
			get_page(pagep);
2329
			page_offset += rx_frag_size;
S
Sathya Perla 已提交
2330
		}
2331
		page_info->page_offset = page_offset;
S
Sathya Perla 已提交
2332 2333 2334
		page_info->page = pagep;

		rxd = queue_head_node(rxq);
2335
		frag_dmaaddr = page_dmaaddr + page_info->page_offset;
S
Sathya Perla 已提交
2336 2337 2338 2339 2340 2341 2342
		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;
2343 2344 2345 2346
			page_info->last_frag = true;
			dma_unmap_addr_set(page_info, bus, page_dmaaddr);
		} else {
			dma_unmap_addr_set(page_info, bus, frag_dmaaddr);
S
Sathya Perla 已提交
2347
		}
2348 2349 2350

		prev_page_info = page_info;
		queue_head_inc(rxq);
S
Sathya Perla 已提交
2351
		page_info = &rxo->page_info_tbl[rxq->head];
S
Sathya Perla 已提交
2352
	}
2353 2354 2355 2356 2357 2358 2359 2360

	/* Mark the last frag of a page when we break out of the above loop
	 * with no more slots available in the RXQ
	 */
	if (pagep) {
		prev_page_info->last_frag = true;
		dma_unmap_addr_set(prev_page_info, bus, page_dmaaddr);
	}
S
Sathya Perla 已提交
2361 2362 2363

	if (posted) {
		atomic_add(posted, &rxq->used);
2364 2365
		if (rxo->rx_post_starved)
			rxo->rx_post_starved = false;
2366
		do {
2367
			notify = min(MAX_NUM_POST_ERX_DB, posted);
2368 2369 2370
			be_rxq_notify(adapter, rxq->id, notify);
			posted -= notify;
		} while (posted);
2371 2372
	} else if (atomic_read(&rxq->used) == 0) {
		/* Let be_worker replenish when memory is available */
2373
		rxo->rx_post_starved = true;
S
Sathya Perla 已提交
2374 2375 2376
	}
}

2377
static struct be_tx_compl_info *be_tx_compl_get(struct be_tx_obj *txo)
S
Sathya Perla 已提交
2378
{
2379 2380 2381
	struct be_queue_info *tx_cq = &txo->cq;
	struct be_tx_compl_info *txcp = &txo->txcp;
	struct be_eth_tx_compl *compl = queue_tail_node(tx_cq);
S
Sathya Perla 已提交
2382

2383
	if (compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
S
Sathya Perla 已提交
2384 2385
		return NULL;

2386
	/* Ensure load ordering of valid bit dword and other dwords below */
2387
	rmb();
2388
	be_dws_le_to_cpu(compl, sizeof(*compl));
S
Sathya Perla 已提交
2389

2390 2391
	txcp->status = GET_TX_COMPL_BITS(status, compl);
	txcp->end_index = GET_TX_COMPL_BITS(wrb_index, compl);
S
Sathya Perla 已提交
2392

2393
	compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
S
Sathya Perla 已提交
2394 2395 2396 2397
	queue_tail_inc(tx_cq);
	return txcp;
}

2398
static u16 be_tx_compl_process(struct be_adapter *adapter,
2399
			       struct be_tx_obj *txo, u16 last_index)
S
Sathya Perla 已提交
2400
{
2401
	struct sk_buff **sent_skbs = txo->sent_skb_list;
2402
	struct be_queue_info *txq = &txo->q;
2403 2404 2405
	u16 frag_index, num_wrbs = 0;
	struct sk_buff *skb = NULL;
	bool unmap_skb_hdr = false;
2406
	struct be_eth_wrb *wrb;
S
Sathya Perla 已提交
2407

2408
	do {
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418
		if (sent_skbs[txq->tail]) {
			/* Free skb from prev req */
			if (skb)
				dev_consume_skb_any(skb);
			skb = sent_skbs[txq->tail];
			sent_skbs[txq->tail] = NULL;
			queue_tail_inc(txq);  /* skip hdr wrb */
			num_wrbs++;
			unmap_skb_hdr = true;
		}
2419
		wrb = queue_tail_node(txq);
2420
		frag_index = txq->tail;
I
Ivan Vecera 已提交
2421
		unmap_tx_frag(&adapter->pdev->dev, wrb,
2422
			      (unmap_skb_hdr && skb_headlen(skb)));
2423
		unmap_skb_hdr = false;
S
Sathya Perla 已提交
2424
		queue_tail_inc(txq);
2425 2426 2427
		num_wrbs++;
	} while (frag_index != last_index);
	dev_consume_skb_any(skb);
S
Sathya Perla 已提交
2428

2429
	return num_wrbs;
S
Sathya Perla 已提交
2430 2431
}

S
Sathya Perla 已提交
2432 2433
/* Return the number of events in the event queue */
static inline int events_get(struct be_eq_obj *eqo)
2434
{
S
Sathya Perla 已提交
2435 2436
	struct be_eq_entry *eqe;
	int num = 0;
2437

S
Sathya Perla 已提交
2438 2439 2440 2441
	do {
		eqe = queue_tail_node(&eqo->q);
		if (eqe->evt == 0)
			break;
2442

S
Sathya Perla 已提交
2443 2444 2445 2446 2447 2448 2449
		rmb();
		eqe->evt = 0;
		num++;
		queue_tail_inc(&eqo->q);
	} while (true);

	return num;
2450 2451
}

S
Sathya Perla 已提交
2452 2453
/* Leaves the EQ is disarmed state */
static void be_eq_clean(struct be_eq_obj *eqo)
2454
{
S
Sathya Perla 已提交
2455
	int num = events_get(eqo);
2456

2457
	be_eq_notify(eqo->adapter, eqo->q.id, false, true, num, 0);
2458 2459
}

2460 2461
/* Free posted rx buffers that were not used */
static void be_rxq_clean(struct be_rx_obj *rxo)
S
Sathya Perla 已提交
2462
{
2463
	struct be_queue_info *rxq = &rxo->q;
2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477
	struct be_rx_page_info *page_info;

	while (atomic_read(&rxq->used) > 0) {
		page_info = get_rx_page_info(rxo);
		put_page(page_info->page);
		memset(page_info, 0, sizeof(*page_info));
	}
	BUG_ON(atomic_read(&rxq->used));
	rxq->tail = 0;
	rxq->head = 0;
}

static void be_rx_cq_clean(struct be_rx_obj *rxo)
{
2478
	struct be_queue_info *rx_cq = &rxo->cq;
2479
	struct be_rx_compl_info *rxcp;
2480 2481
	struct be_adapter *adapter = rxo->adapter;
	int flush_wait = 0;
S
Sathya Perla 已提交
2482

2483 2484 2485 2486 2487 2488 2489 2490
	/* Consume pending rx completions.
	 * Wait for the flush completion (identified by zero num_rcvd)
	 * to arrive. Notify CQ even when there are no more CQ entries
	 * for HW to flush partially coalesced CQ entries.
	 * In Lancer, there is no need to wait for flush compl.
	 */
	for (;;) {
		rxcp = be_rx_compl_get(rxo);
K
Kalesh AP 已提交
2491
		if (!rxcp) {
2492 2493 2494
			if (lancer_chip(adapter))
				break;

2495 2496 2497
			if (flush_wait++ > 50 ||
			    be_check_error(adapter,
					   BE_ERROR_HW)) {
2498 2499 2500 2501 2502 2503 2504 2505
				dev_warn(&adapter->pdev->dev,
					 "did not receive flush compl\n");
				break;
			}
			be_cq_notify(adapter, rx_cq->id, true, 0);
			mdelay(1);
		} else {
			be_rx_compl_discard(rxo, rxcp);
2506
			be_cq_notify(adapter, rx_cq->id, false, 1);
2507 2508 2509
			if (rxcp->num_rcvd == 0)
				break;
		}
S
Sathya Perla 已提交
2510 2511
	}

2512 2513
	/* After cleanup, leave the CQ in unarmed state */
	be_cq_notify(adapter, rx_cq->id, false, 0);
S
Sathya Perla 已提交
2514 2515
}

S
Sathya Perla 已提交
2516
static void be_tx_compl_clean(struct be_adapter *adapter)
S
Sathya Perla 已提交
2517
{
2518 2519
	u16 end_idx, notified_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
	struct device *dev = &adapter->pdev->dev;
2520
	struct be_tx_compl_info *txcp;
S
Sathya Perla 已提交
2521
	struct be_queue_info *txq;
2522
	struct be_tx_obj *txo;
S
Sathya Perla 已提交
2523
	int i, pending_txqs;
2524

2525
	/* Stop polling for compls when HW has been silent for 10ms */
2526
	do {
S
Sathya Perla 已提交
2527 2528 2529
		pending_txqs = adapter->num_tx_qs;

		for_all_tx_queues(adapter, txo, i) {
2530 2531
			cmpl = 0;
			num_wrbs = 0;
S
Sathya Perla 已提交
2532
			txq = &txo->q;
2533 2534 2535 2536
			while ((txcp = be_tx_compl_get(txo))) {
				num_wrbs +=
					be_tx_compl_process(adapter, txo,
							    txcp->end_index);
S
Sathya Perla 已提交
2537 2538 2539 2540 2541
				cmpl++;
			}
			if (cmpl) {
				be_cq_notify(adapter, txo->cq.id, false, cmpl);
				atomic_sub(num_wrbs, &txq->used);
2542
				timeo = 0;
S
Sathya Perla 已提交
2543
			}
2544
			if (!be_is_tx_compl_pending(txo))
S
Sathya Perla 已提交
2545
				pending_txqs--;
2546 2547
		}

2548 2549
		if (pending_txqs == 0 || ++timeo > 10 ||
		    be_check_error(adapter, BE_ERROR_HW))
2550 2551 2552 2553 2554
			break;

		mdelay(1);
	} while (true);

2555
	/* Free enqueued TX that was never notified to HW */
S
Sathya Perla 已提交
2556 2557 2558
	for_all_tx_queues(adapter, txo, i) {
		txq = &txo->q;

2559 2560 2561 2562
		if (atomic_read(&txq->used)) {
			dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n",
				 i, atomic_read(&txq->used));
			notified_idx = txq->tail;
S
Sathya Perla 已提交
2563
			end_idx = txq->tail;
2564 2565 2566 2567 2568
			index_adv(&end_idx, atomic_read(&txq->used) - 1,
				  txq->len);
			/* Use the tx-compl process logic to handle requests
			 * that were not sent to the HW.
			 */
S
Sathya Perla 已提交
2569 2570
			num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
			atomic_sub(num_wrbs, &txq->used);
2571 2572 2573 2574 2575 2576 2577
			BUG_ON(atomic_read(&txq->used));
			txo->pend_wrb_cnt = 0;
			/* Since hw was never notified of these requests,
			 * reset TXQ indices
			 */
			txq->head = notified_idx;
			txq->tail = notified_idx;
S
Sathya Perla 已提交
2578
		}
2579
	}
S
Sathya Perla 已提交
2580 2581
}

S
Sathya Perla 已提交
2582 2583 2584 2585 2586 2587
static void be_evt_queues_destroy(struct be_adapter *adapter)
{
	struct be_eq_obj *eqo;
	int i;

	for_all_evt_queues(adapter, eqo, i) {
2588 2589
		if (eqo->q.created) {
			be_eq_clean(eqo);
S
Sathya Perla 已提交
2590
			be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
2591
			napi_hash_del(&eqo->napi);
2592
			netif_napi_del(&eqo->napi);
2593
			free_cpumask_var(eqo->affinity_mask);
2594
		}
S
Sathya Perla 已提交
2595 2596 2597 2598 2599 2600 2601 2602
		be_queue_free(adapter, &eqo->q);
	}
}

static int be_evt_queues_create(struct be_adapter *adapter)
{
	struct be_queue_info *eq;
	struct be_eq_obj *eqo;
2603
	struct be_aic_obj *aic;
S
Sathya Perla 已提交
2604 2605
	int i, rc;

2606 2607
	adapter->num_evt_qs = min_t(u16, num_irqs(adapter),
				    adapter->cfg_num_qs);
S
Sathya Perla 已提交
2608 2609

	for_all_evt_queues(adapter, eqo, i) {
2610
		int numa_node = dev_to_node(&adapter->pdev->dev);
2611

2612
		aic = &adapter->aic_obj[i];
S
Sathya Perla 已提交
2613 2614
		eqo->adapter = adapter;
		eqo->idx = i;
2615 2616
		aic->max_eqd = BE_MAX_EQD;
		aic->enable = true;
S
Sathya Perla 已提交
2617 2618 2619

		eq = &eqo->q;
		rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
2620
				    sizeof(struct be_eq_entry));
S
Sathya Perla 已提交
2621 2622 2623
		if (rc)
			return rc;

S
Sathya Perla 已提交
2624
		rc = be_cmd_eq_create(adapter, eqo);
S
Sathya Perla 已提交
2625 2626
		if (rc)
			return rc;
2627 2628 2629 2630 2631 2632 2633 2634

		if (!zalloc_cpumask_var(&eqo->affinity_mask, GFP_KERNEL))
			return -ENOMEM;
		cpumask_set_cpu(cpumask_local_spread(i, numa_node),
				eqo->affinity_mask);
		netif_napi_add(adapter->netdev, &eqo->napi, be_poll,
			       BE_NAPI_WEIGHT);
		napi_hash_add(&eqo->napi);
S
Sathya Perla 已提交
2635
	}
2636
	return 0;
S
Sathya Perla 已提交
2637 2638
}

2639 2640 2641 2642
static void be_mcc_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;

2643
	q = &adapter->mcc_obj.q;
2644
	if (q->created)
2645
		be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
2646 2647
	be_queue_free(adapter, q);

2648
	q = &adapter->mcc_obj.cq;
2649
	if (q->created)
2650
		be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2651 2652 2653 2654 2655 2656 2657 2658
	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;

2659
	cq = &adapter->mcc_obj.cq;
2660
	if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
2661
			   sizeof(struct be_mcc_compl)))
2662 2663
		goto err;

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

2668
	q = &adapter->mcc_obj.q;
2669 2670 2671
	if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
		goto mcc_cq_destroy;

2672
	if (be_cmd_mccq_create(adapter, q, cq))
2673 2674 2675 2676 2677 2678 2679
		goto mcc_q_free;

	return 0;

mcc_q_free:
	be_queue_free(adapter, q);
mcc_cq_destroy:
2680
	be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
2681 2682 2683 2684 2685 2686
mcc_cq_free:
	be_queue_free(adapter, cq);
err:
	return -1;
}

S
Sathya Perla 已提交
2687 2688 2689
static void be_tx_queues_destroy(struct be_adapter *adapter)
{
	struct be_queue_info *q;
2690 2691
	struct be_tx_obj *txo;
	u8 i;
S
Sathya Perla 已提交
2692

2693 2694 2695 2696 2697
	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 已提交
2698

2699 2700 2701 2702 2703
		q = &txo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);
	}
S
Sathya Perla 已提交
2704 2705
}

2706
static int be_tx_qs_create(struct be_adapter *adapter)
S
Sathya Perla 已提交
2707
{
S
Sathya Perla 已提交
2708
	struct be_queue_info *cq;
2709
	struct be_tx_obj *txo;
S
Sathya Perla 已提交
2710
	struct be_eq_obj *eqo;
2711
	int status, i;
S
Sathya Perla 已提交
2712

2713
	adapter->num_tx_qs = min(adapter->num_evt_qs, be_max_txqs(adapter));
2714

S
Sathya Perla 已提交
2715 2716 2717 2718 2719 2720
	for_all_tx_queues(adapter, txo, i) {
		cq = &txo->cq;
		status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
					sizeof(struct be_eth_tx_compl));
		if (status)
			return status;
2721

2722 2723 2724
		u64_stats_init(&txo->stats.sync);
		u64_stats_init(&txo->stats.sync_compl);

S
Sathya Perla 已提交
2725 2726 2727
		/* If num_evt_qs is less than num_tx_qs, then more than
		 * one txq share an eq
		 */
S
Sathya Perla 已提交
2728 2729
		eqo = &adapter->eq_obj[i % adapter->num_evt_qs];
		status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3);
S
Sathya Perla 已提交
2730 2731
		if (status)
			return status;
S
Sathya Perla 已提交
2732

S
Sathya Perla 已提交
2733 2734 2735 2736
		status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
					sizeof(struct be_eth_wrb));
		if (status)
			return status;
S
Sathya Perla 已提交
2737

V
Vasundhara Volam 已提交
2738
		status = be_cmd_txq_create(adapter, txo);
S
Sathya Perla 已提交
2739 2740
		if (status)
			return status;
S
Sathya Perla 已提交
2741 2742 2743

		netif_set_xps_queue(adapter->netdev, eqo->affinity_mask,
				    eqo->idx);
2744
	}
S
Sathya Perla 已提交
2745

S
Sathya Perla 已提交
2746 2747
	dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
		 adapter->num_tx_qs);
S
Sathya Perla 已提交
2748
	return 0;
S
Sathya Perla 已提交
2749 2750
}

S
Sathya Perla 已提交
2751
static void be_rx_cqs_destroy(struct be_adapter *adapter)
S
Sathya Perla 已提交
2752 2753
{
	struct be_queue_info *q;
2754 2755 2756 2757 2758 2759 2760 2761
	struct be_rx_obj *rxo;
	int i;

	for_all_rx_queues(adapter, rxo, i) {
		q = &rxo->cq;
		if (q->created)
			be_cmd_q_destroy(adapter, q, QTYPE_CQ);
		be_queue_free(adapter, q);
2762 2763 2764
	}
}

S
Sathya Perla 已提交
2765
static int be_rx_cqs_create(struct be_adapter *adapter)
S
Sathya Perla 已提交
2766
{
S
Sathya Perla 已提交
2767
	struct be_queue_info *eq, *cq;
2768 2769
	struct be_rx_obj *rxo;
	int rc, i;
S
Sathya Perla 已提交
2770

2771
	/* We can create as many RSS rings as there are EQs. */
2772
	adapter->num_rss_qs = adapter->num_evt_qs;
2773

2774 2775 2776 2777 2778 2779 2780 2781
	/* We'll use RSS only if atleast 2 RSS rings are supported. */
	if (adapter->num_rss_qs <= 1)
		adapter->num_rss_qs = 0;

	adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq;

	/* When the interface is not capable of RSS rings (and there is no
	 * need to create a default RXQ) we'll still need one RXQ
S
Sathya Perla 已提交
2782
	 */
2783 2784
	if (adapter->num_rx_qs == 0)
		adapter->num_rx_qs = 1;
2785

S
Sathya Perla 已提交
2786
	adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
2787 2788 2789 2790
	for_all_rx_queues(adapter, rxo, i) {
		rxo->adapter = adapter;
		cq = &rxo->cq;
		rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
2791
				    sizeof(struct be_eth_rx_compl));
2792
		if (rc)
S
Sathya Perla 已提交
2793
			return rc;
2794

2795
		u64_stats_init(&rxo->stats.sync);
S
Sathya Perla 已提交
2796 2797
		eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
		rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
2798
		if (rc)
S
Sathya Perla 已提交
2799
			return rc;
2800
	}
S
Sathya Perla 已提交
2801

S
Sathya Perla 已提交
2802
	dev_info(&adapter->pdev->dev,
2803
		 "created %d RX queue(s)\n", adapter->num_rx_qs);
S
Sathya Perla 已提交
2804
	return 0;
2805 2806
}

S
Sathya Perla 已提交
2807 2808
static irqreturn_t be_intx(int irq, void *dev)
{
2809 2810 2811
	struct be_eq_obj *eqo = dev;
	struct be_adapter *adapter = eqo->adapter;
	int num_evts = 0;
S
Sathya Perla 已提交
2812

2813 2814 2815 2816 2817 2818 2819
	/* IRQ is not expected when NAPI is scheduled as the EQ
	 * will not be armed.
	 * But, this can happen on Lancer INTx where it takes
	 * a while to de-assert INTx or in BE2 where occasionaly
	 * an interrupt may be raised even when EQ is unarmed.
	 * If NAPI is already scheduled, then counting & notifying
	 * events will orphan them.
2820
	 */
2821
	if (napi_schedule_prep(&eqo->napi)) {
2822
		num_evts = events_get(eqo);
2823 2824 2825 2826
		__napi_schedule(&eqo->napi);
		if (num_evts)
			eqo->spurious_intr = 0;
	}
2827
	be_eq_notify(adapter, eqo->q.id, false, true, num_evts, 0);
2828

2829 2830 2831
	/* Return IRQ_HANDLED only for the the first spurious intr
	 * after a valid intr to stop the kernel from branding
	 * this irq as a bad one!
2832
	 */
2833 2834 2835 2836
	if (num_evts || eqo->spurious_intr++ == 0)
		return IRQ_HANDLED;
	else
		return IRQ_NONE;
S
Sathya Perla 已提交
2837 2838
}

S
Sathya Perla 已提交
2839
static irqreturn_t be_msix(int irq, void *dev)
S
Sathya Perla 已提交
2840
{
S
Sathya Perla 已提交
2841
	struct be_eq_obj *eqo = dev;
S
Sathya Perla 已提交
2842

2843
	be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
2844
	napi_schedule(&eqo->napi);
S
Sathya Perla 已提交
2845 2846 2847
	return IRQ_HANDLED;
}

2848
static inline bool do_gro(struct be_rx_compl_info *rxcp)
S
Sathya Perla 已提交
2849
{
2850
	return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false;
S
Sathya Perla 已提交
2851 2852
}

S
Sathya Perla 已提交
2853
static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
2854
			 int budget, int polling)
S
Sathya Perla 已提交
2855
{
2856 2857
	struct be_adapter *adapter = rxo->adapter;
	struct be_queue_info *rx_cq = &rxo->cq;
2858
	struct be_rx_compl_info *rxcp;
S
Sathya Perla 已提交
2859
	u32 work_done;
2860
	u32 frags_consumed = 0;
S
Sathya Perla 已提交
2861 2862

	for (work_done = 0; work_done < budget; work_done++) {
2863
		rxcp = be_rx_compl_get(rxo);
S
Sathya Perla 已提交
2864 2865 2866
		if (!rxcp)
			break;

2867 2868 2869 2870 2871 2872
		/* Is it a flush compl that has no data */
		if (unlikely(rxcp->num_rcvd == 0))
			goto loop_continue;

		/* Discard compl with partial DMA Lancer B0 */
		if (unlikely(!rxcp->pkt_size)) {
S
Sathya Perla 已提交
2873
			be_rx_compl_discard(rxo, rxcp);
2874 2875 2876 2877 2878 2879 2880
			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 &&
2881
			     !lancer_chip(adapter))) {
S
Sathya Perla 已提交
2882
			be_rx_compl_discard(rxo, rxcp);
2883
			goto loop_continue;
2884
		}
2885

2886 2887
		/* Don't do gro when we're busy_polling */
		if (do_gro(rxcp) && polling != BUSY_POLLING)
S
Sathya Perla 已提交
2888
			be_rx_compl_process_gro(rxo, napi, rxcp);
2889
		else
2890 2891
			be_rx_compl_process(rxo, napi, rxcp);

2892
loop_continue:
2893
		frags_consumed += rxcp->num_rcvd;
2894
		be_rx_stats_update(rxo, rxcp);
S
Sathya Perla 已提交
2895 2896
	}

S
Sathya Perla 已提交
2897 2898
	if (work_done) {
		be_cq_notify(adapter, rx_cq->id, true, work_done);
2899

2900 2901 2902 2903 2904
		/* When an rx-obj gets into post_starved state, just
		 * let be_worker do the posting.
		 */
		if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM &&
		    !rxo->rx_post_starved)
2905 2906 2907
			be_post_rx_frags(rxo, GFP_ATOMIC,
					 max_t(u32, MAX_RX_POST,
					       frags_consumed));
S
Sathya Perla 已提交
2908
	}
S
Sathya Perla 已提交
2909

S
Sathya Perla 已提交
2910 2911 2912
	return work_done;
}

2913
static inline void be_update_tx_err(struct be_tx_obj *txo, u8 status)
2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
{
	switch (status) {
	case BE_TX_COMP_HDR_PARSE_ERR:
		tx_stats(txo)->tx_hdr_parse_err++;
		break;
	case BE_TX_COMP_NDMA_ERR:
		tx_stats(txo)->tx_dma_err++;
		break;
	case BE_TX_COMP_ACL_ERR:
		tx_stats(txo)->tx_spoof_check_err++;
		break;
	}
}

2928
static inline void lancer_update_tx_err(struct be_tx_obj *txo, u8 status)
2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949
{
	switch (status) {
	case LANCER_TX_COMP_LSO_ERR:
		tx_stats(txo)->tx_tso_err++;
		break;
	case LANCER_TX_COMP_HSW_DROP_MAC_ERR:
	case LANCER_TX_COMP_HSW_DROP_VLAN_ERR:
		tx_stats(txo)->tx_spoof_check_err++;
		break;
	case LANCER_TX_COMP_QINQ_ERR:
		tx_stats(txo)->tx_qinq_err++;
		break;
	case LANCER_TX_COMP_PARITY_ERR:
		tx_stats(txo)->tx_internal_parity_err++;
		break;
	case LANCER_TX_COMP_DMA_ERR:
		tx_stats(txo)->tx_dma_err++;
		break;
	}
}

S
Sathya Perla 已提交
2950 2951
static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
			  int idx)
S
Sathya Perla 已提交
2952
{
S
Sathya Perla 已提交
2953
	int num_wrbs = 0, work_done = 0;
2954
	struct be_tx_compl_info *txcp;
S
Sathya Perla 已提交
2955

2956 2957
	while ((txcp = be_tx_compl_get(txo))) {
		num_wrbs += be_tx_compl_process(adapter, txo, txcp->end_index);
S
Sathya Perla 已提交
2958
		work_done++;
2959

2960
		if (txcp->status) {
2961
			if (lancer_chip(adapter))
2962
				lancer_update_tx_err(txo, txcp->status);
2963
			else
2964
				be_update_tx_err(txo, txcp->status);
2965
		}
S
Sathya Perla 已提交
2966
	}
S
Sathya Perla 已提交
2967

S
Sathya Perla 已提交
2968 2969 2970
	if (work_done) {
		be_cq_notify(adapter, txo->cq.id, true, work_done);
		atomic_sub(num_wrbs, &txo->q.used);
2971

S
Sathya Perla 已提交
2972 2973 2974
		/* As Tx wrbs have been freed up, wake up netdev queue
		 * if it was stopped due to lack of tx wrbs.  */
		if (__netif_subqueue_stopped(adapter->netdev, idx) &&
2975
		    be_can_txq_wake(txo)) {
S
Sathya Perla 已提交
2976
			netif_wake_subqueue(adapter->netdev, idx);
2977
		}
S
Sathya Perla 已提交
2978 2979 2980 2981

		u64_stats_update_begin(&tx_stats(txo)->sync_compl);
		tx_stats(txo)->tx_compl += work_done;
		u64_stats_update_end(&tx_stats(txo)->sync_compl);
S
Sathya Perla 已提交
2982
	}
S
Sathya Perla 已提交
2983
}
S
Sathya Perla 已提交
2984

2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
#ifdef CONFIG_NET_RX_BUSY_POLL
static inline bool be_lock_napi(struct be_eq_obj *eqo)
{
	bool status = true;

	spin_lock(&eqo->lock); /* BH is already disabled */
	if (eqo->state & BE_EQ_LOCKED) {
		WARN_ON(eqo->state & BE_EQ_NAPI);
		eqo->state |= BE_EQ_NAPI_YIELD;
		status = false;
	} else {
		eqo->state = BE_EQ_NAPI;
	}
	spin_unlock(&eqo->lock);
	return status;
}

static inline void be_unlock_napi(struct be_eq_obj *eqo)
{
	spin_lock(&eqo->lock); /* BH is already disabled */

	WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));
	eqo->state = BE_EQ_IDLE;

	spin_unlock(&eqo->lock);
}

static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
{
	bool status = true;

	spin_lock_bh(&eqo->lock);
	if (eqo->state & BE_EQ_LOCKED) {
		eqo->state |= BE_EQ_POLL_YIELD;
		status = false;
	} else {
		eqo->state |= BE_EQ_POLL;
	}
	spin_unlock_bh(&eqo->lock);
	return status;
}

static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
{
	spin_lock_bh(&eqo->lock);

	WARN_ON(eqo->state & (BE_EQ_NAPI));
	eqo->state = BE_EQ_IDLE;

	spin_unlock_bh(&eqo->lock);
}

static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
{
	spin_lock_init(&eqo->lock);
	eqo->state = BE_EQ_IDLE;
}

static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
{
	local_bh_disable();

	/* It's enough to just acquire napi lock on the eqo to stop
	 * be_busy_poll() from processing any queueus.
	 */
	while (!be_lock_napi(eqo))
		mdelay(1);

	local_bh_enable();
}

#else /* CONFIG_NET_RX_BUSY_POLL */

static inline bool be_lock_napi(struct be_eq_obj *eqo)
{
	return true;
}

static inline void be_unlock_napi(struct be_eq_obj *eqo)
{
}

static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
{
	return false;
}

static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
{
}

static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
{
}

static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
{
}
#endif /* CONFIG_NET_RX_BUSY_POLL */

3085
int be_poll(struct napi_struct *napi, int budget)
S
Sathya Perla 已提交
3086 3087 3088
{
	struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
	struct be_adapter *adapter = eqo->adapter;
3089
	int max_work = 0, work, i, num_evts;
3090
	struct be_rx_obj *rxo;
3091
	struct be_tx_obj *txo;
3092
	u32 mult_enc = 0;
S
Sathya Perla 已提交
3093

3094 3095
	num_evts = events_get(eqo);

3096 3097
	for_all_tx_queues_on_eq(adapter, eqo, txo, i)
		be_process_tx(adapter, txo, i);
S
Sathya Perla 已提交
3098

3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110
	if (be_lock_napi(eqo)) {
		/* This loop will iterate twice for EQ0 in which
		 * completions of the last RXQ (default one) are also processed
		 * For other EQs the loop iterates only once
		 */
		for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
			work = be_process_rx(rxo, napi, budget, NAPI_POLLING);
			max_work = max(work, max_work);
		}
		be_unlock_napi(eqo);
	} else {
		max_work = budget;
S
Sathya Perla 已提交
3111
	}
S
Sathya Perla 已提交
3112

S
Sathya Perla 已提交
3113 3114
	if (is_mcc_eqo(eqo))
		be_process_mcc(adapter);
3115

S
Sathya Perla 已提交
3116 3117
	if (max_work < budget) {
		napi_complete(napi);
3118 3119 3120 3121 3122 3123 3124 3125 3126

		/* Skyhawk EQ_DB has a provision to set the rearm to interrupt
		 * delay via a delay multiplier encoding value
		 */
		if (skyhawk_chip(adapter))
			mult_enc = be_get_eq_delay_mult_enc(eqo);

		be_eq_notify(adapter, eqo->q.id, true, false, num_evts,
			     mult_enc);
S
Sathya Perla 已提交
3127 3128
	} else {
		/* As we'll continue in polling mode, count and clear events */
3129
		be_eq_notify(adapter, eqo->q.id, false, false, num_evts, 0);
3130
	}
S
Sathya Perla 已提交
3131
	return max_work;
S
Sathya Perla 已提交
3132 3133
}

3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155
#ifdef CONFIG_NET_RX_BUSY_POLL
static int be_busy_poll(struct napi_struct *napi)
{
	struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
	struct be_adapter *adapter = eqo->adapter;
	struct be_rx_obj *rxo;
	int i, work = 0;

	if (!be_lock_busy_poll(eqo))
		return LL_FLUSH_BUSY;

	for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
		work = be_process_rx(rxo, napi, 4, BUSY_POLLING);
		if (work)
			break;
	}

	be_unlock_busy_poll(eqo);
	return work;
}
#endif

3156
void be_detect_error(struct be_adapter *adapter)
3157
{
3158 3159
	u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
	u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
3160
	u32 i;
3161
	struct device *dev = &adapter->pdev->dev;
3162

3163
	if (be_check_error(adapter, BE_ERROR_HW))
3164 3165
		return;

3166 3167 3168
	if (lancer_chip(adapter)) {
		sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
		if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
3169
			be_set_error(adapter, BE_ERROR_UE);
3170
			sliport_err1 = ioread32(adapter->db +
3171
						SLIPORT_ERROR1_OFFSET);
3172
			sliport_err2 = ioread32(adapter->db +
3173
						SLIPORT_ERROR2_OFFSET);
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186
			/* Do not log error messages if its a FW reset */
			if (sliport_err1 == SLIPORT_ERROR_FW_RESET1 &&
			    sliport_err2 == SLIPORT_ERROR_FW_RESET2) {
				dev_info(dev, "Firmware update in progress\n");
			} else {
				dev_err(dev, "Error detected in the card\n");
				dev_err(dev, "ERR: sliport status 0x%x\n",
					sliport_status);
				dev_err(dev, "ERR: sliport error1 0x%x\n",
					sliport_err1);
				dev_err(dev, "ERR: sliport error2 0x%x\n",
					sliport_err2);
			}
3187 3188
		}
	} else {
3189 3190 3191 3192 3193 3194
		ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW);
		ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH);
		ue_lo_mask = ioread32(adapter->pcicfg +
				      PCICFG_UE_STATUS_LOW_MASK);
		ue_hi_mask = ioread32(adapter->pcicfg +
				      PCICFG_UE_STATUS_HI_MASK);
3195

3196 3197
		ue_lo = (ue_lo & ~ue_lo_mask);
		ue_hi = (ue_hi & ~ue_hi_mask);
3198

3199 3200 3201 3202
		/* On certain platforms BE hardware can indicate spurious UEs.
		 * Allow HW to stop working completely in case of a real UE.
		 * Hence not setting the hw_error for UE detection.
		 */
3203

3204 3205 3206 3207 3208
		if (ue_lo || ue_hi) {
			dev_err(dev,
				"Unrecoverable Error detected in the adapter");
			dev_err(dev, "Please reboot server to recover");
			if (skyhawk_chip(adapter))
3209 3210
				be_set_error(adapter, BE_ERROR_UE);

3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
			for (i = 0; ue_lo; ue_lo >>= 1, i++) {
				if (ue_lo & 1)
					dev_err(dev, "UE: %s bit set\n",
						ue_status_low_desc[i]);
			}
			for (i = 0; ue_hi; ue_hi >>= 1, i++) {
				if (ue_hi & 1)
					dev_err(dev, "UE: %s bit set\n",
						ue_status_hi_desc[i]);
			}
3221 3222 3223 3224
		}
	}
}

3225 3226
static void be_msix_disable(struct be_adapter *adapter)
{
3227
	if (msix_enabled(adapter)) {
3228
		pci_disable_msix(adapter->pdev);
3229
		adapter->num_msix_vec = 0;
3230
		adapter->num_msix_roce_vec = 0;
3231 3232 3233
	}
}

3234
static int be_msix_enable(struct be_adapter *adapter)
S
Sathya Perla 已提交
3235
{
3236
	int i, num_vec;
S
Sathya Perla 已提交
3237
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
3238

3239 3240 3241 3242 3243 3244 3245 3246 3247
	/* If RoCE is supported, program the max number of NIC vectors that
	 * may be configured via set-channels, along with vectors needed for
	 * RoCe. Else, just program the number we'll use initially.
	 */
	if (be_roce_supported(adapter))
		num_vec = min_t(int, 2 * be_max_eqs(adapter),
				2 * num_online_cpus());
	else
		num_vec = adapter->cfg_num_qs;
3248

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

3252 3253 3254 3255
	num_vec = pci_enable_msix_range(adapter->pdev, adapter->msix_entries,
					MIN_MSIX_VECTORS, num_vec);
	if (num_vec < 0)
		goto fail;
3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266

	if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) {
		adapter->num_msix_roce_vec = num_vec / 2;
		dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n",
			 adapter->num_msix_roce_vec);
	}

	adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec;

	dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n",
		 adapter->num_msix_vec);
3267
	return 0;
3268 3269 3270 3271 3272

fail:
	dev_warn(dev, "MSIx enable failed\n");

	/* INTx is not supported in VFs, so fail probe if enable_msix fails */
3273
	if (be_virtfn(adapter))
3274 3275
		return num_vec;
	return 0;
S
Sathya Perla 已提交
3276 3277
}

3278
static inline int be_msix_vec_get(struct be_adapter *adapter,
3279
				  struct be_eq_obj *eqo)
3280
{
S
Sathya Perla 已提交
3281
	return adapter->msix_entries[eqo->msix_idx].vector;
3282
}
S
Sathya Perla 已提交
3283

3284 3285
static int be_msix_register(struct be_adapter *adapter)
{
S
Sathya Perla 已提交
3286 3287 3288
	struct net_device *netdev = adapter->netdev;
	struct be_eq_obj *eqo;
	int status, i, vec;
S
Sathya Perla 已提交
3289

S
Sathya Perla 已提交
3290 3291 3292 3293
	for_all_evt_queues(adapter, eqo, i) {
		sprintf(eqo->desc, "%s-q%d", netdev->name, i);
		vec = be_msix_vec_get(adapter, eqo);
		status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
3294 3295
		if (status)
			goto err_msix;
3296 3297

		irq_set_affinity_hint(vec, eqo->affinity_mask);
3298
	}
3299

S
Sathya Perla 已提交
3300
	return 0;
3301
err_msix:
S
Sathya Perla 已提交
3302 3303 3304
	for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
		free_irq(be_msix_vec_get(adapter, eqo), eqo);
	dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
3305
		 status);
3306
	be_msix_disable(adapter);
S
Sathya Perla 已提交
3307 3308 3309 3310 3311 3312 3313 3314
	return status;
}

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

3315
	if (msix_enabled(adapter)) {
S
Sathya Perla 已提交
3316 3317 3318
		status = be_msix_register(adapter);
		if (status == 0)
			goto done;
3319
		/* INTx is not supported for VF */
3320
		if (be_virtfn(adapter))
3321
			return status;
S
Sathya Perla 已提交
3322 3323
	}

3324
	/* INTx: only the first EQ is used */
S
Sathya Perla 已提交
3325 3326
	netdev->irq = adapter->pdev->irq;
	status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
3327
			     &adapter->eq_obj[0]);
S
Sathya Perla 已提交
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340
	if (status) {
		dev_err(&adapter->pdev->dev,
			"INTx request IRQ failed - err %d\n", status);
		return status;
	}
done:
	adapter->isr_registered = true;
	return 0;
}

static void be_irq_unregister(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
3341
	struct be_eq_obj *eqo;
3342
	int i, vec;
S
Sathya Perla 已提交
3343 3344 3345 3346 3347

	if (!adapter->isr_registered)
		return;

	/* INTx */
3348
	if (!msix_enabled(adapter)) {
3349
		free_irq(netdev->irq, &adapter->eq_obj[0]);
S
Sathya Perla 已提交
3350 3351 3352 3353
		goto done;
	}

	/* MSIx */
3354 3355 3356 3357 3358
	for_all_evt_queues(adapter, eqo, i) {
		vec = be_msix_vec_get(adapter, eqo);
		irq_set_affinity_hint(vec, NULL);
		free_irq(vec, eqo);
	}
3359

S
Sathya Perla 已提交
3360 3361 3362 3363
done:
	adapter->isr_registered = false;
}

S
Sathya Perla 已提交
3364
static void be_rx_qs_destroy(struct be_adapter *adapter)
3365 3366 3367 3368 3369 3370 3371 3372
{
	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) {
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385
			/* If RXQs are destroyed while in an "out of buffer"
			 * state, there is a possibility of an HW stall on
			 * Lancer. So, post 64 buffers to each queue to relieve
			 * the "out of buffer" condition.
			 * Make sure there's space in the RXQ before posting.
			 */
			if (lancer_chip(adapter)) {
				be_rx_cq_clean(rxo);
				if (atomic_read(&q->used) == 0)
					be_post_rx_frags(rxo, GFP_KERNEL,
							 MAX_RX_POST);
			}

3386
			be_cmd_rxq_destroy(adapter, q);
S
Sathya Perla 已提交
3387
			be_rx_cq_clean(rxo);
3388
			be_rxq_clean(rxo);
3389
		}
S
Sathya Perla 已提交
3390
		be_queue_free(adapter, q);
3391 3392 3393
	}
}

3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
static void be_disable_if_filters(struct be_adapter *adapter)
{
	be_cmd_pmac_del(adapter, adapter->if_handle,
			adapter->pmac_id[0], 0);

	be_clear_uc_list(adapter);

	/* The IFACE flags are enabled in the open path and cleared
	 * in the close path. When a VF gets detached from the host and
	 * assigned to a VM the following happens:
	 *	- VF's IFACE flags get cleared in the detach path
	 *	- IFACE create is issued by the VF in the attach path
	 * Due to a bug in the BE3/Skyhawk-R FW
	 * (Lancer FW doesn't have the bug), the IFACE capability flags
	 * specified along with the IFACE create cmd issued by a VF are not
	 * honoured by FW.  As a consequence, if a *new* driver
	 * (that enables/disables IFACE flags in open/close)
	 * is loaded in the host and an *old* driver is * used by a VM/VF,
	 * the IFACE gets created *without* the needed flags.
	 * To avoid this, disable RX-filter flags only for Lancer.
	 */
	if (lancer_chip(adapter)) {
		be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF);
		adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS;
	}
}

3421 3422 3423
static int be_close(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
3424 3425
	struct be_eq_obj *eqo;
	int i;
3426

3427 3428 3429 3430 3431 3432
	/* This protection is needed as be_close() may be called even when the
	 * adapter is in cleared state (after eeh perm failure)
	 */
	if (!(adapter->flags & BE_FLAGS_SETUP_DONE))
		return 0;

3433 3434
	be_disable_if_filters(adapter);

3435 3436
	if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
		for_all_evt_queues(adapter, eqo, i) {
3437
			napi_disable(&eqo->napi);
3438 3439
			be_disable_busy_poll(eqo);
		}
3440
		adapter->flags &= ~BE_FLAGS_NAPI_ENABLED;
3441
	}
3442 3443 3444 3445 3446 3447

	be_async_mcc_disable(adapter);

	/* Wait for all pending tx completions to arrive so that
	 * all tx skbs are freed.
	 */
S
Sathya Perla 已提交
3448
	netif_tx_disable(netdev);
3449
	be_tx_compl_clean(adapter);
3450 3451

	be_rx_qs_destroy(adapter);
3452

3453
	for_all_evt_queues(adapter, eqo, i) {
S
Sathya Perla 已提交
3454 3455 3456 3457 3458
		if (msix_enabled(adapter))
			synchronize_irq(be_msix_vec_get(adapter, eqo));
		else
			synchronize_irq(netdev->irq);
		be_eq_clean(eqo);
3459 3460
	}

3461 3462
	be_irq_unregister(adapter);

3463 3464 3465
	return 0;
}

S
Sathya Perla 已提交
3466
static int be_rx_qs_create(struct be_adapter *adapter)
3467
{
3468 3469
	struct rss_info *rss = &adapter->rss_info;
	u8 rss_key[RSS_HASH_KEY_LEN];
3470
	struct be_rx_obj *rxo;
3471
	int rc, i, j;
3472 3473

	for_all_rx_queues(adapter, rxo, i) {
S
Sathya Perla 已提交
3474 3475 3476 3477 3478 3479
		rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
				    sizeof(struct be_eth_rx_d));
		if (rc)
			return rc;
	}

3480 3481 3482 3483 3484 3485 3486 3487
	if (adapter->need_def_rxq || !adapter->num_rss_qs) {
		rxo = default_rxo(adapter);
		rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
				       rx_frag_size, adapter->if_handle,
				       false, &rxo->rss_id);
		if (rc)
			return rc;
	}
S
Sathya Perla 已提交
3488 3489

	for_all_rss_queues(adapter, rxo, i) {
3490
		rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
S
Sathya Perla 已提交
3491 3492
				       rx_frag_size, adapter->if_handle,
				       true, &rxo->rss_id);
3493 3494 3495 3496 3497
		if (rc)
			return rc;
	}

	if (be_multi_rxq(adapter)) {
3498
		for (j = 0; j < RSS_INDIR_TABLE_LEN; j += adapter->num_rss_qs) {
3499
			for_all_rss_queues(adapter, rxo, i) {
3500
				if ((j + i) >= RSS_INDIR_TABLE_LEN)
3501
					break;
3502 3503
				rss->rsstable[j + i] = rxo->rss_id;
				rss->rss_queue[j + i] = i;
3504 3505
			}
		}
3506 3507
		rss->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 |
			RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6;
3508 3509

		if (!BEx_chip(adapter))
3510 3511
			rss->rss_flags |= RSS_ENABLE_UDP_IPV4 |
				RSS_ENABLE_UDP_IPV6;
3512 3513
	} else {
		/* Disable RSS, if only default RX Q is created */
3514
		rss->rss_flags = RSS_ENABLE_NONE;
3515
	}
3516

3517
	netdev_rss_key_fill(rss_key, RSS_HASH_KEY_LEN);
3518
	rc = be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags,
3519
			       RSS_INDIR_TABLE_LEN, rss_key);
3520
	if (rc) {
3521
		rss->rss_flags = RSS_ENABLE_NONE;
3522
		return rc;
3523 3524
	}

3525
	memcpy(rss->rss_hkey, rss_key, RSS_HASH_KEY_LEN);
3526

3527 3528 3529
	/* Post 1 less than RXQ-len to avoid head being equal to tail,
	 * which is a queue empty condition
	 */
S
Sathya Perla 已提交
3530
	for_all_rx_queues(adapter, rxo, i)
3531 3532
		be_post_rx_frags(rxo, GFP_KERNEL, RX_Q_LEN - 1);

3533 3534 3535
	return 0;
}

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
static int be_enable_if_filters(struct be_adapter *adapter)
{
	int status;

	status = be_cmd_rx_filter(adapter, BE_IF_EN_FLAGS, ON);
	if (status)
		return status;

	/* For BE3 VFs, the PF programs the initial MAC address */
	if (!(BEx_chip(adapter) && be_virtfn(adapter))) {
		status = be_cmd_pmac_add(adapter, adapter->netdev->dev_addr,
					 adapter->if_handle,
					 &adapter->pmac_id[0], 0);
		if (status)
			return status;
	}

	if (adapter->vlans_added)
		be_vid_config(adapter);

	be_set_rx_mode(adapter->netdev);

	return 0;
}

S
Sathya Perla 已提交
3561 3562 3563
static int be_open(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
3564
	struct be_eq_obj *eqo;
3565
	struct be_rx_obj *rxo;
S
Sathya Perla 已提交
3566
	struct be_tx_obj *txo;
3567
	u8 link_status;
3568
	int status, i;
3569

S
Sathya Perla 已提交
3570
	status = be_rx_qs_create(adapter);
3571 3572 3573
	if (status)
		goto err;

3574 3575 3576 3577
	status = be_enable_if_filters(adapter);
	if (status)
		goto err;

3578 3579 3580
	status = be_irq_register(adapter);
	if (status)
		goto err;
3581

S
Sathya Perla 已提交
3582
	for_all_rx_queues(adapter, rxo, i)
3583
		be_cq_notify(adapter, rxo->cq.id, true, 0);
3584

S
Sathya Perla 已提交
3585 3586 3587
	for_all_tx_queues(adapter, txo, i)
		be_cq_notify(adapter, txo->cq.id, true, 0);

3588 3589
	be_async_mcc_enable(adapter);

S
Sathya Perla 已提交
3590 3591
	for_all_evt_queues(adapter, eqo, i) {
		napi_enable(&eqo->napi);
3592
		be_enable_busy_poll(eqo);
3593
		be_eq_notify(adapter, eqo->q.id, true, true, 0, 0);
S
Sathya Perla 已提交
3594
	}
3595
	adapter->flags |= BE_FLAGS_NAPI_ENABLED;
S
Sathya Perla 已提交
3596

3597
	status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
3598 3599 3600
	if (!status)
		be_link_status_update(adapter, link_status);

S
Sathya Perla 已提交
3601
	netif_tx_start_all_queues(netdev);
3602
#ifdef CONFIG_BE2NET_VXLAN
3603 3604
	if (skyhawk_chip(adapter))
		vxlan_get_rx_port(netdev);
3605 3606
#endif

3607 3608 3609 3610
	return 0;
err:
	be_close(adapter->netdev);
	return -EIO;
3611 3612
}

3613 3614
static int be_setup_wol(struct be_adapter *adapter, bool enable)
{
3615
	struct device *dev = &adapter->pdev->dev;
3616 3617
	struct be_dma_mem cmd;
	u8 mac[ETH_ALEN];
3618
	int status;
3619

3620
	eth_zero_addr(mac);
3621 3622

	cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
3623
	cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
K
Kalesh AP 已提交
3624
	if (!cmd.va)
3625
		return -ENOMEM;
3626 3627 3628

	if (enable) {
		status = pci_write_config_dword(adapter->pdev,
3629 3630
						PCICFG_PM_CONTROL_OFFSET,
						PCICFG_PM_CONTROL_MASK);
3631
		if (status) {
3632 3633
			dev_err(dev, "Could not enable Wake-on-lan\n");
			goto err;
3634 3635
		}
	} else {
3636
		ether_addr_copy(mac, adapter->netdev->dev_addr);
3637 3638
	}

3639 3640 3641 3642 3643
	status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
	pci_enable_wake(adapter->pdev, PCI_D3hot, enable);
	pci_enable_wake(adapter->pdev, PCI_D3cold, enable);
err:
	dma_free_coherent(dev, cmd.size, cmd.va, cmd.dma);
3644 3645 3646
	return status;
}

3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659
static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
{
	u32 addr;

	addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);

	mac[5] = (u8)(addr & 0xFF);
	mac[4] = (u8)((addr >> 8) & 0xFF);
	mac[3] = (u8)((addr >> 16) & 0xFF);
	/* Use the OUI from the current MAC address */
	memcpy(mac, adapter->netdev->dev_addr, 3);
}

3660 3661 3662 3663 3664 3665
/*
 * 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.
 */
3666
static int be_vf_eth_addr_config(struct be_adapter *adapter)
3667
{
3668
	u32 vf;
3669
	int status = 0;
3670
	u8 mac[ETH_ALEN];
3671
	struct be_vf_cfg *vf_cfg;
3672 3673 3674

	be_vf_eth_addr_generate(adapter, mac);

3675
	for_all_vfs(adapter, vf_cfg, vf) {
3676
		if (BEx_chip(adapter))
3677
			status = be_cmd_pmac_add(adapter, mac,
3678 3679
						 vf_cfg->if_handle,
						 &vf_cfg->pmac_id, vf + 1);
3680 3681 3682
		else
			status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
						vf + 1);
3683

3684 3685
		if (status)
			dev_err(&adapter->pdev->dev,
3686 3687
				"Mac address assignment failed for VF %d\n",
				vf);
3688
		else
3689
			memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3690 3691 3692 3693 3694 3695

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

3696 3697 3698 3699 3700 3701 3702
static int be_vfs_mac_query(struct be_adapter *adapter)
{
	int status, vf;
	u8 mac[ETH_ALEN];
	struct be_vf_cfg *vf_cfg;

	for_all_vfs(adapter, vf_cfg, vf) {
3703 3704 3705
		status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id,
					       mac, vf_cfg->if_handle,
					       false, vf+1);
3706 3707 3708 3709 3710 3711 3712
		if (status)
			return status;
		memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
	}
	return 0;
}

3713
static void be_vf_clear(struct be_adapter *adapter)
3714
{
3715
	struct be_vf_cfg *vf_cfg;
3716 3717
	u32 vf;

3718
	if (pci_vfs_assigned(adapter->pdev)) {
3719 3720
		dev_warn(&adapter->pdev->dev,
			 "VFs are assigned to VMs: not disabling VFs\n");
3721 3722 3723
		goto done;
	}

3724 3725
	pci_disable_sriov(adapter->pdev);

3726
	for_all_vfs(adapter, vf_cfg, vf) {
3727
		if (BEx_chip(adapter))
3728 3729
			be_cmd_pmac_del(adapter, vf_cfg->if_handle,
					vf_cfg->pmac_id, vf + 1);
3730 3731 3732
		else
			be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle,
				       vf + 1);
3733

3734 3735
		be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
	}
3736 3737 3738
done:
	kfree(adapter->vf_cfg);
	adapter->num_vfs = 0;
3739
	adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED;
3740 3741
}

3742 3743 3744 3745 3746 3747 3748 3749
static void be_clear_queues(struct be_adapter *adapter)
{
	be_mcc_queues_destroy(adapter);
	be_rx_cqs_destroy(adapter);
	be_tx_queues_destroy(adapter);
	be_evt_queues_destroy(adapter);
}

3750
static void be_cancel_worker(struct be_adapter *adapter)
3751
{
3752 3753 3754 3755
	if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
		cancel_delayed_work_sync(&adapter->work);
		adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
	}
3756 3757
}

3758 3759 3760 3761 3762 3763 3764 3765
static void be_cancel_err_detection(struct be_adapter *adapter)
{
	if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) {
		cancel_delayed_work_sync(&adapter->be_err_detection_work);
		adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED;
	}
}

3766
#ifdef CONFIG_BE2NET_VXLAN
3767 3768
static void be_disable_vxlan_offloads(struct be_adapter *adapter)
{
3769 3770
	struct net_device *netdev = adapter->netdev;

3771 3772 3773 3774 3775 3776 3777 3778 3779
	if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)
		be_cmd_manage_iface(adapter, adapter->if_handle,
				    OP_CONVERT_TUNNEL_TO_NORMAL);

	if (adapter->vxlan_port)
		be_cmd_set_vxlan_port(adapter, 0);

	adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS;
	adapter->vxlan_port = 0;
3780 3781 3782

	netdev->hw_enc_features = 0;
	netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3783
	netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3784
}
3785
#endif
3786

3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
static u16 be_calculate_vf_qs(struct be_adapter *adapter, u16 num_vfs)
{
	struct be_resources res = adapter->pool_res;
	u16 num_vf_qs = 1;

	/* Distribute the queue resources equally among the PF and it's VFs
	 * Do not distribute queue resources in multi-channel configuration.
	 */
	if (num_vfs && !be_is_mc(adapter)) {
		/* If number of VFs requested is 8 less than max supported,
		 * assign 8 queue pairs to the PF and divide the remaining
		 * resources evenly among the VFs
		 */
		if (num_vfs < (be_max_vfs(adapter) - 8))
			num_vf_qs = (res.max_rss_qs - 8) / num_vfs;
		else
			num_vf_qs = res.max_rss_qs / num_vfs;

		/* Skyhawk-R chip supports only MAX_RSS_IFACES RSS capable
		 * interfaces per port. Provide RSS on VFs, only if number
		 * of VFs requested is less than MAX_RSS_IFACES limit.
		 */
		if (num_vfs >= MAX_RSS_IFACES)
			num_vf_qs = 1;
	}
	return num_vf_qs;
}

3815 3816
static int be_clear(struct be_adapter *adapter)
{
3817 3818 3819
	struct pci_dev *pdev = adapter->pdev;
	u16 num_vf_qs;

3820
	be_cancel_worker(adapter);
3821

3822
	if (sriov_enabled(adapter))
3823 3824
		be_vf_clear(adapter);

3825 3826 3827
	/* Re-configure FW to distribute resources evenly across max-supported
	 * number of VFs, only when VFs are not already enabled.
	 */
3828 3829
	if (skyhawk_chip(adapter) && be_physfn(adapter) &&
	    !pci_vfs_assigned(pdev)) {
3830 3831
		num_vf_qs = be_calculate_vf_qs(adapter,
					       pci_sriov_get_totalvfs(pdev));
3832
		be_cmd_set_sriov_config(adapter, adapter->pool_res,
3833 3834 3835
					pci_sriov_get_totalvfs(pdev),
					num_vf_qs);
	}
3836

3837
#ifdef CONFIG_BE2NET_VXLAN
3838
	be_disable_vxlan_offloads(adapter);
3839
#endif
3840 3841
	kfree(adapter->pmac_id);
	adapter->pmac_id = NULL;
3842

3843
	be_cmd_if_destroy(adapter, adapter->if_handle,  0);
3844

3845
	be_clear_queues(adapter);
3846

S
Sathya Perla 已提交
3847
	be_msix_disable(adapter);
3848
	adapter->flags &= ~BE_FLAGS_SETUP_DONE;
3849 3850 3851
	return 0;
}

3852
static int be_vfs_if_create(struct be_adapter *adapter)
3853
{
3854
	struct be_resources res = {0};
3855
	u32 cap_flags, en_flags, vf;
3856
	struct be_vf_cfg *vf_cfg;
3857
	int status;
3858

3859
	/* If a FW profile exists, then cap_flags are updated */
3860
	cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3861
		    BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3862

3863
	for_all_vfs(adapter, vf_cfg, vf) {
3864 3865
		if (!BE3_chip(adapter)) {
			status = be_cmd_get_profile_config(adapter, &res,
3866
							   RESOURCE_LIMITS,
3867
							   vf + 1);
3868
			if (!status) {
3869
				cap_flags = res.if_cap_flags;
3870 3871 3872 3873 3874
				/* Prevent VFs from enabling VLAN promiscuous
				 * mode
				 */
				cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
			}
3875
		}
3876

3877 3878 3879 3880 3881 3882
		en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
					BE_IF_FLAGS_BROADCAST |
					BE_IF_FLAGS_MULTICAST |
					BE_IF_FLAGS_PASS_L3L4_ERRORS);
		status = be_cmd_if_create(adapter, cap_flags, en_flags,
					  &vf_cfg->if_handle, vf + 1);
3883
		if (status)
3884
			return status;
3885
	}
3886 3887

	return 0;
3888 3889
}

3890
static int be_vf_setup_init(struct be_adapter *adapter)
3891
{
3892
	struct be_vf_cfg *vf_cfg;
3893 3894
	int vf;

3895 3896 3897 3898 3899
	adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
				  GFP_KERNEL);
	if (!adapter->vf_cfg)
		return -ENOMEM;

3900 3901 3902
	for_all_vfs(adapter, vf_cfg, vf) {
		vf_cfg->if_handle = -1;
		vf_cfg->pmac_id = -1;
3903
	}
3904
	return 0;
3905 3906
}

3907 3908
static int be_vf_setup(struct be_adapter *adapter)
{
3909
	struct device *dev = &adapter->pdev->dev;
3910
	struct be_vf_cfg *vf_cfg;
3911
	int status, old_vfs, vf;
3912
	bool spoofchk;
3913

3914
	old_vfs = pci_num_vf(adapter->pdev);
3915 3916 3917 3918

	status = be_vf_setup_init(adapter);
	if (status)
		goto err;
3919

3920 3921 3922 3923 3924 3925
	if (old_vfs) {
		for_all_vfs(adapter, vf_cfg, vf) {
			status = be_cmd_get_if_id(adapter, vf_cfg, vf);
			if (status)
				goto err;
		}
3926

3927 3928 3929 3930
		status = be_vfs_mac_query(adapter);
		if (status)
			goto err;
	} else {
3931 3932 3933 3934
		status = be_vfs_if_create(adapter);
		if (status)
			goto err;

3935 3936 3937 3938
		status = be_vf_eth_addr_config(adapter);
		if (status)
			goto err;
	}
3939

3940
	for_all_vfs(adapter, vf_cfg, vf) {
3941
		/* Allow VFs to programs MAC/VLAN filters */
3942 3943 3944
		status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges,
						  vf + 1);
		if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
3945
			status = be_cmd_set_fn_privileges(adapter,
3946
							  vf_cfg->privileges |
3947 3948
							  BE_PRIV_FILTMGMT,
							  vf + 1);
3949 3950
			if (!status) {
				vf_cfg->privileges |= BE_PRIV_FILTMGMT;
3951 3952
				dev_info(dev, "VF%d has FILTMGMT privilege\n",
					 vf);
3953
			}
3954 3955
		}

3956 3957 3958
		/* Allow full available bandwidth */
		if (!old_vfs)
			be_cmd_config_qos(adapter, 0, 0, vf + 1);
3959

3960 3961 3962 3963 3964 3965
		status = be_cmd_get_hsw_config(adapter, NULL, vf + 1,
					       vf_cfg->if_handle, NULL,
					       &spoofchk);
		if (!status)
			vf_cfg->spoofchk = spoofchk;

3966
		if (!old_vfs) {
3967
			be_cmd_enable_vf(adapter, vf + 1);
3968 3969 3970 3971
			be_cmd_set_logical_link_config(adapter,
						       IFLA_VF_LINK_STATE_AUTO,
						       vf+1);
		}
3972
	}
3973 3974 3975 3976 3977 3978 3979 3980 3981

	if (!old_vfs) {
		status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
		if (status) {
			dev_err(dev, "SRIOV enable failed\n");
			adapter->num_vfs = 0;
			goto err;
		}
	}
3982 3983

	adapter->flags |= BE_FLAGS_SRIOV_ENABLED;
3984 3985
	return 0;
err:
3986 3987
	dev_err(dev, "VF setup failed\n");
	be_vf_clear(adapter);
3988 3989 3990
	return status;
}

3991 3992 3993 3994
/* Converting function_mode bits on BE3 to SH mc_type enums */

static u8 be_convert_mc_type(u32 function_mode)
{
3995
	if (function_mode & VNIC_MODE && function_mode & QNQ_MODE)
3996
		return vNIC1;
3997
	else if (function_mode & QNQ_MODE)
3998 3999 4000 4001 4002 4003 4004 4005 4006
		return FLEX10;
	else if (function_mode & VNIC_MODE)
		return vNIC2;
	else if (function_mode & UMC_ENABLED)
		return UMC;
	else
		return MC_NONE;
}

4007 4008 4009 4010
/* On BE2/BE3 FW does not suggest the supported limits */
static void BEx_get_resources(struct be_adapter *adapter,
			      struct be_resources *res)
{
4011
	bool use_sriov = adapter->num_vfs ? 1 : 0;
4012 4013 4014 4015 4016 4017

	if (be_physfn(adapter))
		res->max_uc_mac = BE_UC_PMAC_COUNT;
	else
		res->max_uc_mac = BE_VF_UC_PMAC_COUNT;

4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031
	adapter->mc_type = be_convert_mc_type(adapter->function_mode);

	if (be_is_mc(adapter)) {
		/* Assuming that there are 4 channels per port,
		 * when multi-channel is enabled
		 */
		if (be_is_qnq_mode(adapter))
			res->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
		else
			/* In a non-qnq multichannel mode, the pvid
			 * takes up one vlan entry
			 */
			res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1;
	} else {
4032
		res->max_vlans = BE_NUM_VLANS_SUPPORTED;
4033 4034
	}

4035 4036
	res->max_mcast_mac = BE_MAX_MC;

4037 4038 4039 4040 4041
	/* 1) For BE3 1Gb ports, FW does not support multiple TXQs
	 * 2) Create multiple TX rings on a BE3-R multi-channel interface
	 *    *only* if it is RSS-capable.
	 */
	if (BE2_chip(adapter) || use_sriov ||  (adapter->port_num > 1) ||
4042 4043 4044
	    be_virtfn(adapter) ||
	    (be_is_mc(adapter) &&
	     !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) {
4045
		res->max_tx_qs = 1;
4046 4047 4048 4049 4050 4051
	} else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) {
		struct be_resources super_nic_res = {0};

		/* On a SuperNIC profile, the driver needs to use the
		 * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits
		 */
4052 4053
		be_cmd_get_profile_config(adapter, &super_nic_res,
					  RESOURCE_LIMITS, 0);
4054 4055 4056
		/* Some old versions of BE3 FW don't report max_tx_qs value */
		res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS;
	} else {
4057
		res->max_tx_qs = BE3_MAX_TX_QS;
4058
	}
4059 4060 4061 4062 4063 4064 4065

	if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
	    !use_sriov && be_physfn(adapter))
		res->max_rss_qs = (adapter->be3_native) ?
					   BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
	res->max_rx_qs = res->max_rss_qs + 1;

4066
	if (be_physfn(adapter))
4067
		res->max_evt_qs = (be_max_vfs(adapter) > 0) ?
4068 4069 4070
					BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS;
	else
		res->max_evt_qs = 1;
4071 4072

	res->if_cap_flags = BE_IF_CAP_FLAGS_WANT;
4073
	res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS;
4074 4075 4076 4077
	if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS))
		res->if_cap_flags &= ~BE_IF_FLAGS_RSS;
}

4078 4079 4080
static void be_setup_init(struct be_adapter *adapter)
{
	adapter->vlan_prio_bmap = 0xff;
A
Ajit Khaparde 已提交
4081
	adapter->phy.link_speed = -1;
4082 4083
	adapter->if_handle = -1;
	adapter->be3_native = false;
4084
	adapter->if_flags = 0;
4085 4086 4087 4088
	if (be_physfn(adapter))
		adapter->cmd_privileges = MAX_PRIVILEGES;
	else
		adapter->cmd_privileges = MIN_PRIVILEGES;
4089 4090
}

4091 4092 4093
static int be_get_sriov_config(struct be_adapter *adapter)
{
	struct be_resources res = {0};
4094
	int max_vfs, old_vfs;
4095

4096
	be_cmd_get_profile_config(adapter, &res, RESOURCE_LIMITS, 0);
4097

4098
	/* Some old versions of BE3 FW don't report max_vfs value */
4099 4100 4101 4102 4103
	if (BE3_chip(adapter) && !res.max_vfs) {
		max_vfs = pci_sriov_get_totalvfs(adapter->pdev);
		res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0;
	}

4104
	adapter->pool_res = res;
4105

4106 4107 4108 4109
	/* If during previous unload of the driver, the VFs were not disabled,
	 * then we cannot rely on the PF POOL limits for the TotalVFs value.
	 * Instead use the TotalVFs value stored in the pci-dev struct.
	 */
4110 4111
	old_vfs = pci_num_vf(adapter->pdev);
	if (old_vfs) {
4112 4113 4114 4115 4116
		dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n",
			 old_vfs);

		adapter->pool_res.max_vfs =
			pci_sriov_get_totalvfs(adapter->pdev);
4117 4118 4119 4120 4121 4122
		adapter->num_vfs = old_vfs;
	}

	return 0;
}

4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148
static void be_alloc_sriov_res(struct be_adapter *adapter)
{
	int old_vfs = pci_num_vf(adapter->pdev);
	u16 num_vf_qs;
	int status;

	be_get_sriov_config(adapter);

	if (!old_vfs)
		pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter));

	/* When the HW is in SRIOV capable configuration, the PF-pool
	 * resources are given to PF during driver load, if there are no
	 * old VFs. This facility is not available in BE3 FW.
	 * Also, this is done by FW in Lancer chip.
	 */
	if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) {
		num_vf_qs = be_calculate_vf_qs(adapter, 0);
		status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0,
						 num_vf_qs);
		if (status)
			dev_err(&adapter->pdev->dev,
				"Failed to optimize SRIOV resources\n");
	}
}

4149
static int be_get_resources(struct be_adapter *adapter)
4150
{
4151 4152 4153
	struct device *dev = &adapter->pdev->dev;
	struct be_resources res = {0};
	int status;
4154

4155 4156 4157
	if (BEx_chip(adapter)) {
		BEx_get_resources(adapter, &res);
		adapter->res = res;
4158 4159
	}

4160 4161 4162 4163 4164 4165 4166 4167
	/* For Lancer, SH etc read per-function resource limits from FW.
	 * GET_FUNC_CONFIG returns per function guaranteed limits.
	 * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits
	 */
	if (!BEx_chip(adapter)) {
		status = be_cmd_get_func_config(adapter, &res);
		if (status)
			return status;
4168

4169 4170 4171 4172 4173
		/* If a deafault RXQ must be created, we'll use up one RSSQ*/
		if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs &&
		    !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS))
			res.max_rss_qs -= 1;

4174 4175 4176 4177
		/* If RoCE may be enabled stash away half the EQs for RoCE */
		if (be_roce_supported(adapter))
			res.max_evt_qs /= 2;
		adapter->res = res;
4178
	}
4179

4180 4181 4182 4183 4184 4185
	/* If FW supports RSS default queue, then skip creating non-RSS
	 * queue for non-IP traffic.
	 */
	adapter->need_def_rxq = (be_if_cap_flags(adapter) &
				 BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1;

S
Sathya Perla 已提交
4186 4187 4188 4189 4190 4191 4192 4193
	dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n",
		 be_max_txqs(adapter), be_max_rxqs(adapter),
		 be_max_rss(adapter), be_max_eqs(adapter),
		 be_max_vfs(adapter));
	dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n",
		 be_max_uc(adapter), be_max_mc(adapter),
		 be_max_vlans(adapter));

4194 4195 4196
	/* Sanitize cfg_num_qs based on HW and platform limits */
	adapter->cfg_num_qs = min_t(u16, netif_get_num_default_rss_queues(),
				    be_max_qs(adapter));
4197
	return 0;
4198 4199
}

4200 4201
static int be_get_config(struct be_adapter *adapter)
{
4202
	int status, level;
4203
	u16 profile_id;
4204

4205
	status = be_cmd_query_fw_cfg(adapter);
4206
	if (status)
4207
		return status;
4208

4209 4210 4211 4212 4213 4214 4215 4216
	if (BEx_chip(adapter)) {
		level = be_cmd_get_fw_log_level(adapter);
		adapter->msg_enable =
			level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
	}

	be_cmd_get_acpi_wol_cap(adapter);

4217 4218 4219
	be_cmd_query_port_name(adapter);

	if (be_physfn(adapter)) {
4220 4221 4222 4223
		status = be_cmd_get_active_profile(adapter, &profile_id);
		if (!status)
			dev_info(&adapter->pdev->dev,
				 "Using profile 0x%x\n", profile_id);
4224
	}
4225

4226 4227 4228
	status = be_get_resources(adapter);
	if (status)
		return status;
4229

4230 4231
	adapter->pmac_id = kcalloc(be_max_uc(adapter),
				   sizeof(*adapter->pmac_id), GFP_KERNEL);
4232 4233
	if (!adapter->pmac_id)
		return -ENOMEM;
4234

4235
	return 0;
4236 4237
}

4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254
static int be_mac_setup(struct be_adapter *adapter)
{
	u8 mac[ETH_ALEN];
	int status;

	if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
		status = be_cmd_get_perm_mac(adapter, mac);
		if (status)
			return status;

		memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
		memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
	}

	return 0;
}

4255 4256 4257 4258 4259 4260
static void be_schedule_worker(struct be_adapter *adapter)
{
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
	adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
}

4261 4262 4263 4264 4265 4266 4267
static void be_schedule_err_detection(struct be_adapter *adapter)
{
	schedule_delayed_work(&adapter->be_err_detection_work,
			      msecs_to_jiffies(1000));
	adapter->flags |= BE_FLAGS_ERR_DETECTION_SCHEDULED;
}

4268
static int be_setup_queues(struct be_adapter *adapter)
4269
{
4270
	struct net_device *netdev = adapter->netdev;
S
Sathya Perla 已提交
4271
	int status;
4272

4273
	status = be_evt_queues_create(adapter);
4274 4275
	if (status)
		goto err;
4276

4277
	status = be_tx_qs_create(adapter);
4278 4279
	if (status)
		goto err;
S
Sathya Perla 已提交
4280

4281
	status = be_rx_cqs_create(adapter);
S
Sathya Perla 已提交
4282
	if (status)
4283
		goto err;
S
Sathya Perla 已提交
4284

4285
	status = be_mcc_queues_create(adapter);
S
Sathya Perla 已提交
4286 4287 4288
	if (status)
		goto err;

4289 4290 4291 4292 4293 4294 4295 4296
	status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs);
	if (status)
		goto err;

	status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs);
	if (status)
		goto err;

4297 4298 4299 4300 4301 4302
	return 0;
err:
	dev_err(&adapter->pdev->dev, "queue_setup failed\n");
	return status;
}

4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338
int be_update_queues(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	int status;

	if (netif_running(netdev))
		be_close(netdev);

	be_cancel_worker(adapter);

	/* If any vectors have been shared with RoCE we cannot re-program
	 * the MSIx table.
	 */
	if (!adapter->num_msix_roce_vec)
		be_msix_disable(adapter);

	be_clear_queues(adapter);

	if (!msix_enabled(adapter)) {
		status = be_msix_enable(adapter);
		if (status)
			return status;
	}

	status = be_setup_queues(adapter);
	if (status)
		return status;

	be_schedule_worker(adapter);

	if (netif_running(netdev))
		status = be_open(netdev);

	return status;
}

4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349
static inline int fw_major_num(const char *fw_ver)
{
	int fw_major = 0, i;

	i = sscanf(fw_ver, "%d.", &fw_major);
	if (i != 1)
		return 0;

	return fw_major;
}

4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373
/* If any VFs are already enabled don't FLR the PF */
static bool be_reset_required(struct be_adapter *adapter)
{
	return pci_num_vf(adapter->pdev) ? false : true;
}

/* Wait for the FW to be ready and perform the required initialization */
static int be_func_init(struct be_adapter *adapter)
{
	int status;

	status = be_fw_wait_ready(adapter);
	if (status)
		return status;

	if (be_reset_required(adapter)) {
		status = be_cmd_reset_function(adapter);
		if (status)
			return status;

		/* Wait for interrupts to quiesce after an FLR */
		msleep(100);

		/* We can clear all errors when function reset succeeds */
4374
		be_clear_error(adapter, BE_CLEAR_ALL);
4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
	}

	/* Tell FW we're ready to fire cmds */
	status = be_cmd_fw_init(adapter);
	if (status)
		return status;

	/* Allow interrupts for other ULPs running on NIC function */
	be_intr_set(adapter, true);

	return 0;
}

4388 4389 4390
static int be_setup(struct be_adapter *adapter)
{
	struct device *dev = &adapter->pdev->dev;
4391
	u32 en_flags;
4392 4393
	int status;

4394 4395 4396 4397
	status = be_func_init(adapter);
	if (status)
		return status;

4398 4399 4400 4401 4402
	be_setup_init(adapter);

	if (!lancer_chip(adapter))
		be_cmd_req_native_mode(adapter);

4403 4404 4405 4406 4407
	/* Need to invoke this cmd first to get the PCI Function Number */
	status = be_cmd_get_cntl_attributes(adapter);
	if (status)
		return status;

4408 4409 4410
	if (!BE2_chip(adapter) && be_physfn(adapter))
		be_alloc_sriov_res(adapter);

4411
	status = be_get_config(adapter);
S
Sathya Perla 已提交
4412
	if (status)
4413
		goto err;
S
Sathya Perla 已提交
4414

4415
	status = be_msix_enable(adapter);
S
Sathya Perla 已提交
4416
	if (status)
4417
		goto err;
S
Sathya Perla 已提交
4418

4419 4420 4421 4422 4423
	/* will enable all the needed filter flags in be_open() */
	en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS;
	en_flags = en_flags & be_if_cap_flags(adapter);
	status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
				  &adapter->if_handle, 0);
4424
	if (status)
4425
		goto err;
S
Sathya Perla 已提交
4426

4427 4428
	/* Updating real_num_tx/rx_queues() requires rtnl_lock() */
	rtnl_lock();
4429
	status = be_setup_queues(adapter);
4430
	rtnl_unlock();
4431
	if (status)
4432 4433
		goto err;

4434 4435 4436
	be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);

	status = be_mac_setup(adapter);
S
Sathya Perla 已提交
4437 4438 4439
	if (status)
		goto err;

4440
	be_cmd_get_fw_ver(adapter);
S
Sathya Perla 已提交
4441
	dev_info(dev, "FW version is %s\n", adapter->fw_ver);
4442

4443
	if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) {
V
Vasundhara Volam 已提交
4444
		dev_err(dev, "Firmware on card is old(%s), IRQs may not work",
4445 4446 4447 4448
			adapter->fw_ver);
		dev_err(dev, "Please upgrade firmware to version >= 4.0\n");
	}

4449 4450 4451 4452 4453
	status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
					 adapter->rx_fc);
	if (status)
		be_cmd_get_flow_control(adapter, &adapter->tx_fc,
					&adapter->rx_fc);
4454

4455 4456
	dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n",
		 adapter->tx_fc, adapter->rx_fc);
4457

4458 4459 4460 4461
	if (be_physfn(adapter))
		be_cmd_set_logical_link_config(adapter,
					       IFLA_VF_LINK_STATE_AUTO, 0);

4462 4463
	if (adapter->num_vfs)
		be_vf_setup(adapter);
4464

4465 4466
	status = be_cmd_get_phy_info(adapter);
	if (!status && be_pause_supported(adapter))
A
Ajit Khaparde 已提交
4467 4468
		adapter->phy.fc_autoneg = 1;

4469
	be_schedule_worker(adapter);
4470
	adapter->flags |= BE_FLAGS_SETUP_DONE;
4471
	return 0;
4472 4473 4474 4475
err:
	be_clear(adapter);
	return status;
}
S
Sathya Perla 已提交
4476

I
Ivan Vecera 已提交
4477 4478 4479 4480
#ifdef CONFIG_NET_POLL_CONTROLLER
static void be_netpoll(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);
S
Sathya Perla 已提交
4481
	struct be_eq_obj *eqo;
I
Ivan Vecera 已提交
4482 4483
	int i;

4484
	for_all_evt_queues(adapter, eqo, i) {
4485
		be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
4486 4487
		napi_schedule(&eqo->napi);
	}
I
Ivan Vecera 已提交
4488 4489 4490
}
#endif

4491
static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
4492

4493 4494
static bool phy_flashing_required(struct be_adapter *adapter)
{
4495
	return (adapter->phy.phy_type == PHY_TYPE_TN_8022 &&
A
Ajit Khaparde 已提交
4496
		adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
4497 4498
}

4499 4500 4501 4502 4503 4504
static bool is_comp_in_ufi(struct be_adapter *adapter,
			   struct flash_section_info *fsec, int type)
{
	int i = 0, img_type = 0;
	struct flash_section_info_g2 *fsec_g2 = NULL;

4505
	if (BE2_chip(adapter))
4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520
		fsec_g2 = (struct flash_section_info_g2 *)fsec;

	for (i = 0; i < MAX_FLASH_COMP; i++) {
		if (fsec_g2)
			img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
		else
			img_type = le32_to_cpu(fsec->fsec_entry[i].type);

		if (img_type == type)
			return true;
	}
	return false;

}

J
Jingoo Han 已提交
4521
static struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
4522 4523
						int header_size,
						const struct firmware *fw)
4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537
{
	struct flash_section_info *fsec = NULL;
	const u8 *p = fw->data;

	p += header_size;
	while (p < (fw->data + fw->size)) {
		fsec = (struct flash_section_info *)p;
		if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
			return fsec;
		p += 32;
	}
	return NULL;
}

4538 4539 4540 4541 4542 4543 4544 4545
static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
			      u32 img_offset, u32 img_size, int hdr_size,
			      u16 img_optype, bool *crc_match)
{
	u32 crc_offset;
	int status;
	u8 crc[4];

4546 4547
	status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset,
				      img_size - 4);
4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561
	if (status)
		return status;

	crc_offset = hdr_size + img_offset + img_size - 4;

	/* Skip flashing, if crc of flashed region matches */
	if (!memcmp(crc, p + crc_offset, 4))
		*crc_match = true;
	else
		*crc_match = false;

	return status;
}

4562
static int be_flash(struct be_adapter *adapter, const u8 *img,
4563 4564
		    struct be_dma_mem *flash_cmd, int optype, int img_size,
		    u32 img_offset)
4565
{
4566
	u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0;
4567
	struct be_cmd_write_flashrom *req = flash_cmd->va;
4568
	int status;
4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586

	while (total_bytes) {
		num_bytes = min_t(u32, 32*1024, total_bytes);

		total_bytes -= num_bytes;

		if (!total_bytes) {
			if (optype == OPTYPE_PHY_FW)
				flash_op = FLASHROM_OPER_PHY_FLASH;
			else
				flash_op = FLASHROM_OPER_FLASH;
		} else {
			if (optype == OPTYPE_PHY_FW)
				flash_op = FLASHROM_OPER_PHY_SAVE;
			else
				flash_op = FLASHROM_OPER_SAVE;
		}

4587
		memcpy(req->data_buf, img, num_bytes);
4588 4589
		img += num_bytes;
		status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
4590 4591
					       flash_op, img_offset +
					       bytes_sent, num_bytes);
4592
		if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST &&
4593 4594 4595
		    optype == OPTYPE_PHY_FW)
			break;
		else if (status)
4596
			return status;
4597 4598

		bytes_sent += num_bytes;
4599 4600 4601 4602
	}
	return 0;
}

4603
/* For BE2, BE3 and BE3-R */
4604
static int be_flash_BEx(struct be_adapter *adapter,
4605 4606
			const struct firmware *fw,
			struct be_dma_mem *flash_cmd, int num_of_images)
4607
{
4608
	int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
4609
	struct device *dev = &adapter->pdev->dev;
4610
	struct flash_section_info *fsec = NULL;
4611 4612 4613 4614
	int status, i, filehdr_size, num_comp;
	const struct flash_comp *pflashcomp;
	bool crc_match;
	const u8 *p;
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636

	struct flash_comp gen3_flash_types[] = {
		{ FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
		{ FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
			FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
		{ FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
		{ FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
		{ FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
		{ FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
			FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
		{ FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
		{ FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
			FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
		{ FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
			FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
		{ FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
			FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
4637
	};
4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655

	struct flash_comp gen2_flash_types[] = {
		{ FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
		{ FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
			FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
		{ FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
		{ FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
		{ FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
			FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
		{ FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
			FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
		{ FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
			FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
		{ FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
			 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
4656 4657
	};

4658
	if (BE3_chip(adapter)) {
4659 4660
		pflashcomp = gen3_flash_types;
		filehdr_size = sizeof(struct flash_file_hdr_g3);
J
Joe Perches 已提交
4661
		num_comp = ARRAY_SIZE(gen3_flash_types);
4662 4663 4664
	} else {
		pflashcomp = gen2_flash_types;
		filehdr_size = sizeof(struct flash_file_hdr_g2);
J
Joe Perches 已提交
4665
		num_comp = ARRAY_SIZE(gen2_flash_types);
4666
		img_hdrs_size = 0;
4667
	}
4668

4669 4670 4671
	/* Get flash section info*/
	fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
	if (!fsec) {
4672
		dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4673 4674
		return -1;
	}
4675
	for (i = 0; i < num_comp; i++) {
4676
		if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
4677
			continue;
4678 4679 4680 4681 4682

		if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
		    memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
			continue;

4683 4684
		if (pflashcomp[i].optype == OPTYPE_PHY_FW  &&
		    !phy_flashing_required(adapter))
4685
				continue;
4686

4687
		if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701
			status = be_check_flash_crc(adapter, fw->data,
						    pflashcomp[i].offset,
						    pflashcomp[i].size,
						    filehdr_size +
						    img_hdrs_size,
						    OPTYPE_REDBOOT, &crc_match);
			if (status) {
				dev_err(dev,
					"Could not get CRC for 0x%x region\n",
					pflashcomp[i].optype);
				continue;
			}

			if (crc_match)
4702 4703
				continue;
		}
4704

4705 4706
		p = fw->data + filehdr_size + pflashcomp[i].offset +
			img_hdrs_size;
4707 4708
		if (p + pflashcomp[i].size > fw->data + fw->size)
			return -1;
4709 4710

		status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
4711
				  pflashcomp[i].size, 0);
4712
		if (status) {
4713
			dev_err(dev, "Flashing section type 0x%x failed\n",
4714 4715
				pflashcomp[i].img_type);
			return status;
4716 4717 4718 4719 4720
		}
	}
	return 0;
}

4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772
static u16 be_get_img_optype(struct flash_section_entry fsec_entry)
{
	u32 img_type = le32_to_cpu(fsec_entry.type);
	u16 img_optype = le16_to_cpu(fsec_entry.optype);

	if (img_optype != 0xFFFF)
		return img_optype;

	switch (img_type) {
	case IMAGE_FIRMWARE_iSCSI:
		img_optype = OPTYPE_ISCSI_ACTIVE;
		break;
	case IMAGE_BOOT_CODE:
		img_optype = OPTYPE_REDBOOT;
		break;
	case IMAGE_OPTION_ROM_ISCSI:
		img_optype = OPTYPE_BIOS;
		break;
	case IMAGE_OPTION_ROM_PXE:
		img_optype = OPTYPE_PXE_BIOS;
		break;
	case IMAGE_OPTION_ROM_FCoE:
		img_optype = OPTYPE_FCOE_BIOS;
		break;
	case IMAGE_FIRMWARE_BACKUP_iSCSI:
		img_optype = OPTYPE_ISCSI_BACKUP;
		break;
	case IMAGE_NCSI:
		img_optype = OPTYPE_NCSI_FW;
		break;
	case IMAGE_FLASHISM_JUMPVECTOR:
		img_optype = OPTYPE_FLASHISM_JUMPVECTOR;
		break;
	case IMAGE_FIRMWARE_PHY:
		img_optype = OPTYPE_SH_PHY_FW;
		break;
	case IMAGE_REDBOOT_DIR:
		img_optype = OPTYPE_REDBOOT_DIR;
		break;
	case IMAGE_REDBOOT_CONFIG:
		img_optype = OPTYPE_REDBOOT_CONFIG;
		break;
	case IMAGE_UFI_DIR:
		img_optype = OPTYPE_UFI_DIR;
		break;
	default:
		break;
	}

	return img_optype;
}

4773
static int be_flash_skyhawk(struct be_adapter *adapter,
4774 4775
			    const struct firmware *fw,
			    struct be_dma_mem *flash_cmd, int num_of_images)
4776
{
4777
	int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
4778
	bool crc_match, old_fw_img, flash_offset_support = true;
4779
	struct device *dev = &adapter->pdev->dev;
4780
	struct flash_section_info *fsec = NULL;
4781
	u32 img_offset, img_size, img_type;
4782
	u16 img_optype, flash_optype;
4783 4784
	int status, i, filehdr_size;
	const u8 *p;
4785 4786 4787 4788

	filehdr_size = sizeof(struct flash_file_hdr_g3);
	fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
	if (!fsec) {
4789
		dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4790
		return -EINVAL;
4791 4792
	}

4793
retry_flash:
4794 4795 4796
	for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
		img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
		img_size   = le32_to_cpu(fsec->fsec_entry[i].pad_size);
4797 4798 4799
		img_type   = le32_to_cpu(fsec->fsec_entry[i].type);
		img_optype = be_get_img_optype(fsec->fsec_entry[i]);
		old_fw_img = fsec->fsec_entry[i].optype == 0xFFFF;
4800

4801
		if (img_optype == 0xFFFF)
4802
			continue;
4803 4804 4805 4806 4807 4808

		if (flash_offset_support)
			flash_optype = OPTYPE_OFFSET_SPECIFIED;
		else
			flash_optype = img_optype;

4809 4810 4811 4812 4813 4814 4815 4816
		/* Don't bother verifying CRC if an old FW image is being
		 * flashed
		 */
		if (old_fw_img)
			goto flash;

		status = be_check_flash_crc(adapter, fw->data, img_offset,
					    img_size, filehdr_size +
4817
					    img_hdrs_size, flash_optype,
4818
					    &crc_match);
4819 4820
		if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST ||
		    base_status(status) == MCC_STATUS_ILLEGAL_FIELD) {
4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836
			/* The current FW image on the card does not support
			 * OFFSET based flashing. Retry using older mechanism
			 * of OPTYPE based flashing
			 */
			if (flash_optype == OPTYPE_OFFSET_SPECIFIED) {
				flash_offset_support = false;
				goto retry_flash;
			}

			/* The current FW image on the card does not recognize
			 * the new FLASH op_type. The FW download is partially
			 * complete. Reboot the server now to enable FW image
			 * to recognize the new FLASH op_type. To complete the
			 * remaining process, download the same FW again after
			 * the reboot.
			 */
4837 4838 4839 4840 4841 4842 4843
			dev_err(dev, "Flash incomplete. Reset the server\n");
			dev_err(dev, "Download FW image again after reset\n");
			return -EAGAIN;
		} else if (status) {
			dev_err(dev, "Could not get CRC for 0x%x region\n",
				img_optype);
			return -EFAULT;
4844 4845
		}

4846 4847
		if (crc_match)
			continue;
4848

4849 4850
flash:
		p = fw->data + filehdr_size + img_offset + img_hdrs_size;
4851 4852 4853
		if (p + img_size > fw->data + fw->size)
			return -1;

4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866
		status = be_flash(adapter, p, flash_cmd, flash_optype, img_size,
				  img_offset);

		/* The current FW image on the card does not support OFFSET
		 * based flashing. Retry using older mechanism of OPTYPE based
		 * flashing
		 */
		if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD &&
		    flash_optype == OPTYPE_OFFSET_SPECIFIED) {
			flash_offset_support = false;
			goto retry_flash;
		}

4867 4868 4869
		/* For old FW images ignore ILLEGAL_FIELD error or errors on
		 * UFI_DIR region
		 */
4870 4871 4872 4873
		if (old_fw_img &&
		    (base_status(status) == MCC_STATUS_ILLEGAL_FIELD ||
		     (img_optype == OPTYPE_UFI_DIR &&
		      base_status(status) == MCC_STATUS_FAILED))) {
4874 4875 4876 4877 4878
			continue;
		} else if (status) {
			dev_err(dev, "Flashing section type 0x%x failed\n",
				img_type);
			return -EFAULT;
4879 4880 4881
		}
	}
	return 0;
4882 4883
}

4884
static int lancer_fw_download(struct be_adapter *adapter,
4885
			      const struct firmware *fw)
4886
{
4887 4888
#define LANCER_FW_DOWNLOAD_CHUNK      (32 * 1024)
#define LANCER_FW_DOWNLOAD_LOCATION   "/prg"
4889
	struct device *dev = &adapter->pdev->dev;
4890
	struct be_dma_mem flash_cmd;
4891 4892 4893 4894 4895 4896 4897 4898
	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;
4899
	u8 change_status;
4900

4901
	if (!IS_ALIGNED(fw->size, sizeof(u32))) {
4902
		dev_err(dev, "FW image size should be multiple of 4\n");
K
Kalesh AP 已提交
4903
		return -EINVAL;
4904 4905
	}

4906 4907
	flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
				+ LANCER_FW_DOWNLOAD_CHUNK;
4908 4909
	flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
					   &flash_cmd.dma, GFP_KERNEL);
K
Kalesh AP 已提交
4910 4911
	if (!flash_cmd.va)
		return -ENOMEM;
4912

4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924
	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,
4925 4926 4927 4928
						 chunk_size, offset,
						 LANCER_FW_DOWNLOAD_LOCATION,
						 &data_written, &change_status,
						 &add_status);
4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939
		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,
4940 4941 4942 4943
						 0, offset,
						 LANCER_FW_DOWNLOAD_LOCATION,
						 &data_written, &change_status,
						 &add_status);
4944 4945
	}

4946
	dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
4947
	if (status) {
4948
		dev_err(dev, "Firmware load error\n");
K
Kalesh AP 已提交
4949
		return be_cmd_status(status);
4950 4951
	}

4952 4953
	dev_info(dev, "Firmware flashed successfully\n");

4954
	if (change_status == LANCER_FW_RESET_NEEDED) {
4955
		dev_info(dev, "Resetting adapter to activate new FW\n");
4956 4957
		status = lancer_physdev_ctrl(adapter,
					     PHYSDEV_CONTROL_FW_RESET_MASK);
4958
		if (status) {
4959 4960
			dev_err(dev, "Adapter busy, could not reset FW\n");
			dev_err(dev, "Reboot server to activate new FW\n");
4961 4962
		}
	} else if (change_status != LANCER_NO_RESET_NEEDED) {
4963
		dev_info(dev, "Reboot server to activate new FW\n");
4964
	}
K
Kalesh AP 已提交
4965 4966

	return 0;
4967 4968
}

4969 4970 4971 4972 4973
/* Check if the flash image file is compatible with the adapter that
 * is being flashed.
 */
static bool be_check_ufi_compatibility(struct be_adapter *adapter,
				       struct flash_file_hdr_g3 *fhdr)
4974
{
4975 4976
	if (!fhdr) {
		dev_err(&adapter->pdev->dev, "Invalid FW UFI file");
4977
		return false;
4978
	}
4979

4980 4981 4982 4983 4984
	/* First letter of the build version is used to identify
	 * which chip this image file is meant for.
	 */
	switch (fhdr->build[0]) {
	case BLD_STR_UFI_TYPE_SH:
4985 4986 4987
		if (!skyhawk_chip(adapter))
			return false;
		break;
4988
	case BLD_STR_UFI_TYPE_BE3:
4989 4990 4991
		if (!BE3_chip(adapter))
			return false;
		break;
4992
	case BLD_STR_UFI_TYPE_BE2:
4993 4994 4995
		if (!BE2_chip(adapter))
			return false;
		break;
4996 4997 4998
	default:
		return false;
	}
4999

5000 5001 5002 5003 5004 5005 5006 5007 5008
	/* In BE3 FW images the "asic_type_rev" field doesn't track the
	 * asic_rev of the chips it is compatible with.
	 * When asic_type_rev is 0 the image is compatible only with
	 * pre-BE3-R chips (asic_rev < 0x10)
	 */
	if (BEx_chip(adapter) && fhdr->asic_type_rev == 0)
		return adapter->asic_rev < 0x10;
	else
		return (fhdr->asic_type_rev >= adapter->asic_rev);
5009 5010
}

5011 5012
static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
{
5013
	struct device *dev = &adapter->pdev->dev;
5014
	struct flash_file_hdr_g3 *fhdr3;
5015 5016
	struct image_hdr *img_hdr_ptr;
	int status = 0, i, num_imgs;
5017
	struct be_dma_mem flash_cmd;
5018

5019 5020 5021 5022
	fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
	if (!be_check_ufi_compatibility(adapter, fhdr3)) {
		dev_err(dev, "Flash image is not compatible with adapter\n");
		return -EINVAL;
5023 5024
	}

5025
	flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
5026 5027
	flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
					   GFP_KERNEL);
5028 5029
	if (!flash_cmd.va)
		return -ENOMEM;
5030 5031 5032 5033 5034 5035

	num_imgs = le32_to_cpu(fhdr3->num_imgs);
	for (i = 0; i < num_imgs; i++) {
		img_hdr_ptr = (struct image_hdr *)(fw->data +
				(sizeof(struct flash_file_hdr_g3) +
				 i * sizeof(struct image_hdr)));
5036 5037 5038
		if (!BE2_chip(adapter) &&
		    le32_to_cpu(img_hdr_ptr->imageid) != 1)
			continue;
5039

5040 5041 5042 5043 5044 5045
		if (skyhawk_chip(adapter))
			status = be_flash_skyhawk(adapter, fw, &flash_cmd,
						  num_imgs);
		else
			status = be_flash_BEx(adapter, fw, &flash_cmd,
					      num_imgs);
5046 5047
	}

5048 5049 5050
	dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
	if (!status)
		dev_info(dev, "Firmware flashed successfully\n");
5051

5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062
	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");
5063
		return -ENETDOWN;
5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076
	}

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

S
Somnath Kotur 已提交
5077
	if (!status)
5078
		be_cmd_get_fw_ver(adapter);
S
Somnath Kotur 已提交
5079

5080 5081 5082 5083 5084
fw_exit:
	release_firmware(fw);
	return status;
}

5085 5086
static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
				 u16 flags)
5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097
{
	struct be_adapter *adapter = netdev_priv(dev);
	struct nlattr *attr, *br_spec;
	int rem;
	int status = 0;
	u16 mode = 0;

	if (!sriov_enabled(adapter))
		return -EOPNOTSUPP;

	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5098 5099
	if (!br_spec)
		return -EINVAL;
5100 5101 5102 5103 5104

	nla_for_each_nested(attr, br_spec, rem) {
		if (nla_type(attr) != IFLA_BRIDGE_MODE)
			continue;

5105 5106 5107
		if (nla_len(attr) < sizeof(mode))
			return -EINVAL;

5108 5109 5110 5111 5112 5113 5114 5115
		mode = nla_get_u16(attr);
		if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
			return -EINVAL;

		status = be_cmd_set_hsw_config(adapter, 0, 0,
					       adapter->if_handle,
					       mode == BRIDGE_MODE_VEPA ?
					       PORT_FWD_TYPE_VEPA :
5116
					       PORT_FWD_TYPE_VEB, 0);
5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132
		if (status)
			goto err;

		dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n",
			 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");

		return status;
	}
err:
	dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n",
		mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");

	return status;
}

static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
5133 5134
				 struct net_device *dev, u32 filter_mask,
				 int nlflags)
5135 5136 5137 5138 5139 5140 5141 5142 5143 5144
{
	struct be_adapter *adapter = netdev_priv(dev);
	int status = 0;
	u8 hsw_mode;

	/* BE and Lancer chips support VEB mode only */
	if (BEx_chip(adapter) || lancer_chip(adapter)) {
		hsw_mode = PORT_FWD_TYPE_VEB;
	} else {
		status = be_cmd_get_hsw_config(adapter, NULL, 0,
5145 5146
					       adapter->if_handle, &hsw_mode,
					       NULL);
5147 5148
		if (status)
			return 0;
5149 5150 5151

		if (hsw_mode == PORT_FWD_TYPE_PASSTHRU)
			return 0;
5152 5153 5154 5155
	}

	return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
				       hsw_mode == PORT_FWD_TYPE_VEPA ?
5156
				       BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB,
5157
				       0, 0, nlflags, filter_mask, NULL);
5158 5159
}

5160
#ifdef CONFIG_BE2NET_VXLAN
5161 5162 5163 5164 5165 5166
/* VxLAN offload Notes:
 *
 * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't
 * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload
 * is expected to work across all types of IP tunnels once exported. Skyhawk
 * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN
5167 5168 5169
 * offloads in hw_enc_features only when a VxLAN port is added. If other (non
 * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for
 * those other tunnels are unexported on the fly through ndo_features_check().
5170 5171 5172 5173 5174
 *
 * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack
 * adds more than one port, disable offloads and don't re-enable them again
 * until after all the tunnels are removed.
 */
5175 5176 5177 5178 5179 5180 5181
static void be_add_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
			      __be16 port)
{
	struct be_adapter *adapter = netdev_priv(netdev);
	struct device *dev = &adapter->pdev->dev;
	int status;

5182
	if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5183 5184
		return;

5185 5186 5187 5188 5189
	if (adapter->vxlan_port == port && adapter->vxlan_port_count) {
		adapter->vxlan_port_aliases++;
		return;
	}

5190 5191 5192
	if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) {
		dev_info(dev,
			 "Only one UDP port supported for VxLAN offloads\n");
5193 5194 5195
		dev_info(dev, "Disabling VxLAN offloads\n");
		adapter->vxlan_port_count++;
		goto err;
5196 5197
	}

5198 5199 5200
	if (adapter->vxlan_port_count++ >= 1)
		return;

5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215
	status = be_cmd_manage_iface(adapter, adapter->if_handle,
				     OP_CONVERT_NORMAL_TO_TUNNEL);
	if (status) {
		dev_warn(dev, "Failed to convert normal interface to tunnel\n");
		goto err;
	}

	status = be_cmd_set_vxlan_port(adapter, port);
	if (status) {
		dev_warn(dev, "Failed to add VxLAN port\n");
		goto err;
	}
	adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS;
	adapter->vxlan_port = port;

5216 5217 5218 5219
	netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
				   NETIF_F_TSO | NETIF_F_TSO6 |
				   NETIF_F_GSO_UDP_TUNNEL;
	netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
5220
	netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
5221

5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233
	dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n",
		 be16_to_cpu(port));
	return;
err:
	be_disable_vxlan_offloads(adapter);
}

static void be_del_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
			      __be16 port)
{
	struct be_adapter *adapter = netdev_priv(netdev);

5234
	if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5235 5236 5237
		return;

	if (adapter->vxlan_port != port)
5238
		goto done;
5239

5240 5241 5242 5243 5244
	if (adapter->vxlan_port_aliases) {
		adapter->vxlan_port_aliases--;
		return;
	}

5245 5246 5247 5248 5249
	be_disable_vxlan_offloads(adapter);

	dev_info(&adapter->pdev->dev,
		 "Disabled VxLAN offloads for UDP port %d\n",
		 be16_to_cpu(port));
5250 5251
done:
	adapter->vxlan_port_count--;
5252
}
J
Joe Stringer 已提交
5253

5254 5255 5256
static netdev_features_t be_features_check(struct sk_buff *skb,
					   struct net_device *dev,
					   netdev_features_t features)
J
Joe Stringer 已提交
5257
{
5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
	struct be_adapter *adapter = netdev_priv(dev);
	u8 l4_hdr = 0;

	/* The code below restricts offload features for some tunneled packets.
	 * Offload features for normal (non tunnel) packets are unchanged.
	 */
	if (!skb->encapsulation ||
	    !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS))
		return features;

	/* It's an encapsulated packet and VxLAN offloads are enabled. We
	 * should disable tunnel offload features if it's not a VxLAN packet,
	 * as tunnel offloads have been enabled only for VxLAN. This is done to
	 * allow other tunneled traffic like GRE work fine while VxLAN
	 * offloads are configured in Skyhawk-R.
	 */
	switch (vlan_get_protocol(skb)) {
	case htons(ETH_P_IP):
		l4_hdr = ip_hdr(skb)->protocol;
		break;
	case htons(ETH_P_IPV6):
		l4_hdr = ipv6_hdr(skb)->nexthdr;
		break;
	default:
		return features;
	}

	if (l4_hdr != IPPROTO_UDP ||
	    skb->inner_protocol_type != ENCAP_TYPE_ETHER ||
	    skb->inner_protocol != htons(ETH_P_TEB) ||
	    skb_inner_mac_header(skb) - skb_transport_header(skb) !=
	    sizeof(struct udphdr) + sizeof(struct vxlanhdr))
		return features & ~(NETIF_F_ALL_CSUM | NETIF_F_GSO_MASK);

	return features;
J
Joe Stringer 已提交
5293
}
5294
#endif
5295

5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316
static int be_get_phys_port_id(struct net_device *dev,
			       struct netdev_phys_item_id *ppid)
{
	int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1;
	struct be_adapter *adapter = netdev_priv(dev);
	u8 *id;

	if (MAX_PHYS_ITEM_ID_LEN < id_len)
		return -ENOSPC;

	ppid->id[0] = adapter->hba_port_num + 1;
	id = &ppid->id[1];
	for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0;
	     i--, id += CNTL_SERIAL_NUM_WORD_SZ)
		memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ);

	ppid->id_len = id_len;

	return 0;
}

5317
static const struct net_device_ops be_netdev_ops = {
S
Sathya Perla 已提交
5318 5319 5320
	.ndo_open		= be_open,
	.ndo_stop		= be_close,
	.ndo_start_xmit		= be_xmit,
5321
	.ndo_set_rx_mode	= be_set_rx_mode,
S
Sathya Perla 已提交
5322 5323
	.ndo_set_mac_address	= be_mac_addr_set,
	.ndo_change_mtu		= be_change_mtu,
5324
	.ndo_get_stats64	= be_get_stats64,
S
Sathya Perla 已提交
5325 5326 5327
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_vlan_rx_add_vid	= be_vlan_add_vid,
	.ndo_vlan_rx_kill_vid	= be_vlan_rem_vid,
5328
	.ndo_set_vf_mac		= be_set_vf_mac,
5329
	.ndo_set_vf_vlan	= be_set_vf_vlan,
5330
	.ndo_set_vf_rate	= be_set_vf_tx_rate,
I
Ivan Vecera 已提交
5331
	.ndo_get_vf_config	= be_get_vf_config,
5332
	.ndo_set_vf_link_state  = be_set_vf_link_state,
5333
	.ndo_set_vf_spoofchk    = be_set_vf_spoofchk,
I
Ivan Vecera 已提交
5334 5335 5336
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= be_netpoll,
#endif
5337 5338
	.ndo_bridge_setlink	= be_ndo_bridge_setlink,
	.ndo_bridge_getlink	= be_ndo_bridge_getlink,
5339
#ifdef CONFIG_NET_RX_BUSY_POLL
5340
	.ndo_busy_poll		= be_busy_poll,
5341
#endif
5342
#ifdef CONFIG_BE2NET_VXLAN
5343 5344
	.ndo_add_vxlan_port	= be_add_vxlan_port,
	.ndo_del_vxlan_port	= be_del_vxlan_port,
5345
	.ndo_features_check	= be_features_check,
5346
#endif
5347
	.ndo_get_phys_port_id   = be_get_phys_port_id,
S
Sathya Perla 已提交
5348 5349 5350 5351 5352 5353
};

static void be_netdev_init(struct net_device *netdev)
{
	struct be_adapter *adapter = netdev_priv(netdev);

5354
	netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5355
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
5356
		NETIF_F_HW_VLAN_CTAG_TX;
5357 5358
	if (be_multi_rxq(adapter))
		netdev->hw_features |= NETIF_F_RXHASH;
5359 5360

	netdev->features |= netdev->hw_features |
5361
		NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
A
Ajit Khaparde 已提交
5362

5363
	netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5364
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
5365

5366 5367
	netdev->priv_flags |= IFF_UNICAST_FLT;

S
Sathya Perla 已提交
5368 5369
	netdev->flags |= IFF_MULTICAST;

5370
	netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
5371

S
Sathya Perla 已提交
5372
	netdev->netdev_ops = &be_netdev_ops;
S
Sathya Perla 已提交
5373

5374
	netdev->ethtool_ops = &be_ethtool_ops;
S
Sathya Perla 已提交
5375 5376
}

5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389
static void be_cleanup(struct be_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;

	rtnl_lock();
	netif_device_detach(netdev);
	if (netif_running(netdev))
		be_close(netdev);
	rtnl_unlock();

	be_clear(adapter);
}

5390
static int be_resume(struct be_adapter *adapter)
5391
{
5392
	struct net_device *netdev = adapter->netdev;
5393 5394 5395 5396
	int status;

	status = be_setup(adapter);
	if (status)
5397
		return status;
5398

5399 5400
	if (netif_running(netdev)) {
		status = be_open(netdev);
5401
		if (status)
5402
			return status;
5403 5404
	}

5405 5406
	netif_device_attach(netdev);

5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
	return 0;
}

static int be_err_recover(struct be_adapter *adapter)
{
	struct device *dev = &adapter->pdev->dev;
	int status;

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

5419
	dev_info(dev, "Adapter recovery successful\n");
5420 5421
	return 0;
err:
5422
	if (be_physfn(adapter))
5423
		dev_err(dev, "Adapter recovery failed\n");
5424 5425
	else
		dev_err(dev, "Re-trying adapter recovery\n");
5426 5427 5428 5429

	return status;
}

5430
static void be_err_detection_task(struct work_struct *work)
5431 5432
{
	struct be_adapter *adapter =
5433 5434
				container_of(work, struct be_adapter,
					     be_err_detection_work.work);
5435 5436 5437 5438
	int status = 0;

	be_detect_error(adapter);

5439
	if (be_check_error(adapter, BE_ERROR_HW)) {
5440
		be_cleanup(adapter);
5441 5442 5443 5444

		/* As of now error recovery support is in Lancer only */
		if (lancer_chip(adapter))
			status = be_err_recover(adapter);
5445 5446
	}

5447 5448
	/* Always attempt recovery on VFs */
	if (!status || be_virtfn(adapter))
5449
		be_schedule_err_detection(adapter);
5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502
}

static void be_log_sfp_info(struct be_adapter *adapter)
{
	int status;

	status = be_cmd_query_sfp_info(adapter);
	if (!status) {
		dev_err(&adapter->pdev->dev,
			"Unqualified SFP+ detected on %c from %s part no: %s",
			adapter->port_name, adapter->phy.vendor_name,
			adapter->phy.vendor_pn);
	}
	adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP;
}

static void be_worker(struct work_struct *work)
{
	struct be_adapter *adapter =
		container_of(work, struct be_adapter, work.work);
	struct be_rx_obj *rxo;
	int i;

	/* when interrupts are not yet enabled, just reap any pending
	 * mcc completions
	 */
	if (!netif_running(adapter->netdev)) {
		local_bh_disable();
		be_process_mcc(adapter);
		local_bh_enable();
		goto reschedule;
	}

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

	if (be_physfn(adapter) &&
	    MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
		be_cmd_get_die_temperature(adapter);

	for_all_rx_queues(adapter, rxo, i) {
		/* Replenish RX-queues starved due to memory
		 * allocation failures.
		 */
		if (rxo->rx_post_starved)
			be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST);
	}

5503 5504 5505
	/* EQ-delay update for Skyhawk is done while notifying EQ */
	if (!skyhawk_chip(adapter))
		be_eqd_update(adapter, false);
5506 5507 5508 5509 5510 5511 5512 5513 5514

	if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP)
		be_log_sfp_info(adapter);

reschedule:
	adapter->work_counter++;
	schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
}

S
Sathya Perla 已提交
5515 5516
static void be_unmap_pci_bars(struct be_adapter *adapter)
{
5517 5518
	if (adapter->csr)
		pci_iounmap(adapter->pdev, adapter->csr);
5519
	if (adapter->db)
S
Sathya Perla 已提交
5520
		pci_iounmap(adapter->pdev, adapter->db);
5521 5522
}

S
Sathya Perla 已提交
5523 5524
static int db_bar(struct be_adapter *adapter)
{
5525
	if (lancer_chip(adapter) || be_virtfn(adapter))
S
Sathya Perla 已提交
5526 5527 5528 5529 5530 5531
		return 0;
	else
		return 4;
}

static int be_roce_map_pci_bars(struct be_adapter *adapter)
5532
{
S
Sathya Perla 已提交
5533
	if (skyhawk_chip(adapter)) {
S
Sathya Perla 已提交
5534 5535 5536 5537 5538 5539
		adapter->roce_db.size = 4096;
		adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
							      db_bar(adapter));
		adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
							       db_bar(adapter));
	}
5540
	return 0;
S
Sathya Perla 已提交
5541 5542 5543 5544
}

static int be_map_pci_bars(struct be_adapter *adapter)
{
5545
	struct pci_dev *pdev = adapter->pdev;
S
Sathya Perla 已提交
5546
	u8 __iomem *addr;
5547 5548 5549 5550 5551 5552
	u32 sli_intf;

	pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
	adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
				SLI_INTF_FAMILY_SHIFT;
	adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
5553

5554
	if (BEx_chip(adapter) && be_physfn(adapter)) {
5555
		adapter->csr = pci_iomap(pdev, 2, 0);
K
Kalesh AP 已提交
5556
		if (!adapter->csr)
5557 5558 5559
			return -ENOMEM;
	}

5560
	addr = pci_iomap(pdev, db_bar(adapter), 0);
K
Kalesh AP 已提交
5561
	if (!addr)
S
Sathya Perla 已提交
5562
		goto pci_map_err;
5563
	adapter->db = addr;
S
Sathya Perla 已提交
5564

5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576
	if (skyhawk_chip(adapter) || BEx_chip(adapter)) {
		if (be_physfn(adapter)) {
			/* PCICFG is the 2nd BAR in BE2 */
			addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0);
			if (!addr)
				goto pci_map_err;
			adapter->pcicfg = addr;
		} else {
			adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
		}
	}

S
Sathya Perla 已提交
5577
	be_roce_map_pci_bars(adapter);
S
Sathya Perla 已提交
5578
	return 0;
S
Sathya Perla 已提交
5579

S
Sathya Perla 已提交
5580
pci_map_err:
5581
	dev_err(&pdev->dev, "Error in mapping PCI BARs\n");
S
Sathya Perla 已提交
5582 5583 5584 5585
	be_unmap_pci_bars(adapter);
	return -ENOMEM;
}

5586
static void be_drv_cleanup(struct be_adapter *adapter)
S
Sathya Perla 已提交
5587
{
5588
	struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
5589
	struct device *dev = &adapter->pdev->dev;
S
Sathya Perla 已提交
5590 5591

	if (mem->va)
5592
		dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5593

5594
	mem = &adapter->rx_filter;
5595
	if (mem->va)
5596 5597 5598 5599 5600
		dma_free_coherent(dev, mem->size, mem->va, mem->dma);

	mem = &adapter->stats_cmd;
	if (mem->va)
		dma_free_coherent(dev, mem->size, mem->va, mem->dma);
S
Sathya Perla 已提交
5601 5602
}

5603 5604
/* Allocate and initialize various fields in be_adapter struct */
static int be_drv_init(struct be_adapter *adapter)
S
Sathya Perla 已提交
5605
{
5606 5607
	struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
	struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
5608
	struct be_dma_mem *rx_filter = &adapter->rx_filter;
5609 5610 5611
	struct be_dma_mem *stats_cmd = &adapter->stats_cmd;
	struct device *dev = &adapter->pdev->dev;
	int status = 0;
S
Sathya Perla 已提交
5612 5613

	mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
5614 5615 5616
	mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
						 &mbox_mem_alloc->dma,
						 GFP_KERNEL);
5617 5618 5619
	if (!mbox_mem_alloc->va)
		return -ENOMEM;

S
Sathya Perla 已提交
5620 5621 5622
	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);
5623

5624
	rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
5625 5626
	rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
					    &rx_filter->dma, GFP_KERNEL);
K
Kalesh AP 已提交
5627
	if (!rx_filter->va) {
5628 5629 5630
		status = -ENOMEM;
		goto free_mbox;
	}
5631

5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646
	if (lancer_chip(adapter))
		stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
	else if (BE2_chip(adapter))
		stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
	else if (BE3_chip(adapter))
		stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
	else
		stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
	stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
					    &stats_cmd->dma, GFP_KERNEL);
	if (!stats_cmd->va) {
		status = -ENOMEM;
		goto free_rx_filter;
	}

5647
	mutex_init(&adapter->mbox_lock);
5648 5649
	spin_lock_init(&adapter->mcc_lock);
	spin_lock_init(&adapter->mcc_cq_lock);
5650
	init_completion(&adapter->et_cmd_compl);
5651

5652
	pci_save_state(adapter->pdev);
S
Sathya Perla 已提交
5653

5654
	INIT_DELAYED_WORK(&adapter->work, be_worker);
5655 5656
	INIT_DELAYED_WORK(&adapter->be_err_detection_work,
			  be_err_detection_task);
S
Sathya Perla 已提交
5657

5658 5659
	adapter->rx_fc = true;
	adapter->tx_fc = true;
S
Sathya Perla 已提交
5660

5661 5662
	/* Must be a power of 2 or else MODULO will BUG_ON */
	adapter->be_get_temp_freq = 64;
5663

S
Sathya Perla 已提交
5664
	return 0;
5665 5666 5667 5668 5669 5670 5671

free_rx_filter:
	dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma);
free_mbox:
	dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va,
			  mbox_mem_alloc->dma);
	return status;
S
Sathya Perla 已提交
5672 5673
}

B
Bill Pemberton 已提交
5674
static void be_remove(struct pci_dev *pdev)
S
Sathya Perla 已提交
5675 5676
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
5677

S
Sathya Perla 已提交
5678 5679 5680
	if (!adapter)
		return;

5681
	be_roce_dev_remove(adapter);
5682
	be_intr_set(adapter, false);
5683

5684
	be_cancel_err_detection(adapter);
5685

S
Sathya Perla 已提交
5686 5687
	unregister_netdev(adapter->netdev);

5688 5689
	be_clear(adapter);

5690 5691 5692
	/* tell fw we're done with firing cmds */
	be_cmd_fw_clean(adapter);

5693 5694
	be_unmap_pci_bars(adapter);
	be_drv_cleanup(adapter);
S
Sathya Perla 已提交
5695

S
Sathya Perla 已提交
5696 5697
	pci_disable_pcie_error_reporting(pdev);

S
Sathya Perla 已提交
5698 5699 5700 5701 5702 5703
	pci_release_regions(pdev);
	pci_disable_device(pdev);

	free_netdev(adapter->netdev);
}

5704 5705 5706
static ssize_t be_hwmon_show_temp(struct device *dev,
				  struct device_attribute *dev_attr,
				  char *buf)
5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727
{
	struct be_adapter *adapter = dev_get_drvdata(dev);

	/* Unit: millidegree Celsius */
	if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP)
		return -EIO;
	else
		return sprintf(buf, "%u\n",
			       adapter->hwmon_info.be_on_die_temp * 1000);
}

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
			  be_hwmon_show_temp, NULL, 1);

static struct attribute *be_hwmon_attrs[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	NULL
};

ATTRIBUTE_GROUPS(be_hwmon);

S
Sathya Perla 已提交
5728 5729
static char *mc_name(struct be_adapter *adapter)
{
5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755
	char *str = "";	/* default */

	switch (adapter->mc_type) {
	case UMC:
		str = "UMC";
		break;
	case FLEX10:
		str = "FLEX10";
		break;
	case vNIC1:
		str = "vNIC-1";
		break;
	case nPAR:
		str = "nPAR";
		break;
	case UFP:
		str = "UFP";
		break;
	case vNIC2:
		str = "vNIC-2";
		break;
	default:
		str = "";
	}

	return str;
S
Sathya Perla 已提交
5756 5757 5758 5759 5760 5761 5762
}

static inline char *func_name(struct be_adapter *adapter)
{
	return be_physfn(adapter) ? "PF" : "VF";
}

5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782
static inline char *nic_name(struct pci_dev *pdev)
{
	switch (pdev->device) {
	case OC_DEVICE_ID1:
		return OC_NAME;
	case OC_DEVICE_ID2:
		return OC_NAME_BE;
	case OC_DEVICE_ID3:
	case OC_DEVICE_ID4:
		return OC_NAME_LANCER;
	case BE_DEVICE_ID2:
		return BE3_NAME;
	case OC_DEVICE_ID5:
	case OC_DEVICE_ID6:
		return OC_NAME_SH;
	default:
		return BE_NAME;
	}
}

5783
static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
S
Sathya Perla 已提交
5784 5785 5786
{
	struct be_adapter *adapter;
	struct net_device *netdev;
5787
	int status = 0;
S
Sathya Perla 已提交
5788

S
Sathya Perla 已提交
5789 5790
	dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER);

S
Sathya Perla 已提交
5791 5792 5793 5794 5795 5796 5797 5798 5799
	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);

5800
	netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
K
Kalesh AP 已提交
5801
	if (!netdev) {
S
Sathya Perla 已提交
5802 5803 5804 5805 5806 5807 5808
		status = -ENOMEM;
		goto rel_reg;
	}
	adapter = netdev_priv(netdev);
	adapter->pdev = pdev;
	pci_set_drvdata(pdev, adapter);
	adapter->netdev = netdev;
5809
	SET_NETDEV_DEV(netdev, &pdev->dev);
S
Sathya Perla 已提交
5810

5811
	status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
S
Sathya Perla 已提交
5812 5813 5814
	if (!status) {
		netdev->features |= NETIF_F_HIGHDMA;
	} else {
5815
		status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
S
Sathya Perla 已提交
5816 5817 5818 5819 5820 5821
		if (status) {
			dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
			goto free_netdev;
		}
	}

5822 5823 5824
	status = pci_enable_pcie_error_reporting(pdev);
	if (!status)
		dev_info(&pdev->dev, "PCIe error reporting enabled\n");
S
Sathya Perla 已提交
5825

5826
	status = be_map_pci_bars(adapter);
S
Sathya Perla 已提交
5827
	if (status)
5828
		goto free_netdev;
S
Sathya Perla 已提交
5829

5830 5831 5832 5833
	status = be_drv_init(adapter);
	if (status)
		goto unmap_bars;

5834 5835
	status = be_setup(adapter);
	if (status)
5836
		goto drv_cleanup;
5837

5838
	be_netdev_init(netdev);
S
Sathya Perla 已提交
5839 5840
	status = register_netdev(netdev);
	if (status != 0)
5841
		goto unsetup;
S
Sathya Perla 已提交
5842

5843 5844
	be_roce_dev_add(adapter);

5845
	be_schedule_err_detection(adapter);
5846

5847
	/* On Die temperature not supported for VF. */
5848
	if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) {
5849 5850 5851 5852 5853 5854 5855 5856
		adapter->hwmon_info.hwmon_dev =
			devm_hwmon_device_register_with_groups(&pdev->dev,
							       DRV_NAME,
							       adapter,
							       be_hwmon_groups);
		adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP;
	}

S
Sathya Perla 已提交
5857
	dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
5858
		 func_name(adapter), mc_name(adapter), adapter->port_name);
5859

S
Sathya Perla 已提交
5860 5861
	return 0;

5862 5863
unsetup:
	be_clear(adapter);
5864 5865 5866 5867
drv_cleanup:
	be_drv_cleanup(adapter);
unmap_bars:
	be_unmap_pci_bars(adapter);
5868
free_netdev:
5869
	free_netdev(netdev);
S
Sathya Perla 已提交
5870 5871 5872 5873 5874
rel_reg:
	pci_release_regions(pdev);
disable_dev:
	pci_disable_device(pdev);
do_none:
5875
	dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
S
Sathya Perla 已提交
5876 5877 5878 5879 5880 5881 5882
	return status;
}

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

S
Suresh Reddy 已提交
5883
	if (adapter->wol_en)
5884 5885
		be_setup_wol(adapter, true);

5886
	be_intr_set(adapter, false);
5887
	be_cancel_err_detection(adapter);
5888

5889
	be_cleanup(adapter);
S
Sathya Perla 已提交
5890 5891 5892 5893 5894 5895 5896

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

5897
static int be_pci_resume(struct pci_dev *pdev)
S
Sathya Perla 已提交
5898 5899
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
5900
	int status = 0;
S
Sathya Perla 已提交
5901 5902 5903 5904 5905 5906 5907

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

	pci_restore_state(pdev);

5908
	status = be_resume(adapter);
5909 5910 5911
	if (status)
		return status;

5912 5913
	be_schedule_err_detection(adapter);

S
Suresh Reddy 已提交
5914
	if (adapter->wol_en)
5915
		be_setup_wol(adapter, false);
5916

S
Sathya Perla 已提交
5917 5918 5919
	return 0;
}

5920 5921 5922 5923 5924 5925 5926
/*
 * 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);

5927 5928
	if (!adapter)
		return;
5929

5930
	be_roce_dev_shutdown(adapter);
5931
	cancel_delayed_work_sync(&adapter->work);
5932
	be_cancel_err_detection(adapter);
5933

5934
	netif_device_detach(adapter->netdev);
5935

5936 5937
	be_cmd_reset_function(adapter);

5938 5939 5940
	pci_disable_device(pdev);
}

5941
static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
5942
					    pci_channel_state_t state)
5943 5944 5945 5946 5947
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);

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

5948 5949
	if (!be_check_error(adapter, BE_ERROR_EEH)) {
		be_set_error(adapter, BE_ERROR_EEH);
5950

5951
		be_cancel_err_detection(adapter);
5952

5953
		be_cleanup(adapter);
5954 5955 5956 5957 5958 5959 5960
	}

	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

	pci_disable_device(pdev);

5961 5962
	/* The error could cause the FW to trigger a flash debug dump.
	 * Resetting the card while flash dump is in progress
5963 5964 5965
	 * can cause it not to recover; wait for it to finish.
	 * Wait only for first function as it is needed only once per
	 * adapter.
5966
	 */
5967 5968 5969
	if (pdev->devfn == 0)
		ssleep(30);

5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987
	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");

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

	pci_set_master(pdev);
	pci_restore_state(pdev);

	/* Check if card is ok and fw is ready */
5988 5989
	dev_info(&adapter->pdev->dev,
		 "Waiting for FW to be ready after EEH reset\n");
5990
	status = be_fw_wait_ready(adapter);
5991 5992 5993
	if (status)
		return PCI_ERS_RESULT_DISCONNECT;

S
Sathya Perla 已提交
5994
	pci_cleanup_aer_uncorrect_error_status(pdev);
5995
	be_clear_error(adapter, BE_CLEAR_ALL);
5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007
	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);

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

	pci_save_state(pdev);

6008
	status = be_resume(adapter);
6009 6010 6011
	if (status)
		goto err;

6012
	be_schedule_err_detection(adapter);
6013 6014 6015 6016 6017
	return;
err:
	dev_err(&adapter->pdev->dev, "EEH resume failed\n");
}

6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071
static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
{
	struct be_adapter *adapter = pci_get_drvdata(pdev);
	u16 num_vf_qs;
	int status;

	if (!num_vfs)
		be_vf_clear(adapter);

	adapter->num_vfs = num_vfs;

	if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) {
		dev_warn(&pdev->dev,
			 "Cannot disable VFs while they are assigned\n");
		return -EBUSY;
	}

	/* When the HW is in SRIOV capable configuration, the PF-pool resources
	 * are equally distributed across the max-number of VFs. The user may
	 * request only a subset of the max-vfs to be enabled.
	 * Based on num_vfs, redistribute the resources across num_vfs so that
	 * each VF will have access to more number of resources.
	 * This facility is not available in BE3 FW.
	 * Also, this is done by FW in Lancer chip.
	 */
	if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) {
		num_vf_qs = be_calculate_vf_qs(adapter, adapter->num_vfs);
		status = be_cmd_set_sriov_config(adapter, adapter->pool_res,
						 adapter->num_vfs, num_vf_qs);
		if (status)
			dev_err(&pdev->dev,
				"Failed to optimize SR-IOV resources\n");
	}

	status = be_get_resources(adapter);
	if (status)
		return be_cmd_status(status);

	/* Updating real_num_tx/rx_queues() requires rtnl_lock() */
	rtnl_lock();
	status = be_update_queues(adapter);
	rtnl_unlock();
	if (status)
		return be_cmd_status(status);

	if (adapter->num_vfs)
		status = be_vf_setup(adapter);

	if (!status)
		return adapter->num_vfs;

	return 0;
}

6072
static const struct pci_error_handlers be_eeh_handlers = {
6073 6074 6075 6076 6077
	.error_detected = be_eeh_err_detected,
	.slot_reset = be_eeh_reset,
	.resume = be_eeh_resume,
};

S
Sathya Perla 已提交
6078 6079 6080 6081 6082 6083
static struct pci_driver be_driver = {
	.name = DRV_NAME,
	.id_table = be_dev_ids,
	.probe = be_probe,
	.remove = be_remove,
	.suspend = be_suspend,
6084
	.resume = be_pci_resume,
6085
	.shutdown = be_shutdown,
6086
	.sriov_configure = be_pci_sriov_configure,
6087
	.err_handler = &be_eeh_handlers
S
Sathya Perla 已提交
6088 6089 6090 6091
};

static int __init be_init_module(void)
{
6092 6093
	if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
	    rx_frag_size != 2048) {
S
Sathya Perla 已提交
6094 6095 6096 6097 6098 6099
		printk(KERN_WARNING DRV_NAME
			" : Module param rx_frag_size must be 2048/4096/8192."
			" Using 2048\n");
		rx_frag_size = 2048;
	}

6100 6101 6102 6103 6104
	if (num_vfs > 0) {
		pr_info(DRV_NAME " : Module param num_vfs is obsolete.");
		pr_info(DRV_NAME " : Use sysfs method to enable VFs\n");
	}

S
Sathya Perla 已提交
6105 6106 6107 6108 6109 6110 6111 6112 6113
	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);