be.h 23.2 KB
Newer Older
Sathya Perla's avatar
Sathya Perla committed
1
/*
2
 * Copyright (C) 2005 - 2014 Emulex
Sathya Perla's avatar
Sathya Perla committed
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
Sathya Perla's avatar
Sathya Perla committed
12
 *
13
14
15
 * Emulex
 * 3333 Susan Street
 * Costa Mesa, CA 92626
Sathya Perla's avatar
Sathya Perla committed
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 */

#ifndef BE_H
#define BE_H

#include <linux/pci.h>
#include <linux/etherdevice.h>
#include <linux/delay.h>
#include <net/tcp.h>
#include <net/ip.h>
#include <net/ipv6.h>
#include <linux/if_vlan.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
30
#include <linux/firmware.h>
31
#include <linux/slab.h>
32
#include <linux/u64_stats_sync.h>
Sathya Perla's avatar
Sathya Perla committed
33
34

#include "be_hw.h"
35
#include "be_roce.h"
Sathya Perla's avatar
Sathya Perla committed
36

37
#define DRV_VER			"10.4u"
Sathya Perla's avatar
Sathya Perla committed
38
#define DRV_NAME		"be2net"
39
40
41
#define BE_NAME			"Emulex BladeEngine2"
#define BE3_NAME		"Emulex BladeEngine3"
#define OC_NAME			"Emulex OneConnect"
42
43
#define OC_NAME_BE		OC_NAME	"(be3)"
#define OC_NAME_LANCER		OC_NAME "(Lancer)"
44
#define OC_NAME_SH		OC_NAME "(Skyhawk)"
45
#define DRV_DESC		"Emulex OneConnect NIC Driver"
Sathya Perla's avatar
Sathya Perla committed
46

47
#define BE_VENDOR_ID 		0x19a2
48
#define EMULEX_VENDOR_ID	0x10df
49
#define BE_DEVICE_ID1		0x211
50
#define BE_DEVICE_ID2		0x221
51
52
53
#define OC_DEVICE_ID1		0x700	/* Device Id for BE2 cards */
#define OC_DEVICE_ID2		0x710	/* Device Id for BE3 cards */
#define OC_DEVICE_ID3		0xe220	/* Device id for Lancer cards */
54
#define OC_DEVICE_ID4           0xe228   /* Device id for VF in Lancer */
55
#define OC_DEVICE_ID5		0x720	/* Device Id for Skyhawk cards */
56
#define OC_DEVICE_ID6		0x728   /* Device id for VF in SkyHawk */
57
58
59
60
#define OC_SUBSYS_DEVICE_ID1	0xE602
#define OC_SUBSYS_DEVICE_ID2	0xE642
#define OC_SUBSYS_DEVICE_ID3	0xE612
#define OC_SUBSYS_DEVICE_ID4	0xE652
61
62
63

static inline char *nic_name(struct pci_dev *pdev)
{
64
65
	switch (pdev->device) {
	case OC_DEVICE_ID1:
66
		return OC_NAME;
67
	case OC_DEVICE_ID2:
68
69
		return OC_NAME_BE;
	case OC_DEVICE_ID3:
70
	case OC_DEVICE_ID4:
71
		return OC_NAME_LANCER;
72
73
	case BE_DEVICE_ID2:
		return BE3_NAME;
74
	case OC_DEVICE_ID5:
75
	case OC_DEVICE_ID6:
76
		return OC_NAME_SH;
77
	default:
78
		return BE_NAME;
79
	}
80
81
}

Sathya Perla's avatar
Sathya Perla committed
82
/* Number of bytes of an RX frame that are copied to skb->data */
83
#define BE_HDR_LEN		((u16) 64)
84
85
86
/* allocate extra space to allow tunneling decapsulation without head reallocation */
#define BE_RX_SKB_ALLOC_SIZE (BE_HDR_LEN + 64)

Sathya Perla's avatar
Sathya Perla committed
87
88
#define BE_MAX_JUMBO_FRAME_SIZE	9018
#define BE_MIN_MTU		256
Kalesh AP's avatar
Kalesh AP committed
89
90
#define BE_MAX_MTU              (BE_MAX_JUMBO_FRAME_SIZE -	\
				 (ETH_HLEN + ETH_FCS_LEN))
Sathya Perla's avatar
Sathya Perla committed
91
92

#define BE_NUM_VLANS_SUPPORTED	64
93
#define BE_MAX_EQD		128u
Sathya Perla's avatar
Sathya Perla committed
94
95
96
97
98
99
100
#define	BE_MAX_TX_FRAG_COUNT	30

