7ab2e8160db974e8f6f771ec92bc16869fef09f8
[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 refd_pages       *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         struct poke_tracker     poker;
261
262         /* Following part should be mostly read */
263         cpumask_t               affinity_mask;
264         struct mlx4_qp          qp;
265         struct mlx4_hwq_resources wqres;
266         uint32_t                        size; /* number of TXBBs */
267         uint32_t                        size_mask;
268         uint16_t                        stride;
269         uint16_t                        cqn;    /* index of port CQ associated with this ring */
270         uint32_t                        buf_size;
271         __be32                  doorbell_qpn;
272         __be32                  mr_key;
273         void                    *buf;
274         struct mlx4_en_tx_info  *tx_info;
275         uint8_t                 *bounce_buf;
276         struct mlx4_qp_context  context;
277         int                     qpn;
278         enum mlx4_qp_state      qp_state;
279         uint8_t                 queue_index;
280         bool                    bf_enabled;
281         bool                    bf_alloced;
282         struct netdev_queue     *tx_queue;
283         int                     hwtstamp_tx_type;
284 } ____cacheline_aligned_in_smp;
285
286 struct mlx4_poke_args {
287         struct ether            *edev;
288         struct mlx4_en_priv     *priv;
289         struct mlx4_en_tx_ring  *ring;
290 };
291
292 void __mlx4_xmit_poke(void *args);
293
294 struct mlx4_en_rx_desc {
295         /* actual number of entries depends on rx ring stride */
296         struct mlx4_wqe_data_seg data[0];
297 };
298
299 struct mlx4_en_rx_ring {
300         struct mlx4_hwq_resources wqres;
301         struct mlx4_en_rx_alloc page_alloc[MLX4_EN_MAX_RX_FRAGS];
302         uint32_t size ; /* number of Rx descs*/
303         uint32_t actual_size;
304         uint32_t size_mask;
305         uint16_t stride;
306         uint16_t log_stride;
307         uint16_t cqn;   /* index of port CQ associated with this ring */
308         uint32_t prod;
309         uint32_t cons;
310         uint32_t buf_size;
311         uint8_t  fcs_del;
312         void *buf;
313         void *rx_info;
314         unsigned long bytes;
315         unsigned long packets;
316 #ifdef CONFIG_NET_RX_BUSY_POLL
317         unsigned long yields;
318         unsigned long misses;
319         unsigned long cleaned;
320 #endif
321         unsigned long csum_ok;
322         unsigned long csum_none;
323         unsigned long csum_complete;
324         int hwtstamp_rx_filter;
325         cpumask_var_t affinity_mask;
326 };
327
328 struct mlx4_en_cq {
329         struct mlx4_cq          mcq;
330         struct mlx4_hwq_resources wqres;
331         int                     ring;
332         struct ether      *dev;
333         struct napi_struct      napi;
334         int size;
335         int buf_size;
336         unsigned vector;
337         enum cq_type is_tx;
338         uint16_t moder_time;
339         uint16_t moder_cnt;
340         struct mlx4_cqe *buf;
341 #define MLX4_EN_OPCODE_ERROR    0x1e
342
343 #ifdef CONFIG_NET_RX_BUSY_POLL
344         unsigned int state;
345 #define MLX4_EN_CQ_STATE_IDLE        0
346 #define MLX4_EN_CQ_STATE_NAPI     1    /* NAPI owns this CQ */
347 #define MLX4_EN_CQ_STATE_POLL     2    /* poll owns this CQ */
348 #define MLX4_CQ_LOCKED (MLX4_EN_CQ_STATE_NAPI | MLX4_EN_CQ_STATE_POLL)
349 #define MLX4_EN_CQ_STATE_NAPI_YIELD  4    /* NAPI yielded this CQ */
350 #define MLX4_EN_CQ_STATE_POLL_YIELD  8    /* poll yielded this CQ */
351 #define CQ_YIELD (MLX4_EN_CQ_STATE_NAPI_YIELD | MLX4_EN_CQ_STATE_POLL_YIELD)
352 #define CQ_USER_PEND (MLX4_EN_CQ_STATE_POLL | MLX4_EN_CQ_STATE_POLL_YIELD)
353         spinlock_t poll_lock; /* protects from LLS/napi conflicts */
354 #endif  /* CONFIG_NET_RX_BUSY_POLL */
355         struct irq_desc *irq_desc;
356 };
357
358 struct mlx4_en_port_profile {
359         uint32_t flags;
360         uint32_t tx_ring_num;
361         uint32_t rx_ring_num;
362         uint32_t tx_ring_size;
363         uint32_t rx_ring_size;
364         uint8_t rx_pause;
365         uint8_t rx_ppp;
366         uint8_t tx_pause;
367         uint8_t tx_ppp;
368         int rss_rings;
369         int inline_thold;
370 };
371
372 struct mlx4_en_profile {
373         int udp_rss;
374         uint8_t rss_mask;
375         uint32_t active_ports;
376         uint32_t small_pkt_int;
377         uint8_t no_reset;
378         uint8_t num_tx_rings_p_up;
379         struct mlx4_en_port_profile prof[MLX4_MAX_PORTS + 1];
380 };
381
382 struct mlx4_en_dev {
383         struct mlx4_dev         *dev;
384         struct pci_device               *pdev;
385         qlock_t         state_lock;
386         struct ether       *pndev[MLX4_MAX_PORTS + 1];
387         struct ether       *upper[MLX4_MAX_PORTS + 1];
388         uint32_t                     port_cnt;
389         bool                    device_up;
390         struct mlx4_en_profile  profile;
391         uint32_t                        LSO_support;
392         struct workqueue_struct *workqueue;
393         struct device           *dma_device;
394         void __iomem            *uar_map;
395         struct mlx4_uar         priv_uar;
396         struct mlx4_mr          mr;
397         uint32_t                     priv_pdn;
398         spinlock_t              uar_lock;
399         uint8_t                 mac_removed[MLX4_MAX_PORTS + 1];
400 #if 0 // AKAROS_PORT
401         rwlock_t                clock_lock;
402         uint32_t                        nominal_c_mult;
403         struct cyclecounter     cycles;
404         struct timecounter      clock;
405         unsigned long           last_overflow_check;
406         unsigned long           overflow_period;
407         struct ptp_clock        *ptp_clock;
408         struct ptp_clock_info   ptp_clock_info;
409         struct notifier_block   nb;
410 #endif
411 };
412
413
414 struct mlx4_en_rss_map {
415         int base_qpn;
416         struct mlx4_qp qps[MAX_RX_RINGS];
417         enum mlx4_qp_state state[MAX_RX_RINGS];
418         struct mlx4_qp indir_qp;
419         enum mlx4_qp_state indir_state;
420 };
421
422 enum mlx4_en_port_flag {
423         MLX4_EN_PORT_ANC = 1<<0, /* Auto-negotiation complete */
424         MLX4_EN_PORT_ANE = 1<<1, /* Auto-negotiation enabled */
425 };
426
427 struct mlx4_en_port_state {
428         int link_state;
429         int link_speed;
430         int transceiver;
431         uint32_t flags;
432 };
433
434 enum mlx4_en_mclist_act {
435         MCLIST_NONE,
436         MCLIST_REM,
437         MCLIST_ADD,
438 };
439
440 struct mlx4_en_mc_list {
441         struct list_head        list;
442         enum mlx4_en_mclist_act action;
443         uint8_t                 addr[Eaddrlen];
444         uint64_t                        reg_id;
445         uint64_t                        tunnel_reg_id;
446 };
447
448 struct mlx4_en_frag_info {
449         uint16_t frag_size;
450         uint16_t frag_prefix_size;
451         uint16_t frag_stride;
452 };
453
454 #ifdef CONFIG_MLX4_EN_DCB
455 /* Minimal TC BW - setting to 0 will block traffic */
456 #define MLX4_EN_BW_MIN 1
457 #define MLX4_EN_BW_MAX 100 /* Utilize 100% of the line */
458
459 #define MLX4_EN_TC_ETS 7
460
461 #endif
462
463 #if 0 // AKAROS_PORT
464 struct ethtool_flow_id {
465         struct list_head list;
466         struct ethtool_rx_flow_spec flow_spec;
467         uint64_t id;
468 };
469 #endif
470
471 enum {
472         MLX4_EN_FLAG_PROMISC            = (1 << 0),
473         MLX4_EN_FLAG_MC_PROMISC         = (1 << 1),
474         /* whether we need to enable hardware loopback by putting dmac
475          * in Tx WQE
476          */
477         MLX4_EN_FLAG_ENABLE_HW_LOOPBACK = (1 << 2),
478         /* whether we need to drop packets that hardware loopback-ed */
479         MLX4_EN_FLAG_RX_FILTER_NEEDED   = (1 << 3),
480         MLX4_EN_FLAG_FORCE_PROMISC      = (1 << 4),
481         MLX4_EN_FLAG_RX_CSUM_NON_TCP_UDP        = (1 << 5),
482 };
483
484 #define PORT_BEACON_MAX_LIMIT (65535)
485 #define MLX4_EN_MAC_HASH_SIZE (1 << BITS_PER_BYTE)
486 #define MLX4_EN_MAC_HASH_IDX 5
487
488 struct mlx4_en_stats_bitmap {
489         DECLARE_BITMAP(bitmap, NUM_ALL_STATS);
490         qlock_t mutex; /* for mutual access to stats bitmap */
491 };
492
493 struct mlx4_en_priv {
494         struct mlx4_en_dev *mdev;
495         struct mlx4_en_port_profile *prof;
496         struct ether *dev;
497         unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
498         struct netif_stats stats;
499         struct netif_stats ret_stats;
500         struct mlx4_en_port_state port_state;
501         spinlock_t stats_lock;
502 #if 0 // AKAROS_PORT
503         struct ethtool_flow_id ethtool_rules[MAX_NUM_OF_FS_RULES];
504         /* To allow rules removal while port is going down */
505         struct list_head ethtool_list;
506 #endif
507
508         unsigned long last_moder_packets[MAX_RX_RINGS];
509         unsigned long last_moder_tx_packets;
510         unsigned long last_moder_bytes[MAX_RX_RINGS];
511         unsigned long last_moder_jiffies;
512         int last_moder_time[MAX_RX_RINGS];
513         uint16_t rx_usecs;
514         uint16_t rx_frames;
515         uint16_t tx_usecs;
516         uint16_t tx_frames;
517         uint32_t pkt_rate_low;
518         uint16_t rx_usecs_low;
519         uint32_t pkt_rate_high;
520         uint16_t rx_usecs_high;
521         uint16_t sample_interval;
522         uint16_t adaptive_rx_coal;
523         uint32_t msg_enable;
524         uint32_t loopback_ok;
525         uint32_t validate_loopback;
526
527         struct mlx4_hwq_resources res;
528         int link_state;
529         int last_link_state;
530         bool port_up;
531         int port;
532         int registered;
533         int allocated;
534         int stride;
535         unsigned char current_mac[Eaddrlen + 2];
536         int mac_index;
537         unsigned max_mtu;
538         int base_qpn;
539         int cqe_factor;
540         int cqe_size;
541
542         struct mlx4_en_rss_map rss_map;
543         __be32 ctrl_flags;
544         uint32_t flags;
545         uint8_t num_tx_rings_p_up;
546         uint32_t tx_work_limit;
547         uint32_t tx_ring_num;
548         uint32_t rx_ring_num;
549         uint32_t rx_skb_size;
550         struct mlx4_en_frag_info frag_info[MLX4_EN_MAX_RX_FRAGS];
551         uint16_t num_frags;
552         uint16_t log_rx_info;
553
554         struct mlx4_en_tx_ring **tx_ring;
555         struct mlx4_en_rx_ring *rx_ring[MAX_RX_RINGS];
556         struct mlx4_en_cq **tx_cq;
557         struct mlx4_en_cq *rx_cq[MAX_RX_RINGS];
558         struct mlx4_qp drop_qp;
559         struct work_struct rx_mode_task;
560         struct work_struct watchdog_task;
561         struct work_struct linkstate_task;
562         struct delayed_work stats_task;
563         struct delayed_work service_task;
564 #ifdef CONFIG_MLX4_EN_VXLAN
565         struct work_struct vxlan_add_task;
566         struct work_struct vxlan_del_task;
567 #endif
568         struct mlx4_en_perf_stats pstats;
569         struct mlx4_en_pkt_stats pkstats;
570         struct mlx4_en_flow_stats_rx rx_priority_flowstats[MLX4_NUM_PRIORITIES];
571         struct mlx4_en_flow_stats_tx tx_priority_flowstats[MLX4_NUM_PRIORITIES];
572         struct mlx4_en_flow_stats_rx rx_flowstats;
573         struct mlx4_en_flow_stats_tx tx_flowstats;
574         struct mlx4_en_port_stats port_stats;
575         struct mlx4_en_stats_bitmap stats_bitmap;
576         struct list_head mc_list;
577         struct list_head curr_list;
578         uint64_t broadcast_id;
579         struct mlx4_en_stat_out_mbox hw_stats;
580         int vids[128];
581         bool wol;
582 #if 0 // AKAROS_PORT
583         struct device *ddev;
584 #endif
585         int base_tx_qpn;
586         struct hlist_head mac_hash[MLX4_EN_MAC_HASH_SIZE];
587         struct hwtstamp_config hwtstamp_config;
588
589 #ifdef CONFIG_MLX4_EN_DCB
590         struct ieee_ets ets;
591         uint16_t maxrate[IEEE_8021QAZ_MAX_TCS];
592         enum dcbnl_cndd_states cndd_state[IEEE_8021QAZ_MAX_TCS];
593 #endif
594 #ifdef CONFIG_RFS_ACCEL
595         spinlock_t filters_lock;
596         int last_filter_id;
597         struct list_head filters;
598         struct hlist_head filter_hash[1 << MLX4_EN_FILTER_HASH_SHIFT];
599 #endif
600         uint64_t tunnel_reg_id;
601         __be16 vxlan_port;
602
603         uint32_t pflags;
604         uint8_t rss_key[MLX4_EN_RSS_KEY_SIZE];
605         uint8_t rss_hash_fn;
606 };
607
608 enum mlx4_en_wol {
609         MLX4_EN_WOL_MAGIC = (1ULL << 61),
610         MLX4_EN_WOL_ENABLED = (1ULL << 62),
611 };
612
613 struct mlx4_mac_entry {
614         struct hlist_node hlist;
615         unsigned char mac[Eaddrlen + 2];
616         uint64_t reg_id;
617 #if 0 // AKAROS_PORT
618         struct rcu_head rcu;
619 #endif
620 };
621
622 static inline struct mlx4_cqe *mlx4_en_get_cqe(void *buf, int idx, int cqe_sz)
623 {
624         return buf + idx * cqe_sz;
625 }
626
627 static inline bool mlx4_en_ring_is_full(struct mlx4_en_tx_ring *ring)
628 {
629         /* Check available TXBBs And 2K spare for prefetch */
630         return (int)(ring->prod - ring->cons) >
631                ring->size - HEADROOM - MAX_DESC_TXBBS;
632 }
633
634 #ifdef CONFIG_NET_RX_BUSY_POLL
635 static inline void mlx4_en_cq_init_lock(struct mlx4_en_cq *cq)
636 {
637         spinlock_init(&cq->poll_lock);
638         cq->state = MLX4_EN_CQ_STATE_IDLE;
639 }
640
641 /* called from the device poll rutine to get ownership of a cq */
642 static inline bool mlx4_en_cq_lock_napi(struct mlx4_en_cq *cq)
643 {
644         int rc = true;
645         spin_lock(&cq->poll_lock);
646         if (cq->state & MLX4_CQ_LOCKED) {
647                 warn_on(cq->state & MLX4_EN_CQ_STATE_NAPI);
648                 cq->state |= MLX4_EN_CQ_STATE_NAPI_YIELD;
649                 rc = false;
650         } else
651                 /* we don't care if someone yielded */
652                 cq->state = MLX4_EN_CQ_STATE_NAPI;
653         spin_unlock(&cq->poll_lock);
654         return rc;
655 }
656
657 /* returns true is someone tried to get the cq while napi had it */
658 static inline bool mlx4_en_cq_unlock_napi(struct mlx4_en_cq *cq)
659 {
660         int rc = false;
661         spin_lock(&cq->poll_lock);
662         warn_on(cq->state & (MLX4_EN_CQ_STATE_POLL |
663                                MLX4_EN_CQ_STATE_NAPI_YIELD));
664
665         if (cq->state & MLX4_EN_CQ_STATE_POLL_YIELD)
666                 rc = true;
667         cq->state = MLX4_EN_CQ_STATE_IDLE;
668         spin_unlock(&cq->poll_lock);
669         return rc;
670 }
671
672 /* called from mlx4_en_low_latency_poll() */
673 static inline bool mlx4_en_cq_lock_poll(struct mlx4_en_cq *cq)
674 {
675         int rc = true;
676         spin_lock(&cq->poll_lock);
677         if ((cq->state & MLX4_CQ_LOCKED)) {
678                 struct ether *dev = cq->dev;
679                 struct mlx4_en_priv *priv = netdev_priv(dev);
680                 struct mlx4_en_rx_ring *rx_ring = priv->rx_ring[cq->ring];
681
682                 cq->state |= MLX4_EN_CQ_STATE_POLL_YIELD;
683                 rc = false;
684                 rx_ring->yields++;
685         } else
686                 /* preserve yield marks */
687                 cq->state |= MLX4_EN_CQ_STATE_POLL;
688         spin_unlock(&cq->poll_lock);
689         return rc;
690 }
691
692 /* returns true if someone tried to get the cq while it was locked */
693 static inline bool mlx4_en_cq_unlock_poll(struct mlx4_en_cq *cq)
694 {
695         int rc = false;
696         spin_lock(&cq->poll_lock);
697         warn_on(cq->state & (MLX4_EN_CQ_STATE_NAPI));
698
699         if (cq->state & MLX4_EN_CQ_STATE_POLL_YIELD)
700                 rc = true;
701         cq->state = MLX4_EN_CQ_STATE_IDLE;
702         spin_unlock(&cq->poll_lock);
703         return rc;
704 }
705
706 /* true if a socket is polling, even if it did not get the lock */
707 static inline bool mlx4_en_cq_busy_polling(struct mlx4_en_cq *cq)
708 {
709         warn_on(!(cq->state & MLX4_CQ_LOCKED));
710         return cq->state & CQ_USER_PEND;
711 }
712 #else
713 static inline void mlx4_en_cq_init_lock(struct mlx4_en_cq *cq)
714 {
715 }
716
717 static inline bool mlx4_en_cq_lock_napi(struct mlx4_en_cq *cq)
718 {
719         return true;
720 }
721
722 static inline bool mlx4_en_cq_unlock_napi(struct mlx4_en_cq *cq)
723 {
724         return false;
725 }
726
727 static inline bool mlx4_en_cq_lock_poll(struct mlx4_en_cq *cq)
728 {
729         return false;
730 }
731
732 static inline bool mlx4_en_cq_unlock_poll(struct mlx4_en_cq *cq)
733 {
734         return false;
735 }
736
737 static inline bool mlx4_en_cq_busy_polling(struct mlx4_en_cq *cq)
738 {
739         return false;
740 }
741 #endif /* CONFIG_NET_RX_BUSY_POLL */
742
743 #define MLX4_EN_WOL_DO_MODIFY (1ULL << 63)
744
745 void mlx4_en_update_loopback_state(struct ether *dev,
746                                    netdev_features_t features);
747
748 void mlx4_en_destroy_netdev(struct ether *dev);
749 int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
750                         struct ether *dev,
751                         struct mlx4_en_port_profile *prof);
752
753 int mlx4_en_start_port(struct ether *dev);
754 void mlx4_en_stop_port(struct ether *dev, int detach);
755
756 void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
757                               struct mlx4_en_stats_bitmap *stats_bitmap,
758                               uint8_t rx_ppp, uint8_t rx_pause,
759                               uint8_t tx_ppp, uint8_t tx_pause);
760
761 void mlx4_en_free_resources(struct mlx4_en_priv *priv);
762 int mlx4_en_alloc_resources(struct mlx4_en_priv *priv);
763
764 int mlx4_en_create_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq **pcq,
765                       int entries, int ring, enum cq_type mode, int node);
766 void mlx4_en_destroy_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq **pcq);
767 int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq,
768                         int cq_idx);
769 void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
770 int mlx4_en_set_cq_moder(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
771 int mlx4_en_arm_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq);
772
773 void mlx4_en_tx_irq(struct mlx4_cq *mcq);
774 uint16_t mlx4_en_select_queue(struct ether *dev, struct sk_buff *skb,
775                               void *accel_priv,
776                               select_queue_fallback_t fallback);
777 netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct ether *dev);
778
779 int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
780                            struct mlx4_en_tx_ring **pring,
781                            uint32_t size, uint16_t stride,
782                            int node, int queue_index);
783 void mlx4_en_destroy_tx_ring(struct mlx4_en_priv *priv,
784                              struct mlx4_en_tx_ring **pring);
785 int mlx4_en_activate_tx_ring(struct mlx4_en_priv *priv,
786                              struct mlx4_en_tx_ring *ring,
787                              int cq, int user_prio);
788 void mlx4_en_deactivate_tx_ring(struct mlx4_en_priv *priv,
789                                 struct mlx4_en_tx_ring *ring);
790 void mlx4_en_set_num_rx_rings(struct mlx4_en_dev *mdev);
791 void mlx4_en_recover_from_oom(struct mlx4_en_priv *priv);
792 int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
793                            struct mlx4_en_rx_ring **pring,
794                            uint32_t size, uint16_t stride, int node);
795 void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
796                              struct mlx4_en_rx_ring **pring,
797                              uint32_t size, uint16_t stride);
798 int mlx4_en_activate_rx_rings(struct mlx4_en_priv *priv);
799 void mlx4_en_deactivate_rx_ring(struct mlx4_en_priv *priv,
800                                 struct mlx4_en_rx_ring *ring);
801 int mlx4_en_process_rx_cq(struct ether *dev,
802                           struct mlx4_en_cq *cq,
803                           int budget);
804 void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
805                 int is_tx, int rss, int qpn, int cqn, int user_prio,
806                 struct mlx4_qp_context *context);
807 void mlx4_en_sqp_event(struct mlx4_qp *qp, enum mlx4_event event);
808 int mlx4_en_map_buffer(struct mlx4_buf *buf);
809 void mlx4_en_unmap_buffer(struct mlx4_buf *buf);
810
811 void mlx4_en_calc_rx_buf(struct ether *dev);
812 int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv);
813 void mlx4_en_release_rss_steer(struct mlx4_en_priv *priv);
814 int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv);
815 void mlx4_en_destroy_drop_qp(struct mlx4_en_priv *priv);
816 int mlx4_en_free_tx_buf(struct ether *dev, struct mlx4_en_tx_ring *ring);
817 void mlx4_en_rx_irq(struct mlx4_cq *mcq);
818
819 int mlx4_SET_MCAST_FLTR(struct mlx4_dev *dev, uint8_t port, uint64_t mac,
820                         uint64_t clear, uint8_t mode);
821 int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv);
822
823 int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, uint8_t port,
824                            uint8_t reset);
825 int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, uint8_t port);
826
827 #ifdef CONFIG_MLX4_EN_DCB
828 extern const struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops;
829 extern const struct dcbnl_rtnl_ops mlx4_en_dcbnl_pfc_ops;
830 #endif
831
832 int mlx4_en_setup_tc(struct ether *dev, uint8_t up);
833
834 #ifdef CONFIG_RFS_ACCEL
835 void mlx4_en_cleanup_filters(struct mlx4_en_priv *priv);
836 #endif
837
838 #define MLX4_EN_NUM_SELF_TEST   5
839 void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
840                          uint64_t *buf);
841 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev);
842
843 #define DEV_FEATURE_CHANGED(dev, new_features, feature) \
844         ((dev->feat & feature) ^ (new_features & feature))
845
846 int mlx4_en_reset_config(struct ether *dev,
847                          struct hwtstamp_config ts_config,
848                          netdev_features_t new_features);
849 void mlx4_en_update_pfc_stats_bitmap(struct mlx4_dev *dev,
850                                      struct mlx4_en_stats_bitmap *stats_bitmap,
851                                      uint8_t rx_ppp, uint8_t rx_pause,
852                                      uint8_t tx_ppp, uint8_t tx_pause);
853 int mlx4_en_netdev_event(struct notifier_block *this,
854                          unsigned long event, void *ptr);
855
856 /*
857  * Functions for time stamping
858  */
859 uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe);
860 void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
861                             struct skb_shared_hwtstamps *hwts,
862                             uint64_t timestamp);
863 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev);
864 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev);
865
866 #if 0 // AKAROS_PORT
867 /* Globals
868  */
869 extern const struct ethtool_ops mlx4_en_ethtool_ops;
870 #endif
871
872
873 /*
874  * printk / logging functions
875  */
876
877 __printf(3, 4)
878 void en_print(const char *level, const struct mlx4_en_priv *priv,
879               const char *format, ...);
880
881 #if 0 // AKAROS_PORT
882 #define en_dbg(mlevel, priv, format, ...)                               \
883 do {                                                                    \
884         if (NETIF_MSG_##mlevel & (priv)->msg_enable)                    \
885                 en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
886 } while (0)
887 #else
888 #define en_dbg(mlevel, priv, format, ...)                               \
889 do {                                                                    \
890                 en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
891 } while (0)
892 #endif
893 #define en_warn(priv, format, ...)                                      \
894         en_print(KERN_WARNING, priv, format, ##__VA_ARGS__)
895 #define en_err(priv, format, ...)                                       \
896         en_print(KERN_ERR, priv, format, ##__VA_ARGS__)
897 #define en_info(priv, format, ...)                                      \
898         en_print(KERN_INFO, priv, format, ##__VA_ARGS__)
899
900 #define mlx4_err(mdev, format, ...)                                     \
901         pr_err(DRV_NAME " %s: " format,                                 \
902                dev_name(&(mdev)->pdev->linux_dev), ##__VA_ARGS__)
903 #define mlx4_info(mdev, format, ...)                                    \
904         pr_info(DRV_NAME " %s: " format,                                \
905                 dev_name(&(mdev)->pdev->linux_dev), ##__VA_ARGS__)
906 #define mlx4_warn(mdev, format, ...)                                    \
907         pr_warn(DRV_NAME " %s: " format,                                \
908                 dev_name(&(mdev)->pdev->linux_dev), ##__VA_ARGS__)