mlx4: /dev/ -> /dev_vfs/
[akaros.git] / kern / drivers / net / mlx4 / mlx4_en.h
1 /*
2  * Copyright (c) 2007 Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33
34 #pragma once
35
36 #include <linux/mlx4/device.h>
37 #include <linux/mlx4/qp.h>
38 #include <linux/mlx4/cq.h>
39 #include <linux/mlx4/srq.h>
40 #include <linux/mlx4/doorbell.h>
41 #include <linux/mlx4/cmd.h>
42
43 #include "en_port.h"
44 #include "mlx4_stats.h"
45
46 #define DRV_NAME        "mlx4_en"
47 #define DRV_VERSION     "2.2-1"
48 #define DRV_RELDATE     "Feb 2014"
49
50 #define MLX4_EN_MSG_LEVEL       (NETIF_MSG_LINK | NETIF_MSG_IFDOWN)
51
52 /*
53  * Device constants
54  */
55
56
57 #define MLX4_EN_PAGE_SHIFT      12
58 #define MLX4_EN_PAGE_SIZE       (1 << MLX4_EN_PAGE_SHIFT)
59 #define DEF_RX_RINGS            16
60 #define MAX_RX_RINGS            128
61 #define MIN_RX_RINGS            4
62 #define TXBB_SIZE               64
63 #define HEADROOM                (2048 / TXBB_SIZE + 1)
64 #define STAMP_STRIDE            64
65 #define STAMP_DWORDS            (STAMP_STRIDE / 4)
66 #define STAMP_SHIFT             31
67 #define STAMP_VAL               0x7fffffff
68 #define STATS_DELAY             (HZ / 4)
69 #define SERVICE_TASK_DELAY      (HZ / 4)
70 #define MAX_NUM_OF_FS_RULES     256
71
72 #define MLX4_EN_FILTER_HASH_SHIFT 4
73 #define MLX4_EN_FILTER_EXPIRY_QUOTA 60
74
75 /* Typical TSO descriptor with 16 gather entries is 352 bytes... */
76 #define MAX_DESC_SIZE           512
77 #define MAX_DESC_TXBBS          (MAX_DESC_SIZE / TXBB_SIZE)
78
79 /*
80  * OS related constants and tunables
81  */
82
83 #define MLX4_EN_PRIV_FLAGS_BLUEFLAME 1
84
85 #define MLX4_EN_WATCHDOG_TIMEOUT        (15 * HZ)
86
87 /* Use the maximum between 16384 and a single page */
88 #define MLX4_EN_ALLOC_SIZE      PAGE_ALIGN(16384)
89
90 #define MLX4_EN_ALLOC_PREFER_ORDER      PAGE_ALLOC_COSTLY_ORDER
91
92 /* Receive fragment sizes; we use at most 3 fragments (for 9600 byte MTU
93  * and 4K allocations) */
94 enum {
95         FRAG_SZ0 = 1536 - NET_IP_ALIGN,
96         FRAG_SZ1 = 4096,
97         FRAG_SZ2 = 4096,
98         FRAG_SZ3 = MLX4_EN_ALLOC_SIZE
99 };
100 #define MLX4_EN_MAX_RX_FRAGS    4
101
102 /* Maximum ring sizes */
103 #define MLX4_EN_MAX_TX_SIZE     8192
104 #define MLX4_EN_MAX_RX_SIZE     8192
105
106 /* Minimum ring size for our page-allocation scheme to work */
107 #define MLX4_EN_MIN_RX_SIZE     (MLX4_EN_ALLOC_SIZE / SMP_CACHE_BYTES)
108 #define MLX4_EN_MIN_TX_SIZE     (4096 / TXBB_SIZE)
109
110 #define MLX4_EN_SMALL_PKT_SIZE          64
111 #define MLX4_EN_MIN_TX_RING_P_UP        1
112 #define MLX4_EN_MAX_TX_RING_P_UP        32
113 #define MLX4_EN_NUM_UP                  8
114 #define MLX4_EN_DEF_TX_RING_SIZE        512
115 #define MLX4_EN_DEF_RX_RING_SIZE        1024
116 #define MAX_TX_RINGS                    (MLX4_EN_MAX_TX_RING_P_UP * \
117                                          MLX4_EN_NUM_UP)
118
119 #define MLX4_EN_DEFAULT_TX_WORK         256
120
121 /* Target number of packets to coalesce with interrupt moderation */
122 #define MLX4_EN_RX_COAL_TARGET  44
123 #define MLX4_EN_RX_COAL_TIME    0x10
124
125 #define MLX4_EN_TX_COAL_PKTS    16
126 #define MLX4_EN_TX_COAL_TIME    0x10
127
128 #define MLX4_EN_RX_RATE_LOW             400000
129 #define MLX4_EN_RX_COAL_TIME_LOW        0
130 #define MLX4_EN_RX_RATE_HIGH            450000
131 #define MLX4_EN_RX_COAL_TIME_HIGH       128
132 #define MLX4_EN_RX_SIZE_THRESH          1024
133 #define MLX4_EN_RX_RATE_THRESH          (1000000 / MLX4_EN_RX_COAL_TIME_HIGH)
134 #define MLX4_EN_SAMPLE_INTERVAL         0
135 #define MLX4_EN_AVG_PKT_SMALL           256
136
137 #define MLX4_EN_AUTO_CONF       0xffff
138
139 #define MLX4_EN_DEF_RX_PAUSE    1
140 #define MLX4_EN_DEF_TX_PAUSE    1
141
142 /* Interval between successive polls in the Tx routine when polling is used
143    instead of interrupts (in per-core Tx rings) - should be power of 2 */
144 #define MLX4_EN_TX_POLL_MODER   16
145 #define MLX4_EN_TX_POLL_TIMEOUT (HZ / 4)
146
147 #define SMALL_PACKET_SIZE      (256 - NET_IP_ALIGN)
148 #define HEADER_COPY_SIZE       (128 - NET_IP_ALIGN)
149 #define MLX4_LOOPBACK_TEST_PAYLOAD (HEADER_COPY_SIZE - ETHERHDRSIZE)
150
151 #define MLX4_EN_MIN_MTU         46
152 #define ETH_BCAST               0xffffffffffffULL
153
154 #define MLX4_EN_LOOPBACK_RETRIES        5
155 #define MLX4_EN_LOOPBACK_TIMEOUT        100
156
157 #ifdef MLX4_EN_PERF_STAT
158 /* Number of samples to 'average' */
159 #define AVG_SIZE                        128
160 #define AVG_FACTOR                      1024
161
162 #define INC_PERF_COUNTER(cnt)           (++(cnt))
163 #define ADD_PERF_COUNTER(cnt, add)      ((cnt) += (add))
164 #define AVG_PERF_COUNTER(cnt, sample) \
165         ((cnt) = ((cnt) * (AVG_SIZE - 1) + (sample) * AVG_FACTOR) / AVG_SIZE)
166 #define GET_PERF_COUNTER(cnt)           (cnt)
167 #define GET_AVG_PERF_COUNTER(cnt)       ((cnt) / AVG_FACTOR)
168
169 #else
170
171 #define INC_PERF_COUNTER(cnt)           do {} while (0)
172 #define ADD_PERF_COUNTER(cnt, add)      do {} while (0)
173 #define AVG_PERF_COUNTER(cnt, sample)   do {} while (0)
174 #define GET_PERF_COUNTER(cnt)           (0)
175 #define GET_AVG_PERF_COUNTER(cnt)       (0)
176 #endif /* MLX4_EN_PERF_STAT */
177
178 /* Constants for TX flow */
179 enum {
180         MAX_INLINE = 104, /* 128 - 16 - 4 - 4 */
181         MAX_BF = 256,
182         MIN_PKT_LEN = 17,
183 };
184
185 /*
186  * Configurables
187  */
188
189 enum cq_type {
190         RX = 0,
191         TX = 1,
192 };
193
194
195 /*
196  * Useful macros
197  */
198 #define ROUNDUP_LOG2(x)         LOG2_UP(ROUNDUPPWR2(x))
199 #define XNOR(x, y)              (!(x) == !(y))
200
201
202 struct mlx4_en_tx_info {
203         struct block *block;
204         dma_addr_t      map0_dma;
205         uint32_t                map0_byte_count;
206         uint32_t                nr_txbb;
207         uint32_t                nr_bytes;
208         uint8_t         linear;
209         uint8_t         data_offset;
210         uint8_t         inl;
211         uint8_t         ts_requested;
212         uint8_t         nr_maps;
213 } ____cacheline_aligned_in_smp;
214
215
216 #define MLX4_EN_BIT_DESC_OWN    0x80000000
217 #define CTRL_SIZE       sizeof(struct mlx4_wqe_ctrl_seg)
218 #define MLX4_EN_MEMTYPE_PAD     0x100
219 #define DS_SIZE         sizeof(struct mlx4_wqe_data_seg)
220
221
222 struct mlx4_en_tx_desc {
223         struct mlx4_wqe_ctrl_seg ctrl;
224         union {
225                 struct mlx4_wqe_data_seg data; /* at least one data segment */
226                 struct mlx4_wqe_lso_seg lso;
227                 struct mlx4_wqe_inline_seg inl;
228         };
229 };
230
231 #define MLX4_EN_USE_SRQ         0x01000000
232
233 #define MLX4_EN_CX3_LOW_ID      0x1000
234 #define MLX4_EN_CX3_HIGH_ID     0x1005
235
236 struct mlx4_en_rx_alloc {
237         struct page     *page;
238         dma_addr_t      dma;
239         uint32_t                page_offset;
240         uint32_t                page_size;
241 };
242
243 struct mlx4_en_tx_ring {
244         /* cache line used and dirtied in tx completion
245          * (mlx4_en_free_tx_buf())
246          */
247         uint32_t                        last_nr_txbb;
248         uint32_t                        cons;
249         unsigned long           wake_queue;
250
251         /* cache line used and dirtied in mlx4_en_xmit() */
252         uint32_t                        prod ____cacheline_aligned_in_smp;
253         unsigned long           bytes;
254         unsigned long           packets;
255         unsigned long           tx_csum;
256         unsigned long           tso_packets;
257         unsigned long           xmit_more;
258         struct mlx4_bf          bf;
259         unsigned long           queue_stopped;
260
261         /* Following part should be mostly read */
262         cpumask_t               affinity_mask;
263         struct mlx4_qp          qp;
264         struct mlx4_hwq_resources wqres;
265         uint32_t                        size; /* number of TXBBs */
266         uint32_t                        size_mask;
267         uint16_t                        stride;
268         uint16_t                        cqn;    /* index of port CQ associated with this ring */
269         uint32_t                        buf_size;
270         __be32                  doorbell_qpn;
271         __be32                  mr_key;
272         void                    *buf;
273         struct mlx4_en_tx_info  *tx_info;
274         uint8_t                 *bounce_buf;
275         struct mlx4_qp_context  context;
276         int                     qpn;
277         enum mlx4_qp_state      qp_state;
278         uint8_t                 queue_index;
279         bool                    bf_enabled;
280         bool                    bf_alloced;
281         struct netdev_queue     *tx_queue;
282         int                     hwtstamp_tx_type;
283 } ____cacheline_aligned_in_smp;
284
285 struct mlx4_en_rx_desc {
286         /* actual number of entries depends on rx ring stride */
287         struct mlx4_wqe_data_seg data[0];
288 };
289
290 struct mlx4_en_rx_ring {
291         struct mlx4_hwq_resources wqres;
292         struct mlx4_en_rx_alloc page_alloc[MLX4_EN_MAX_RX_FRAGS];
293         uint32_t size ; /* number of Rx descs*/
294         uint32_t actual_size;
295         uint32_t size_mask;
296         uint16_t stride;
297         uint16_t log_stride;
298         uint16_t cqn;   /* index of port CQ associated with this ring */
299         uint32_t prod;
300         uint32_t cons;
301         uint32_t buf_size;
302         uint8_t  fcs_del;
303         void *buf;
304         void *rx_info;
305         unsigned long bytes;
306         unsigned long packets;
307 #ifdef CONFIG_NET_RX_BUSY_POLL
308         unsigned long yields;
309         unsigned long misses;
310         unsigned long cleaned;
311 #endif
312         unsigned long csum_ok;
313         unsigned long csum_none;
314         unsigned long csum_complete;
315         int hwtstamp_rx_filter;
316         cpumask_var_t affinity_mask;
317 };
318
319 struct mlx4_en_cq {
320         struct mlx4_cq          mcq;
321         struct mlx4_hwq_resources wqres;
322         int                     ring;
323         struct ether      *dev;
324         struct napi_struct      napi;
325         int size;
326         int buf_size;
327         unsigned vector;
328         enum cq_type is_tx;
329         uint16_t moder_time;
330         uint16_t moder_cnt;
331         struct mlx4_cqe *buf;
332 #define MLX4_EN_OPCODE_ERROR    0x1e
333
334 #ifdef CONFIG_NET_RX_BUSY_POLL
335         unsigned int state;
336 #define MLX4_EN_CQ_STATE_IDLE        0
337 #define MLX4_EN_CQ_STATE_NAPI     1    /* NAPI owns this CQ */
338 #define MLX4_EN_CQ_STATE_POLL     2    /* poll owns this CQ */
339 #define MLX4_CQ_LOCKED (MLX4_EN_CQ_STATE_NAPI | MLX4_EN_CQ_STATE_POLL)
340 #define MLX4_EN_CQ_STATE_NAPI_YIELD  4    /* NAPI yielded this CQ */
341 #define MLX4_EN_CQ_STATE_POLL_YIELD  8    /* poll yielded this CQ */
342 #define CQ_YIELD (MLX4_EN_CQ_STATE_NAPI_YIELD | MLX4_EN_CQ_STATE_POLL_YIELD)
343 #define CQ_USER_PEND (MLX4_EN_CQ_STATE_POLL | MLX4_EN_CQ_STATE_POLL_YIELD)
344         spinlock_t poll_lock; /* protects from LLS/napi conflicts */
345 #endif  /* CONFIG_NET_RX_BUSY_POLL */
346         struct irq_desc *irq_desc;
347 };
348
349 struct mlx4_en_port_profile {
350         uint32_t flags;
351         uint32_t tx_ring_num;
352         uint32_t rx_ring_num;
353         uint32_t tx_ring_size;
354         uint32_t rx_ring_size;
355         uint8_t rx_pause;
356         uint8_t rx_ppp;
357         uint8_t tx_pause;
358         uint8_t tx_ppp;
359         int rss_rings;
360         int inline_thold;
361 };
362
363 struct mlx4_en_profile {
364         int udp_rss;
365         uint8_t rss_mask;
366         uint32_t active_ports;
367         uint32_t small_pkt_int;
368         uint8_t no_reset;
369         uint8_t num_tx_rings_p_up;
370         struct mlx4_en_port_profile prof[MLX4_MAX_PORTS + 1];
371 };
372
373 struct mlx4_en_dev {
374         struct mlx4_dev         *dev;
375         struct pci_device               *pdev;
376         qlock_t         state_lock;
377         struct ether       *pndev[MLX4_MAX_PORTS + 1];
378         struct ether       *upper[MLX4_MAX_PORTS + 1];
379         uint32_t                     port_cnt;
380         bool                    device_up;
381         struct mlx4_en_profile  profile;
382         uint32_t                        LSO_support;
383         struct workqueue_struct *workqueue;
384         struct device           *dma_device;
385         void __iomem            *uar_map;
386         struct mlx4_uar         priv_uar;
387         struct mlx4_mr          mr;
388         uint32_t                     priv_pdn;
389         spinlock_t              uar_lock;
390         uint8_t                 mac_removed[MLX4_MAX_PORTS + 1];
391 #if 0 // AKAROS_PORT
392         rwlock_t                clock_lock;
393         uint32_t                        nominal_c_mult;
394         struct cyclecounter     cycles;
395         struct timecounter      clock;
396         unsigned long           last_overflow_check;
397         unsigned long           overflow_period;
398         struct ptp_clock        *ptp_clock;
399         struct ptp_clock_info   ptp_clock_info;
400         struct notifier_block   nb;
401 #endif
402 };
403
404
405 struct mlx4_en_rss_map {
406         int base_qpn;
407         struct mlx4_qp qps[MAX_RX_RINGS];
408         enum mlx4_qp_state state[MAX_RX_RINGS];
409         struct mlx4_qp indir_qp;
410         enum mlx4_qp_state indir_state;
411 };
412
413 enum mlx4_en_port_flag {
414         MLX4_EN_PORT_ANC = 1<<0, /* Auto-negotiation complete */
415         MLX4_EN_PORT_ANE = 1<<1, /* Auto-negotiation enabled */
416 };
417
418 struct mlx4_en_port_state {
419         int link_state;
420         int link_speed;
421         int transceiver;
422         uint32_t flags;
423 };
424
425 enum mlx4_en_mclist_act {
426         MCLIST_NONE,
427         MCLIST_REM,
428         MCLIST_ADD,
429 };
430
431 struct mlx4_en_mc_list {
432         struct list_head        list;
433         enum mlx4_en_mclist_act action;
434         uint8_t                 addr[Eaddrlen];
435         uint64_t                        reg_id;
436         uint64_t                        tunnel_reg_id;
437 };
438
439 struct mlx4_en_frag_info {
440         uint16_t frag_size;
441         uint16_t frag_prefix_size;
442         uint16_t frag_stride;
443 };
444
445 #ifdef CONFIG_MLX4_EN_DCB
446 /* Minimal TC BW - setting to 0 will block traffic */
447 #define MLX4_EN_BW_MIN 1
448 #define MLX4_EN_BW_MAX 100 /* Utilize 100% of the line */
449
450 #define MLX4_EN_TC_ETS 7
451
452 #endif
453
454 #if 0 // AKAROS_PORT
455 struct ethtool_flow_id {
456         struct list_head list;
457         struct ethtool_rx_flow_spec flow_spec;
458         uint64_t id;
459 };
460 #endif
461
462 enum {
463         MLX4_EN_FLAG_PROMISC            = (1 << 0),
464         MLX4_EN_FLAG_MC_PROMISC         = (1 << 1),
465         /* whether we need to enable hardware loopback by putting dmac
466          * in Tx WQE
467          */
468         MLX4_EN_FLAG_ENABLE_HW_LOOPBACK = (1 << 2),
469         /* whether we need to drop packets that hardware loopback-ed */
470         MLX4_EN_FLAG_RX_FILTER_NEEDED   = (1 << 3),
471         MLX4_EN_FLAG_FORCE_PROMISC      = (1 << 4),
472         MLX4_EN_FLAG_RX_CSUM_NON_TCP_UDP        = (1 << 5),
473 };
474
475 #define PORT_BEACON_MAX_LIMIT (65535)
476 #define MLX4_EN_MAC_HASH_SIZE (1 << BITS_PER_BYTE)
477 #define MLX4_EN_MAC_HASH_IDX 5
478
479 struct mlx4_en_stats_bitmap {
480         DECLARE_BITMAP(bitmap, NUM_ALL_STATS);
481         qlock_t mutex; /* for mutual access to stats bitmap */
482 };
483
484 struct mlx4_en_priv {
485         struct mlx4_en_dev *mdev;
486         struct mlx4_en_port_profile *prof;
487         struct ether *dev;
488         unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
489         struct net_device_stats stats;
490         struct net_device_stats ret_stats;
491         struct mlx4_en_port_state port_state;
492         spinlock_t stats_lock;
493 #if 0 // AKAROS_PORT
494         struct ethtool_flow_id ethtool_rules[MAX_NUM_OF_FS_RULES];
495         /* To allow rules removal while port is going down */
496         struct list_head ethtool_list;
497 #endif
498
499         unsigned long last_moder_packets[MAX_RX_RINGS];
500         unsigned long last_moder_tx_packets;
501         unsigned long last_moder_bytes[MAX_RX_RINGS];
502         unsigned long last_moder_jiffies;
503         int last_moder_time[MAX_RX_RINGS];
504         uint16_t rx_usecs;
505         uint16_t rx_frames;
506         uint16_t tx_usecs;
507         uint16_t tx_frames;
508         uint32_t pkt_rate_low;
509         uint16_t rx_usecs_low;
510         uint32_t pkt_rate_high;
511         uint16_t rx_usecs_high;
512         uint16_t sample_interval;
513         uint16_t adaptive_rx_coal;
514         uint32_t msg_enable;
515         uint32_t loopback_ok;
516         uint32_t validate_loopback;
517
518         struct mlx4_hwq_resources res;
519         int link_state;
520         int last_link_state;
521         bool port_up;
522         int port;
523         int registered;
524         int allocated;
525         int stride;
526         unsigned char current_mac[Eaddrlen + 2];
527         int mac_index;
528         unsigned max_mtu;
529         int base_qpn;
530         int cqe_factor;
531         int cqe_size;
532
533         struct mlx4_en_rss_map rss_map;
534         __be32 ctrl_flags;
535         uint32_t flags;
536         uint8_t num_tx_rings_p_up;
537         uint32_t tx_work_limit;
538         uint32_t tx_ring_num;
539         uint32_t rx_ring_num;
540         uint32_t rx_skb_size;
541         struct mlx4_en_frag_info frag_info[MLX4_EN_MAX_RX_FRAGS];
542         uint16_t num_frags;
543         uint16_t log_rx_info;
544
545         struct mlx4_en_tx_ring **tx_ring;
546         struct mlx4_en_rx_ring *rx_ring[MAX_RX_RINGS];
547         struct mlx4_en_cq **tx_cq;
548         struct mlx4_en_cq *rx_cq[MAX_RX_RINGS];
549         struct mlx4_qp drop_qp;
550         struct work_struct rx_mode_task;
551         struct work_struct watchdog_task;
552         struct work_struct linkstate_task;
553         struct delayed_work stats_task;
554         struct delayed_work service_task;
555 #ifdef CONFIG_MLX4_EN_VXLAN
556         struct work_struct vxlan_add_task;
557         struct work_struct vxlan_del_task;
558 #endif
559         struct mlx4_en_perf_stats pstats;
560         struct mlx4_en_pkt_stats pkstats;
561         struct mlx4_en_flow_stats_rx rx_priority_flowstats[MLX4_NUM_PRIORITIES];
562         struct mlx4_en_flow_stats_tx tx_priority_flowstats[MLX4_NUM_PRIORITIES];
563         struct mlx4_en_flow_stats_rx rx_flowstats;
564         struct mlx4_en_flow_stats_tx tx_flowstats;
565         struct mlx4_en_port_stats port_stats;
566         struct mlx4_en_stats_bitmap stats_bitmap;
567         struct list_head mc_list;
568         struct list_head curr_list;
569         uint64_t broadcast_id;
570         struct mlx4_en_stat_out_mbox hw_stats;
571         int vids[128];
572         bool wol;
573 #if 0 // AKAROS_PORT
574         struct device *ddev;
575 #endif
576         int base_tx_qpn;
577         struct hlist_head mac_hash[MLX4_EN_MAC_HASH_SIZE];
578         struct hwtstamp_config hwtstamp_config;
579
580 #ifdef CONFIG_MLX4_EN_DCB
581         struct ieee_ets ets;
582         uint16_t maxrate[IEEE_8021QAZ_MAX_TCS];
583         enum dcbnl_cndd_states cndd_state[IEEE_8021QAZ_MAX_TCS];
584 #endif
585 #ifdef CONFIG_RFS_ACCEL
586         spinlock_t filters_lock;
587         int last_filter_id;
588         struct list_head filters;
589         struct hlist_head filter_hash[1 << MLX4_EN_FILTER_HASH_SHIFT];
590 #endif
591         uint64_t tunnel_reg_id;
592         __be16 vxlan_port;
593
594         uint32_t pflags;
595         uint8_t rss_key[MLX4_EN_RSS_KEY_SIZE];
596         uint8_t rss_hash_fn;
597 };
598
599 enum mlx4_en_wol {
600         MLX4_EN_WOL_MAGIC = (1ULL << 61),
601         MLX4_EN_WOL_ENABLED = (1ULL << 62),
602 };
603
604 struct mlx4_mac_entry {
605         struct hlist_node hlist;
606         unsigned char mac[Eaddrlen + 2];
607         uint64_t reg_id;
608 #if 0 // AKAROS_PORT
609         struct rcu_head rcu;
610 #endif
611 };
612
613 static inline struct mlx4_cqe *mlx4_en_get_cqe(void *buf, int idx, int cqe_sz)
614 {
615         return buf + idx * cqe_sz;
616 }
617
618 #ifdef CONFIG_NET_RX_BUSY_POLL
619 static inline void mlx4_en_cq_init_lock(struct mlx4_en_cq *cq)
620 {
621         spinlock_init_irqsave(&cq->poll_lock);
622         cq->state = MLX4_EN_CQ_STATE_IDLE;
623 }
624
625 /* called from the device poll rutine to get ownership of a cq */
626 static inline bool mlx4_en_cq_lock_napi(struct mlx4_en_cq *cq)
627 {
628         int rc = true;
629         spin_lock(&cq->poll_lock);
630         if (cq->state & MLX4_CQ_LOCKED) {
631                 warn_on(cq->state & MLX4_EN_CQ_STATE_NAPI);
632                 cq->state |= MLX4_EN_CQ_STATE_NAPI_YIELD;
633                 rc = false;
634         } else
635                 /* we don't care if someone yielded */
636                 cq->state = MLX4_EN_CQ_STATE_NAPI;
637         spin_unlock(&cq->poll_lock);
638         return rc;
639 }
640
641 /* returns true is someone tried to get the cq while napi had it */
642 static inline bool mlx4_en_cq_unlock_napi(struct mlx4_en_cq *cq)
643 {
644         int rc = false;
645         spin_lock(&cq->poll_lock);
646         warn_on(cq->state & (MLX4_EN_CQ_STATE_POLL |
647                                MLX4_EN_CQ_STATE_NAPI_YIELD));
648
649         if (cq->state & MLX4_EN_CQ_STATE_POLL_YIELD)
650                 rc = true;
651         cq->state = MLX4_EN_CQ_STATE_IDLE;
652         spin_unlock(&cq->poll_lock);
653         return rc;
654 }
655
656 /* called from mlx4_en_low_latency_poll() */
657 static inline bool mlx4_en_cq_lock_poll(struct mlx4_en_cq *cq)
658 {
659         int rc = true;
660         spin_lock(&cq->poll_lock);
661         if ((cq->state & MLX4_CQ_LOCKED)) {
662                 struct ether *dev = cq->dev;
663                 struct mlx4_en_priv *priv = netdev_priv(dev);
664                 struct mlx4_en_rx_ring *rx_ring = priv->rx_ring[cq->ring];
665
666                 cq->state |= MLX4_EN_CQ_STATE_POLL_YIELD;
667                 rc = false;
668                 rx_ring->yields++;
669         } else
670                 /* preserve yield marks */
671                 cq->state |= MLX4_EN_CQ_STATE_POLL;
672         spin_unlock(&cq->poll_lock);
673         return rc;
674 }
675
676 /* returns true if someone tried to get the cq while it was locked */
677 static inline bool mlx4_en_cq_unlock_poll(struct mlx4_en_cq *cq)
678 {
679         int rc = false;
680         spin_lock(&cq->poll_lock);
681         warn_on(cq->state & (MLX4_EN_CQ_STATE_NAPI));
682
683         if (cq->state & MLX4_EN_CQ_STATE_POLL_YIELD)
684                 rc = true;
685         cq->state = MLX4_EN_CQ_STATE_IDLE;
686         spin_unlock(&cq->poll_lock);
687         return rc;
688 }
689
690 /* true if a socket is polling, even if it did not get the lock */
691 static inline bool mlx4_en_cq_busy_polling(struct mlx4_en_cq *cq)
692 {
693         warn_on(!(cq->state & MLX4_CQ_LOCKED));
694         return cq->state & CQ_USER_PEND;
695 }
696 #else
697 static inline void mlx4_en_cq_init_lock(struct mlx4_en_cq *cq)
698 {
699 }
700
701 static inline bool mlx4_en_cq_lock_napi(struct mlx4_en_cq *cq)
702 {
703         return true;
704 }
705
706 static inline bool mlx4_en_cq_unlock_napi(struct mlx4_en_cq *cq)
707 {
708         return false;
709 }
710
711 static inline bool mlx4_en_cq_lock_poll(struct mlx4_en_cq *cq)
712 {
713         return false;
714 }
715
716 static inline bool mlx4_en_cq_unlock_poll(struct mlx4_en_cq *cq)
717 {
718         return false;
719 }
720
721 static inline bool mlx4_en_cq_busy_polling(struct mlx4_en_cq *cq)
722 {
723         return false;
724 }
725 #endif /* CONFIG_NET_RX_BUSY_POLL */
726
727 #define MLX4_EN_WOL_DO_MODIFY (1ULL << 63)
728
729 void mlx4_en_update_loopback_state(struct ether *dev,
730                                    netdev_features_t features);
731
732 void mlx4_en_destroy_netdev(struct ether *dev);
733 int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
734                         struct ether *dev,
735                         struct mlx4_en_port_profile *prof);
736
737 int mlx4_en_start_port(struct ether *dev);
738 void mlx4_en_stop_port(struct ether *dev, int detach);
739
740 void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
741                               struct mlx4_en_stats_bitmap *stats_bitmap,
742                               uint8_t rx_ppp, uint8_t rx_pause,
743                               uint8_t tx_ppp, uint8_t tx_pause);
744
745 void mlx4_en_free_resources(struct mlx4_en_priv *priv);
746 int mlx4_en_alloc_resources(struct mlx4_en_priv *priv);
747
748 int mlx4_en_create_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq **pcq,
749                       int entries, int ring, enum cq_type mode, int node);
750 void mlx4_en_destroy_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq **pcq);
751 int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq,
752                         int cq_idx);
753 void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
754 int mlx4_en_set_cq_moder(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
755 int mlx4_en_arm_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
756
757 void mlx4_en_tx_irq(struct mlx4_cq *mcq);
758 uint16_t mlx4_en_select_queue(struct ether *dev, struct sk_buff *skb,
759                               void *accel_priv,
760                               select_queue_fallback_t fallback);
761 netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct ether *dev);
762
763 int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
764                            struct mlx4_en_tx_ring **pring,
765                            uint32_t size, uint16_t stride,
766                            int node, int queue_index);
767 void mlx4_en_destroy_tx_ring(struct mlx4_en_priv *priv,
768                              struct mlx4_en_tx_ring **pring);
769 int mlx4_en_activate_tx_ring(struct mlx4_en_priv *priv,
770                              struct mlx4_en_tx_ring *ring,
771                              int cq, int user_prio);
772 void mlx4_en_deactivate_tx_ring(struct mlx4_en_priv *priv,
773                                 struct mlx4_en_tx_ring *ring);
774 void mlx4_en_set_num_rx_rings(struct mlx4_en_dev *mdev);
775 void mlx4_en_recover_from_oom(struct mlx4_en_priv *priv);
776 int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
777                            struct mlx4_en_rx_ring **pring,
778                            uint32_t size, uint16_t stride, int node);
779 void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
780                              struct mlx4_en_rx_ring **pring,
781                              uint32_t size, uint16_t stride);
782 int mlx4_en_activate_rx_rings(struct mlx4_en_priv *priv);
783 void mlx4_en_deactivate_rx_ring(struct mlx4_en_priv *priv,
784                                 struct mlx4_en_rx_ring *ring);
785 int mlx4_en_process_rx_cq(struct ether *dev,
786                           struct mlx4_en_cq *cq,
787                           int budget);
788 void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
789                 int is_tx, int rss, int qpn, int cqn, int user_prio,
790                 struct mlx4_qp_context *context);
791 void mlx4_en_sqp_event(struct mlx4_qp *qp, enum mlx4_event event);
792 int mlx4_en_map_buffer(struct mlx4_buf *buf);
793 void mlx4_en_unmap_buffer(struct mlx4_buf *buf);
794
795 void mlx4_en_calc_rx_buf(struct ether *dev);
796 int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv);
797 void mlx4_en_release_rss_steer(struct mlx4_en_priv *priv);
798 int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv);
799 void mlx4_en_destroy_drop_qp(struct mlx4_en_priv *priv);
800 int mlx4_en_free_tx_buf(struct ether *dev, struct mlx4_en_tx_ring *ring);
801 void mlx4_en_rx_irq(struct mlx4_cq *mcq);
802
803 int mlx4_SET_MCAST_FLTR(struct mlx4_dev *dev, uint8_t port, uint64_t mac,
804                         uint64_t clear, uint8_t mode);
805 int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv);
806
807 int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, uint8_t port,
808                            uint8_t reset);
809 int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, uint8_t port);
810
811 #ifdef CONFIG_MLX4_EN_DCB
812 extern const struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops;
813 extern const struct dcbnl_rtnl_ops mlx4_en_dcbnl_pfc_ops;
814 #endif
815
816 int mlx4_en_setup_tc(struct ether *dev, uint8_t up);
817
818 #ifdef CONFIG_RFS_ACCEL
819 void mlx4_en_cleanup_filters(struct mlx4_en_priv *priv);
820 #endif
821
822 #define MLX4_EN_NUM_SELF_TEST   5
823 void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
824                          uint64_t *buf);
825 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev);
826
827 #define DEV_FEATURE_CHANGED(dev, new_features, feature) \
828         ((dev->feat & feature) ^ (new_features & feature))
829
830 int mlx4_en_reset_config(struct ether *dev,
831                          struct hwtstamp_config ts_config,
832                          netdev_features_t new_features);
833 void mlx4_en_update_pfc_stats_bitmap(struct mlx4_dev *dev,
834                                      struct mlx4_en_stats_bitmap *stats_bitmap,
835                                      uint8_t rx_ppp, uint8_t rx_pause,
836                                      uint8_t tx_ppp, uint8_t tx_pause);
837 int mlx4_en_netdev_event(struct notifier_block *this,
838                          unsigned long event, void *ptr);
839
840 /*
841  * Functions for time stamping
842  */
843 uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe);
844 void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
845                             struct skb_shared_hwtstamps *hwts,
846                             uint64_t timestamp);
847 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev);
848 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev);
849
850 #if 0 // AKAROS_PORT
851 /* Globals
852  */
853 extern const struct ethtool_ops mlx4_en_ethtool_ops;
854 #endif
855
856
857 /*
858  * printk / logging functions
859  */
860
861 __printf(3, 4)
862 void en_print(const char *level, const struct mlx4_en_priv *priv,
863               const char *format, ...);
864
865 #if 0 // AKAROS_PORT
866 #define en_dbg(mlevel, priv, format, ...)                               \
867 do {                                                                    \
868         if (NETIF_MSG_##mlevel & (priv)->msg_enable)                    \
869                 en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
870 } while (0)
871 #else
872 #define en_dbg(mlevel, priv, format, ...)                               \
873 do {                                                                    \
874                 en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
875 } while (0)
876 #endif
877 #define en_warn(priv, format, ...)                                      \
878         en_print(KERN_WARNING, priv, format, ##__VA_ARGS__)
879 #define en_err(priv, format, ...)                                       \
880         en_print(KERN_ERR, priv, format, ##__VA_ARGS__)
881 #define en_info(priv, format, ...)                                      \
882         en_print(KERN_INFO, priv, format, ##__VA_ARGS__)
883
884 #define mlx4_err(mdev, format, ...)                                     \
885         pr_err(DRV_NAME " %s: " format,                                 \
886                dev_name(&(mdev)->pdev->dev), ##__VA_ARGS__)
887 #define mlx4_info(mdev, format, ...)                                    \
888         pr_info(DRV_NAME " %s: " format,                                \
889                 dev_name(&(mdev)->pdev->dev), ##__VA_ARGS__)
890 #define mlx4_warn(mdev, format, ...)                                    \
891         pr_warn(DRV_NAME " %s: " format,                                \
892                 dev_name(&(mdev)->pdev->dev), ##__VA_ARGS__)