#define EVNT_Q_LEN		1024
#define TX_Q_LEN		2048
#define TX_CQ_LEN		1024
#define RX_Q_LEN		1024	/* Does not support any other value */
#define RX_CQ_LEN		1024
101
#define MCC_Q_LEN		128	/* total size not to exceed 8 pages */
Sathya Perla's avatar
Sathya Perla committed
102
103
#define MCC_CQ_LEN		256

Sathya Perla's avatar
Sathya Perla committed
104
#define BE2_MAX_RSS_QS		4
105
106
107
#define BE3_MAX_RSS_QS		16
#define BE3_MAX_TX_QS		16
#define BE3_MAX_EVT_QS		16
108
#define BE3_SRIOV_MAX_EVT_QS	8
109
110
111
112

#define MAX_RX_QS		32
#define MAX_EVT_QS		32
#define MAX_TX_QS		32
Sathya Perla's avatar
Sathya Perla committed
113

114
#define MAX_ROCE_EQS		5
115
#define MAX_MSIX_VECTORS	32
116
#define MIN_MSIX_VECTORS	1
Sathya Perla's avatar
Sathya Perla committed
117
#define BE_NAPI_WEIGHT		64
Sathya Perla's avatar
Sathya Perla committed
118
#define MAX_RX_POST		BE_NAPI_WEIGHT /* Frags posted at a time */
Sathya Perla's avatar
Sathya Perla committed
119
120
#define RX_FRAGS_REFILL_WM	(RX_Q_LEN - MAX_RX_POST)

121
#define MAX_VFS			30 /* Max VFs supported by BE3 FW */
122
123
#define FW_VER_LEN		32

124
125
126
#define	RSS_INDIR_TABLE_LEN	128
#define RSS_HASH_KEY_LEN	40

Sathya Perla's avatar
Sathya Perla committed
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
struct be_dma_mem {
	void *va;
	dma_addr_t dma;
	u32 size;
};

struct be_queue_info {
	struct be_dma_mem dma_mem;
	u16 len;
	u16 entry_size;	/* Size of an element in the queue */
	u16 id;
	u16 tail, head;
	bool created;
	atomic_t used;	/* Number of valid elements in the queue */
};

143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
static inline u32 MODULO(u16 val, u16 limit)
{
	BUG_ON(limit & (limit - 1));
	return val & (limit - 1);
}

static inline void index_adv(u16 *index, u16 val, u16 limit)
{
	*index = MODULO((*index + val), limit);
}

static inline void index_inc(u16 *index, u16 limit)
{
	*index = MODULO((*index + 1), limit);
}

static inline void *queue_head_node(struct be_queue_info *q)
{
	return q->dma_mem.va + q->head * q->entry_size;
}

static inline void *queue_tail_node(struct be_queue_info *q)
{
	return q->dma_mem.va + q->tail * q->entry_size;
}

169
170
171
172
173
static inline void *queue_index_node(struct be_queue_info *q, u16 index)
{
	return q->dma_mem.va + index * q->entry_size;
}

174
175
176
177
178
static inline void queue_head_inc(struct be_queue_info *q)
{
	index_inc(&q->head, q->len);
}

179
180
181
182
183
static inline void index_dec(u16 *index, u16 limit)
{
	*index = MODULO((*index - 1), limit);
}

184
185
186
187
188
189
190
191
192
193
194
static inline void queue_tail_inc(struct be_queue_info *q)
{
	index_inc(&q->tail, q->len);
}

struct be_eq_obj {
	struct be_queue_info q;
	char desc[32];

	/* Adaptive interrupt coalescing (AIC) info */
	bool enable_aic;
Sathya Perla's avatar
Sathya Perla committed
195
196
197
198
	u32 min_eqd;		/* in usecs */
	u32 max_eqd;		/* in usecs */
	u32 eqd;		/* configured val when aic is off */
	u32 cur_eqd;		/* in usecs */
199

Sathya Perla's avatar
Sathya Perla committed
200
	u8 idx;			/* array index */
201
	u8 msix_idx;
202
	u16 spurious_intr;
203
	struct napi_struct napi;
Sathya Perla's avatar
Sathya Perla committed
204
	struct be_adapter *adapter;
205
206
207
208
209
210
211
212
213
214
215
216
217

#ifdef CONFIG_NET_RX_BUSY_POLL
#define BE_EQ_IDLE		0
#define BE_EQ_NAPI		1	/* napi owns this EQ */
#define BE_EQ_POLL		2	/* poll owns this EQ */
#define BE_EQ_LOCKED		(BE_EQ_NAPI | BE_EQ_POLL)
#define BE_EQ_NAPI_YIELD	4	/* napi yielded this EQ */
#define BE_EQ_POLL_YIELD	8	/* poll yielded this EQ */
#define BE_EQ_YIELD		(BE_EQ_NAPI_YIELD | BE_EQ_POLL_YIELD)
#define BE_EQ_USER_PEND		(BE_EQ_POLL | BE_EQ_POLL_YIELD)
	unsigned int state;
	spinlock_t lock;	/* lock to serialize napi and busy-poll */
#endif  /* CONFIG_NET_RX_BUSY_POLL */
Sathya Perla's avatar
Sathya Perla committed
218
} ____cacheline_aligned_in_smp;
219

220
221
222
223
224
225
226
227
228
229
230
struct be_aic_obj {		/* Adaptive interrupt coalescing (AIC) info */
	bool enable;
	u32 min_eqd;		/* in usecs */
	u32 max_eqd;		/* in usecs */
	u32 prev_eqd;		/* in usecs */
	u32 et_eqd;		/* configured val when aic is off */
	ulong jiffies;
	u64 rx_pkts_prev;	/* Used to calculate RX pps */
	u64 tx_reqs_prev;	/* Used to calculate TX pps */
};

231
232
233
234
235
enum {
	NAPI_POLLING,
	BUSY_POLLING
};

236
237
238
struct be_mcc_obj {
	struct be_queue_info q;
	struct be_queue_info cq;
239
	bool rearm_cq;
240
241
};

242
struct be_tx_stats {
243
244
245
246
247
248
249
	u64 tx_bytes;
	u64 tx_pkts;
	u64 tx_reqs;
	u64 tx_wrbs;
	u64 tx_compl;
	ulong tx_jiffies;
	u32 tx_stops;
250
	u32 tx_drv_drops;	/* pkts dropped by driver */
251
252
253
254
255
256
257
	/* the error counters are described in be_ethtool.c */
	u32 tx_hdr_parse_err;
	u32 tx_dma_err;
	u32 tx_tso_err;
	u32 tx_spoof_check_err;
	u32 tx_qinq_err;
	u32 tx_internal_parity_err;
258
259
	struct u64_stats_sync sync;
	struct u64_stats_sync sync_compl;
Sathya Perla's avatar
Sathya Perla committed
260
261
262
};

struct be_tx_obj {
263
	u32 db_offset;
Sathya Perla's avatar
Sathya Perla committed
264
265
266
267
	struct be_queue_info q;
	struct be_queue_info cq;
	/* Remember the skbs that were transmitted */
	struct sk_buff *sent_skb_list[TX_Q_LEN];
268
	struct be_tx_stats stats;
Sathya Perla's avatar
Sathya Perla committed
269
} ____cacheline_aligned_in_smp;
Sathya Perla's avatar
Sathya Perla committed
270
271
272
273

/* Struct to remember the pages posted for rx frags */
struct be_rx_page_info {
	struct page *page;
274
	/* set to page-addr for last frag of the page & frag-addr otherwise */
275
	DEFINE_DMA_UNMAP_ADDR(bus);
Sathya Perla's avatar
Sathya Perla committed
276
	u16 page_offset;
277
	bool last_frag;		/* last frag of the page */
Sathya Perla's avatar
Sathya Perla committed
278
279
};

280
281
282
struct be_rx_stats {
	u64 rx_bytes;
	u64 rx_pkts;
283
284
285
286
	u32 rx_drops_no_skbs;	/* skb allocation errors */
	u32 rx_drops_no_frags;	/* HW has no fetched frags */
	u32 rx_post_fail;	/* page post alloc failures */
	u32 rx_compl;
287
	u32 rx_mcast_pkts;
288
	u32 rx_compl_err;	/* completions with err set */
289
	struct u64_stats_sync sync;
290
291
};

292
293
struct be_rx_compl_info {
	u32 rss_hash;
294
	u16 vlan_tag;
295
	u16 pkt_size;
296
	u16 port;
297
298
299
300
301
302
303
304
305
	u8 vlanf;
	u8 num_rcvd;
	u8 err;
	u8 ipf;
	u8 tcpf;
	u8 udpf;
	u8 ip_csum;
	u8 l4_csum;
	u8 ipv6;
306
	u8 qnq;
307
	u8 pkt_type;
308
	u8 ip_frag;
309
	u8 tunneled;
310
311
};

Sathya Perla's avatar
Sathya Perla committed
312
struct be_rx_obj {
313
	struct be_adapter *adapter;
Sathya Perla's avatar
Sathya Perla committed
314
315
	struct be_queue_info q;
	struct be_queue_info cq;
316
	struct be_rx_compl_info rxcp;
Sathya Perla's avatar
Sathya Perla committed
317
	struct be_rx_page_info page_info_tbl[RX_Q_LEN];
318
319
320
	struct be_rx_stats stats;
	u8 rss_id;
	bool rx_post_starved;	/* Zero rx frags have been posted to BE */
Sathya Perla's avatar
Sathya Perla committed
321
} ____cacheline_aligned_in_smp;
Sathya Perla's avatar
Sathya Perla committed
322

323
struct be_drv_stats {
324
	u32 be_on_die_temperature;
325
	u32 eth_red_drops;
326
	u32 dma_map_errors;
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
	u32 rx_drops_no_pbuf;
	u32 rx_drops_no_txpb;
	u32 rx_drops_no_erx_descr;
	u32 rx_drops_no_tpre_descr;
	u32 rx_drops_too_many_frags;
	u32 forwarded_packets;
	u32 rx_drops_mtu;
	u32 rx_crc_errors;
	u32 rx_alignment_symbol_errors;
	u32 rx_pause_frames;
	u32 rx_priority_pause_frames;
	u32 rx_control_frames;
	u32 rx_in_range_errors;
	u32 rx_out_range_errors;
	u32 rx_frame_too_long;
342
	u32 rx_address_filtered;
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
	u32 rx_dropped_too_small;
	u32 rx_dropped_too_short;
	u32 rx_dropped_header_too_small;
	u32 rx_dropped_tcp_length;
	u32 rx_dropped_runt;
	u32 rx_ip_checksum_errs;
	u32 rx_tcp_checksum_errs;
	u32 rx_udp_checksum_errs;
	u32 tx_pauseframes;
	u32 tx_priority_pauseframes;
	u32 tx_controlframes;
	u32 rxpp_fifo_overflow_drop;
	u32 rx_input_fifo_overflow_drop;
	u32 pmem_fifo_overflow_drop;
	u32 jabber_events;
358
359
360
361
362
	u32 rx_roce_bytes_lsd;
	u32 rx_roce_bytes_msd;
	u32 rx_roce_frames;
	u32 roce_drops_payload_len;
	u32 roce_drops_crc;
363
364
};

365
366
367
/* A vlan-id of 0xFFFF must be used to clear transparent vlan-tagging */
#define BE_RESET_VLAN_TAG_ID	0xFFFF

368
struct be_vf_cfg {
369
370
371
372
373
	unsigned char mac_addr[ETH_ALEN];
	int if_handle;
	int pmac_id;
	u16 vlan_tag;
	u32 tx_rate;
374
	u32 plink_tracking;
375
376
};

377
378
379
380
381
enum vf_state {
	ENABLED = 0,
	ASSIGNED = 1
};

382
#define BE_FLAGS_LINK_STATUS_INIT		1
383
#define BE_FLAGS_SRIOV_ENABLED			(1 << 2)
384
#define BE_FLAGS_WORKER_SCHEDULED		(1 << 3)
385
#define BE_FLAGS_VLAN_PROMISC			(1 << 4)
386
#define BE_FLAGS_MCAST_PROMISC			(1 << 5)
387
#define BE_FLAGS_NAPI_ENABLED			(1 << 9)
388
#define BE_FLAGS_QNQ_ASYNC_EVT_RCVD		(1 << 11)
389
#define BE_FLAGS_VXLAN_OFFLOADS			(1 << 12)
390
#define BE_FLAGS_SETUP_DONE			(1 << 13)
391

392
393
#define BE_UC_PMAC_COUNT			30
#define BE_VF_UC_PMAC_COUNT			2
394

395
396
/* Ethtool set_dump flags */
#define LANCER_INITIATE_FW_DUMP			0x1
397
#define LANCER_DELETE_FW_DUMP			0x2
398

399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
struct phy_info {
	u8 transceiver;
	u8 autoneg;
	u8 fc_autoneg;
	u8 port_type;
	u16 phy_type;
	u16 interface_type;
	u32 misc_params;
	u16 auto_speeds_supported;
	u16 fixed_speeds_supported;
	int link_speed;
	u32 dac_cable_len;
	u32 advertising;
	u32 supported;
};

415
416
417
418
419
420
421
422
423
424
struct be_resources {
	u16 max_vfs;		/* Total VFs "really" supported by FW/HW */
	u16 max_mcast_mac;
	u16 max_tx_qs;
	u16 max_rss_qs;
	u16 max_rx_qs;
	u16 max_uc_mac;		/* Max UC MACs programmable */
	u16 max_vlans;		/* Number of vlans supported */
	u16 max_evt_qs;
	u32 if_cap_flags;
425
	u32 vf_if_cap_flags;	/* VF if capability flags */
426
427
};

428
429
430
431
432
433
434
struct rss_info {
	u64 rss_flags;
	u8 rsstable[RSS_INDIR_TABLE_LEN];
	u8 rss_queue[RSS_INDIR_TABLE_LEN];
	u8 rss_hkey[RSS_HASH_KEY_LEN];
};

Sathya Perla's avatar
Sathya Perla committed
435
436
437
438
struct be_adapter {
	struct pci_dev *pdev;
	struct net_device *netdev;

439
	u8 __iomem *csr;	/* CSR BAR used only for BE2/3 */
440
441
	u8 __iomem *db;		/* Door Bell */

442
	struct mutex mbox_lock; /* For serializing mbox cmds to BE card */
443
444
445
446
447
448
449
450
	struct be_dma_mem mbox_mem;
	/* Mbox mem is adjusted to align to 16 bytes. The allocated addr
	 * is stored for freeing purpose */
	struct be_dma_mem mbox_mem_alloced;

	struct be_mcc_obj mcc_obj;
	spinlock_t mcc_lock;	/* For serializing mcc cmds to BE card */
	spinlock_t mcc_cq_lock;
Sathya Perla's avatar
Sathya Perla committed
451

452
453
454
455
	u16 cfg_num_qs;		/* configured via set-channels */
	u16 num_evt_qs;
	u16 num_msix_vec;
	struct be_eq_obj eq_obj[MAX_EVT_QS];
Sathya Perla's avatar
Sathya Perla committed
456
	struct msix_entry msix_entries[MAX_MSIX_VECTORS];
Sathya Perla's avatar
Sathya Perla committed
457
458
459
	bool isr_registered;

	/* TX Rings */
460
	u16 num_tx_qs;
461
	struct be_tx_obj tx_obj[MAX_TX_QS];
Sathya Perla's avatar
Sathya Perla committed
462
463

	/* Rx rings */
464
	u16 num_rx_qs;
Sathya Perla's avatar
Sathya Perla committed
465
	struct be_rx_obj rx_obj[MAX_RX_QS];
Sathya Perla's avatar
Sathya Perla committed
466
467
	u32 big_page_size;	/* Compounded page size shared by rx wrbs */

468
	struct be_drv_stats drv_stats;
469
	struct be_aic_obj aic_obj[MAX_EVT_QS];
470
	u16 vlans_added;
471
	unsigned long vids[BITS_TO_LONGS(VLAN_N_VID)];
472
473
	u8 vlan_prio_bmap;	/* Available Priority BitMap */
	u16 recommended_prio;	/* Recommended Priority */
474
	struct be_dma_mem rx_filter; /* Cmd DMA mem for rx-filter */
Sathya Perla's avatar
Sathya Perla committed
475

476
	struct be_dma_mem stats_cmd;
Sathya Perla's avatar
Sathya Perla committed
477
478
	/* Work queue used to perform periodic tasks like getting statistics */
	struct delayed_work work;
479
	u16 work_counter;
Sathya Perla's avatar
Sathya Perla committed
480

481
	struct delayed_work func_recovery_work;
482
	u32 flags;
483
	u32 cmd_privileges;
Sathya Perla's avatar
Sathya Perla committed
484
485
	/* Ethtool knobs and info */
	char fw_ver[FW_VER_LEN];
486
	char fw_on_flash[FW_VER_LEN];
487
	int if_handle;		/* Used to configure filtering */
488
	u32 *pmac_id;		/* MAC addr handle used by BE card */
489
	u32 beacon_state;	/* for set_phys_id */
Sathya Perla's avatar
Sathya Perla committed
490

491
	bool eeh_error;
492
	bool fw_timeout;
493
494
	bool hw_error;

Sathya Perla's avatar
Sathya Perla committed
495
	u32 port_num;
496
	bool promiscuous;
497
	u8 mc_type;
Ajit Khaparde's avatar
Ajit Khaparde committed
498
	u32 function_mode;
499
	u32 function_caps;
500
501
	u32 rx_fc;		/* Rx flow control */
	u32 tx_fc;		/* Tx flow control */
Ajit Khaparde's avatar
Ajit Khaparde committed
502
	bool stats_cmd_sent;
503
504
505
506
507
508
509
510
511
	struct {
		u32 size;
		u32 total_size;
		u64 io_addr;
	} roce_db;
	u32 num_msix_roce_vec;
	struct ocrdma_dev *ocrdma_dev;
	struct list_head entry;

512
	u32 flash_status;
513
	struct completion et_cmd_compl;
514

515
	struct be_resources pool_res;	/* resources available for the port */
516
517
	struct be_resources res;	/* resources available for the func */
	u16 num_vfs;			/* Number of VFs provisioned by PF */
518
	u8 virtfn;
519
520
	struct be_vf_cfg *vf_cfg;
	bool be3_native;
521
	u32 sli_family;
522
	u8 hba_port_num;
523
	u16 pvid;
524
	__be16 vxlan_port;
525
	struct phy_info phy;
526
	u8 wol_cap;
527
	bool wol_en;
528
	u32 uc_macs;		/* Count of secondary UC MAC programmed */
529
	u16 asic_rev;
530
	u16 qnq_vid;
531
	u32 msg_enable;
532
	int be_get_temp_freq;
533
	u8 pf_number;
534
	struct rss_info rss_info;
Sathya Perla's avatar
Sathya Perla committed
535
536
};

537
#define be_physfn(adapter)		(!adapter->virtfn)
538
#define be_virtfn(adapter)		(adapter->virtfn)
539
540
#define sriov_enabled(adapter)		(adapter->flags &	\
					 BE_FLAGS_SRIOV_ENABLED)
541

542
543
544
#define for_all_vfs(adapter, vf_cfg, i)					\
	for (i = 0, vf_cfg = &adapter->vf_cfg[i]; i < adapter->num_vfs;	\
		i++, vf_cfg++)
545

546
547
#define ON				1
#define OFF				0
548

549
550
551
#define be_max_vlans(adapter)		(adapter->res.max_vlans)
#define be_max_uc(adapter)		(adapter->res.max_uc_mac)
#define be_max_mc(adapter)		(adapter->res.max_mcast_mac)
552
#define be_max_vfs(adapter)		(adapter->pool_res.max_vfs)
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
#define be_max_rss(adapter)		(adapter->res.max_rss_qs)
#define be_max_txqs(adapter)		(adapter->res.max_tx_qs)
#define be_max_prio_txqs(adapter)	(adapter->res.max_prio_tx_qs)
#define be_max_rxqs(adapter)		(adapter->res.max_rx_qs)
#define be_max_eqs(adapter)		(adapter->res.max_evt_qs)
#define be_if_cap_flags(adapter)	(adapter->res.if_cap_flags)

static inline u16 be_max_qs(struct be_adapter *adapter)
{
	/* If no RSS, need atleast the one def RXQ */
	u16 num = max_t(u16, be_max_rss(adapter), 1);

	num = min(num, be_max_eqs(adapter));
	return min_t(u16, num, num_online_cpus());
}

569
570
571
572
/* Is BE in pvid_tagging mode */
#define be_pvid_tagging_enabled(adapter)	(adapter->pvid)

/* Is BE in QNQ multi-channel mode */
573
#define be_is_qnq_mode(adapter)		(adapter->function_mode & QNQ_MODE)
574

575
576
#define lancer_chip(adapter)	(adapter->pdev->device == OC_DEVICE_ID3 || \
				 adapter->pdev->device == OC_DEVICE_ID4)
577

578
579
#define skyhawk_chip(adapter)	(adapter->pdev->device == OC_DEVICE_ID5 || \
				 adapter->pdev->device == OC_DEVICE_ID6)
580

581
582
583
584
585
586
587
#define BE3_chip(adapter)	(adapter->pdev->device == BE_DEVICE_ID2 || \
				 adapter->pdev->device == OC_DEVICE_ID2)

#define BE2_chip(adapter)	(adapter->pdev->device == BE_DEVICE_ID1 || \
				 adapter->pdev->device == OC_DEVICE_ID1)

#define BEx_chip(adapter)	(BE3_chip(adapter) || BE2_chip(adapter))
588

Sathya Perla's avatar
Sathya Perla committed
589
590
#define be_roce_supported(adapter)	(skyhawk_chip(adapter) && \
					(adapter->function_mode & RDMA_ENABLED))
591

592
extern const struct ethtool_ops be_ethtool_ops;
Sathya Perla's avatar
Sathya Perla committed
593

594
#define msix_enabled(adapter)		(adapter->num_msix_vec > 0)
Sathya Perla's avatar
Sathya Perla committed
595
596
597
598
#define num_irqs(adapter)		(msix_enabled(adapter) ?	\
						adapter->num_msix_vec : 1)
#define tx_stats(txo)			(&(txo)->stats)
#define rx_stats(rxo)			(&(rxo)->stats)
Sathya Perla's avatar
Sathya Perla committed
599

Sathya Perla's avatar
Sathya Perla committed
600
601
/* The default RXQ is the last RXQ */
#define default_rxo(adpt)		(&adpt->rx_obj[adpt->num_rx_qs - 1])
Sathya Perla's avatar
Sathya Perla committed
602

603
604
605
606
#define for_all_rx_queues(adapter, rxo, i)				\
	for (i = 0, rxo = &adapter->rx_obj[i]; i < adapter->num_rx_qs;	\
		i++, rxo++)

Sathya Perla's avatar
Sathya Perla committed
607
/* Skip the default non-rss queue (last one)*/
608
#define for_all_rss_queues(adapter, rxo, i)				\
Sathya Perla's avatar
Sathya Perla committed
609
	for (i = 0, rxo = &adapter->rx_obj[i]; i < (adapter->num_rx_qs - 1);\
610
611
		i++, rxo++)

612
613
614
615
#define for_all_tx_queues(adapter, txo, i)				\
	for (i = 0, txo = &adapter->tx_obj[i]; i < adapter->num_tx_qs;	\
		i++, txo++)

Sathya Perla's avatar
Sathya Perla committed
616
617
618
619
#define for_all_evt_queues(adapter, eqo, i)				\
	for (i = 0, eqo = &adapter->eq_obj[i]; i < adapter->num_evt_qs; \
		i++, eqo++)

620
621
622
623
#define for_all_rx_queues_on_eq(adapter, eqo, rxo, i)			\
	for (i = eqo->idx, rxo = &adapter->rx_obj[i]; i < adapter->num_rx_qs;\
		 i += adapter->num_evt_qs, rxo += adapter->num_evt_qs)

624
625
626
627
#define for_all_tx_queues_on_eq(adapter, eqo, txo, i)			\
	for (i = eqo->idx, txo = &adapter->tx_obj[i]; i < adapter->num_tx_qs;\
		i += adapter->num_evt_qs, txo += adapter->num_evt_qs)

Sathya Perla's avatar
Sathya Perla committed
628
629
630
#define is_mcc_eqo(eqo)			(eqo->idx == 0)
#define mcc_eqo(adapter)		(&adapter->eq_obj[0])

Sathya Perla's avatar
Sathya Perla committed
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
#define PAGE_SHIFT_4K		12
#define PAGE_SIZE_4K		(1 << PAGE_SHIFT_4K)

/* Returns number of pages spanned by the data starting at the given addr */
#define PAGES_4K_SPANNED(_address, size) 				\
		((u32)((((size_t)(_address) & (PAGE_SIZE_4K - 1)) + 	\
			(size) + (PAGE_SIZE_4K - 1)) >> PAGE_SHIFT_4K))

/* Returns bit offset within a DWORD of a bitfield */
#define AMAP_BIT_OFFSET(_struct, field)  				\
		(((size_t)&(((_struct *)0)->field))%32)

/* Returns the bit mask of the field that is NOT shifted into location. */
static inline u32 amap_mask(u32 bitsize)
{
	return (bitsize == 32 ? 0xFFFFFFFF : (1 << bitsize) - 1);
}

static inline void
amap_set(void *ptr, u32 dw_offset, u32 mask, u32 offset, u32 value)
{
	u32 *dw = (u32 *) ptr + dw_offset;
	*dw &= ~(mask << offset);
	*dw |= (mask & value) << offset;
}

#define AMAP_SET_BITS(_struct, field, ptr, val)				\
		amap_set(ptr,						\
			offsetof(_struct, field)/32,			\
			amap_mask(sizeof(((_struct *)0)->field)),	\
			AMAP_BIT_OFFSET(_struct, field),		\
			val)

static inline u32 amap_get(void *ptr, u32 dw_offset, u32 mask, u32 offset)
{
	u32 *dw = (u32 *) ptr;
	return mask & (*(dw + dw_offset) >> offset);
}

#define AMAP_GET_BITS(_struct, field, ptr)				\
		amap_get(ptr,						\
			offsetof(_struct, field)/32,			\
			amap_mask(sizeof(((_struct *)0)->field)),	\
			AMAP_BIT_OFFSET(_struct, field))

676
677
678
679
680
681
682
683
684
685
686
687
#define GET_RX_COMPL_V0_BITS(field, ptr)				\
		AMAP_GET_BITS(struct amap_eth_rx_compl_v0, field, ptr)

#define GET_RX_COMPL_V1_BITS(field, ptr)				\
		AMAP_GET_BITS(struct amap_eth_rx_compl_v1, field, ptr)

#define GET_TX_COMPL_BITS(field, ptr)					\
		AMAP_GET_BITS(struct amap_eth_tx_compl, field, ptr)

#define SET_TX_WRB_HDR_BITS(field, ptr, val)				\
		AMAP_SET_BITS(struct amap_eth_hdr_wrb, field, ptr, val)

Sathya Perla's avatar
Sathya Perla committed
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
#define be_dws_cpu_to_le(wrb, len)	swap_dws(wrb, len)
#define be_dws_le_to_cpu(wrb, len)	swap_dws(wrb, len)
static inline void swap_dws(void *wrb, int len)
{
#ifdef __BIG_ENDIAN
	u32 *dw = wrb;
	BUG_ON(len % 4);
	do {
		*dw = cpu_to_le32(*dw);
		dw++;
		len -= 4;
	} while (len);
#endif				/* __BIG_ENDIAN */
}

703
704
#define be_cmd_status(status)		(status > 0 ? -EIO : status)

Sathya Perla's avatar
Sathya Perla committed
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
static inline u8 is_tcp_pkt(struct sk_buff *skb)
{
	u8 val = 0;

	if (ip_hdr(skb)->version == 4)
		val = (ip_hdr(skb)->protocol == IPPROTO_TCP);
	else if (ip_hdr(skb)->version == 6)
		val = (ipv6_hdr(skb)->nexthdr == NEXTHDR_TCP);

	return val;
}

static inline u8 is_udp_pkt(struct sk_buff *skb)
{
	u8 val = 0;

	if (ip_hdr(skb)->version == 4)
		val = (ip_hdr(skb)->protocol == IPPROTO_UDP);
	else if (ip_hdr(skb)->version == 6)
		val = (ipv6_hdr(skb)->nexthdr == NEXTHDR_UDP);

	return val;
}

729
730
static inline bool is_ipv4_pkt(struct sk_buff *skb)
{
Li RongQing's avatar
Li RongQing committed
731
	return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;
732
733
}

734
735
736
737
738
739
740
741
742
static inline 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);
743
744
	/* Use the OUI from the current MAC address */
	memcpy(mac, adapter->netdev->dev_addr, 3);
745
746
}

Ajit Khaparde's avatar
Ajit Khaparde committed
747
748
749
750
751
static inline bool be_multi_rxq(const struct be_adapter *adapter)
{
	return adapter->num_rx_qs > 1;
}

752
753
static inline bool be_error(struct be_adapter *adapter)
{
754
755
756
	return adapter->eeh_error || adapter->hw_error || adapter->fw_timeout;
}

757
static inline bool be_hw_error(struct be_adapter *adapter)
758
759
760
761
762
763
764
765
766
{
	return adapter->eeh_error || adapter->hw_error;
}

static inline void  be_clear_all_error(struct be_adapter *adapter)
{
	adapter->eeh_error = false;
	adapter->hw_error = false;
	adapter->fw_timeout = false;
767
768
}

769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
static inline bool be_is_wol_excluded(struct be_adapter *adapter)
{
	struct pci_dev *pdev = adapter->pdev;

	if (!be_physfn(adapter))
		return true;

	switch (pdev->subsystem_device) {
	case OC_SUBSYS_DEVICE_ID1:
	case OC_SUBSYS_DEVICE_ID2:
	case OC_SUBSYS_DEVICE_ID3:
	case OC_SUBSYS_DEVICE_ID4:
		return true;
	default:
		return false;
	}
}

787
788
789
790
791
static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
{
	return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
}

792
793
794
795
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
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
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
#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 */

892
893
894
895
896
897
898
899
void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,
		  u16 num_popped);
void be_link_status_update(struct be_adapter *adapter, u8 link_status);
void be_parse_stats(struct be_adapter *adapter);
int be_load_fw(struct be_adapter *adapter, u8 *func);
bool be_is_wol_supported(struct be_adapter *adapter);
bool be_pause_supported(struct be_adapter *adapter);
u32 be_get_fw_log_level(struct be_adapter *adapter);
900

901
902
903
904
905
906
907
908
909
static inline int fw_major_num(const char *fw_ver)
{
	int fw_major = 0;

	sscanf(fw_ver, "%d.", &fw_major);

	return fw_major;
}

910
911
int be_update_queues(struct be_adapter *adapter);
int be_poll(struct napi_struct *napi, int budget);
912

913
914
915
/*
 * internal function to initialize-cleanup roce device.
 */
916
917
void be_roce_dev_add(struct be_adapter *);
void be_roce_dev_remove(struct be_adapter *);
918
919
920
921

/*
 * internal function to open-close roce device during ifup-ifdown.
 */
922
923
void be_roce_dev_open(struct be_adapter *);
void be_roce_dev_close(struct be_adapter *);
924
void be_roce_dev_shutdown(struct be_adapter *);
925

Sathya Perla's avatar
Sathya Perla committed
926
#endif				/* BE_H */