Bus space barriers (XCC)
[akaros.git] / kern / drivers / net / bxe / ecore_sp.h
1 /*-
2  * Copyright (c) 2007-2014 QLogic Corporation. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27
28 //__FBSDID("$FreeBSD: head/sys/dev/bxe/ecore_sp.h 271728 2014-09-17 22:49:29Z davidcs $");
29
30 #ifndef ECORE_SP_H
31 #define ECORE_SP_H
32
33 #if _BYTE_ORDER == _LITTLE_ENDIAN
34 #ifndef LITTLE_ENDIAN
35 #define LITTLE_ENDIAN
36 #endif
37 #ifndef __LITTLE_ENDIAN
38 #define __LITTLE_ENDIAN
39 #endif
40 #undef BIG_ENDIAN
41 #undef __BIG_ENDIAN
42 #else /* _BIG_ENDIAN */
43 #ifndef BIG_ENDIAN
44 #define BIG_ENDIAN
45 #endif
46 #ifndef __BIG_ENDIAN
47 #define __BIG_ENDIAN
48 #endif
49 #undef LITTLE_ENDIAN
50 #undef __LITTLE_ENDIAN
51 #endif
52
53 #include "ecore_mfw_req.h"
54 #include "ecore_fw_defs.h"
55 #include "ecore_hsi.h"
56 #include "ecore_reg.h"
57 #include <time.h>       /* udelay */
58
59 struct bxe_adapter;
60 typedef bus_addr_t ecore_dma_addr_t; /* expected to be 64 bit wide */
61 typedef volatile int ecore_atomic_t;
62
63 #ifndef __bool_true_false_are_defined
64 #ifndef __cplusplus
65 #define bool _Bool
66 #if __STDC_VERSION__ < 199901L && __GNUC__ < 3 && !defined(__INTEL_COMPILER)
67 typedef _Bool bool;
68 #endif
69 #endif /* !__cplusplus */
70 #endif /* !__bool_true_false_are_defined$ */
71
72 #define ETH_ALEN 6
73
74 #define ECORE_SWCID_SHIFT   17
75 #define ECORE_SWCID_MASK    ((0x1 << ECORE_SWCID_SHIFT) - 1)
76
77 #define ECORE_MC_HASH_SIZE 8
78 #define ECORE_MC_HASH_OFFSET(sc, i)                                          \
79     (BAR_TSTRORM_INTMEM +                                                    \
80      TSTORM_APPROXIMATE_MATCH_MULTICAST_FILTERING_OFFSET(FUNC_ID(sc)) + i*4)
81
82 #define ECORE_MAX_MULTICAST   64
83 #define ECORE_MAX_EMUL_MULTI  1
84
85 #define IRO sc->iro_array
86
87 #define ECORE_MUTEX_INIT(_mutex)   qlock_init(_mutex)
88 #define ECORE_MUTEX_LOCK(_mutex)   qlock(_mutex)
89 #define ECORE_MUTEX_UNLOCK(_mutex) qunlock(_mutex)
90
91 #define ECORE_SPIN_LOCK_INIT(_spin, _sc) spinlock_init_irqsave(_spin)
92 #define ECORE_SPIN_LOCK_BH(_spin)   spin_lock_irqsave(_spin) /* bh = bottom-half */
93 #define ECORE_SPIN_UNLOCK_BH(_spin) spin_unlock_irqsave(_spin) /* bh = bottom-half */
94
95 #define ECORE_SMP_MB_AFTER_CLEAR_BIT()  mb()
96 #define ECORE_SMP_MB_BEFORE_CLEAR_BIT() mb()
97 #define ECORE_SMP_MB()                  mb()
98 #define ECORE_SMP_RMB()                 rmb()
99 #define ECORE_SMP_WMB()                 wmb()
100 #define ECORE_MMIOWB()                  wmb()
101
102 #define ECORE_SET_BIT_NA(bit, var)   __set_bit(bit, var) /* non-atomic */
103 #define ECORE_CLEAR_BIT_NA(bit, var) __clear_bit(bit, var) /* non-atomic */
104 #define ECORE_TEST_BIT(bit, var)     test_bit(bit, var)
105 #define ECORE_SET_BIT(bit, var)      set_bit(bit, var)
106 #define ECORE_CLEAR_BIT(bit, var)    clear_bit(bit, var)
107 #define ECORE_TEST_AND_CLEAR_BIT(bit, var) test_and_clear_bit(bit, var)
108
109 /* TODO: probably should use atomic_t for real */
110 #define ECORE_ATOMIC_READ(a) atomic_read((atomic_t*)a)
111 #define ECORE_ATOMIC_SET(a, v) atomic_set((atomic_t*)a, v)
112 #define ECORE_ATOMIC_CMPXCHG(a, o, n) atomic_cas_u32((uint32_t*)a, o, n)
113
114 #define ECORE_RET_PENDING(pending_bit, pending) \
115     (ECORE_TEST_BIT(pending_bit, pending) ? ECORE_PENDING : ECORE_SUCCESS)
116
117 #define ECORE_SET_FLAG(value, mask, flag)      \
118     do {                                       \
119         (value) &= ~(mask);                    \
120         (value) |= ((flag) << (mask##_SHIFT)); \
121     } while (0)
122
123 #define ECORE_GET_FLAG(value, mask) \
124     (((value) &= (mask)) >> (mask##_SHIFT))
125
126 #define ECORE_MIGHT_SLEEP()
127
128 #define ECORE_FCOE_CID(sc) ((sc)->fp[FCOE_IDX(sc)].cl_id)
129
130 #define ECORE_MEMCMP(_a, _b, _s) memcmp(_a, _b, _s)
131 #define ECORE_MEMCPY(_a, _b, _s) memcpy(_a, _b, _s)
132 #define ECORE_MEMSET(_a, _c, _s) memset(_a, _c, _s)
133
134 #define ECORE_CPU_TO_LE16(x) cpu_to_le16(x)
135 #define ECORE_CPU_TO_LE32(x) cpu_to_le32(x)
136
137 #define ECORE_WAIT(_s, _t) udelay(1000)
138 #define ECORE_MSLEEP(_t)   udelay((_t) * 1000)
139
140 #define ECORE_LIKELY(x)   (x)
141 #define ECORE_UNLIKELY(x) (x)
142
143 #define ECORE_ZALLOC(_size, _flags, _sc) \
144         kzmalloc(_size, 0) /*M_TEMP, (M_NOWAIT | M_ZERO))*/
145
146 #define ECORE_CALLOC(_len, _size, _flags, _sc) \
147     kzmalloc(_len * _size, 0) /*M_TEMP, (M_NOWAIT | M_ZERO))*/
148
149 #define ECORE_FREE(_s, _buf, _size) kfree(_buf); /*, M_TEMP)*/
150
151 #define SC_ILT(sc)  ((sc)->ilt)
152 #define ILOG2(x)    LOG2_UP(x)
153
154 #define ECORE_ILT_ZALLOC(x, y, size)                                       \
155     do {                                                                   \
156         x = kzmalloc(sizeof(struct bxe_dma), 0);                           \
157         /* malloc args: M_DEVBUF, (M_NOWAIT | M_ZERO));*/                  \
158         if (x) {                                                           \
159             if (bxe_dma_alloc((struct bxe_adapter *)sc,                      \
160                               size, (struct bxe_dma *)x,                   \
161                               "ECORE_ILT") != 0) {                         \
162                 kfree(x);                                                  \
163                 x = NULL;                                                  \
164                 *y = 0;                                                    \
165             } else {                                                       \
166                 *y = ((struct bxe_dma *)x)->paddr;                         \
167             }                                                              \
168         }                                                                  \
169     } while (0)
170
171 #define ECORE_ILT_FREE(x, y, size)                   \
172     do {                                             \
173         if (x) {                                     \
174             bxe_dma_free((struct bxe_adapter *)sc, x); \
175             kfree(x);                                \
176             x = NULL;                                \
177             y = 0;                                   \
178         }                                            \
179     } while (0)
180
181 #define ECORE_IS_VALID_ETHER_ADDR(_mac) TRUE
182
183 #define ECORE_IS_MF_SD_MODE   IS_MF_SD_MODE
184 #define ECORE_IS_MF_SI_MODE   IS_MF_SI_MODE
185 #define ECORE_IS_MF_AFEX_MODE IS_MF_AFEX_MODE
186
187 #define ECORE_SET_CTX_VALIDATION bxe_set_ctx_validation
188
189 #define ECORE_UPDATE_COALESCE_SB_INDEX bxe_update_coalesce_sb_index
190
191 #define ECORE_ALIGN(x, a) ((((x) + (a) - 1) / (a)) * (a))
192
193 #define ECORE_REG_WR_DMAE_LEN REG_WR_DMAE_LEN
194
195 #define ECORE_PATH_ID     SC_PATH
196 #define ECORE_PORT_ID     SC_PORT
197 #define ECORE_FUNC_ID     SC_FUNC
198 #define ECORE_ABS_FUNC_ID SC_ABS_FUNC
199
200 uint32_t calc_crc32(uint8_t *crc32_packet, uint32_t crc32_length,
201                     uint32_t crc32_seed, uint8_t complement);
202
203 static inline uint32_t
204 ECORE_CRC32_LE(uint32_t seed, uint8_t *mac, uint32_t len)
205 {
206     uint32_t packet_buf[2] = {0};
207     memcpy(((uint8_t *)(&packet_buf[0]))+2, &mac[0], 2);
208     memcpy(&packet_buf[1], &mac[2], 4);
209     return byte_swap32(calc_crc32((uint8_t *)packet_buf, 8, seed, 0));
210 }
211
212 #define ecore_sp_post(_sc, _a, _b, _c, _d) \
213     bxe_sp_post(_sc, _a, _b, U64_HI(_c), U64_LO(_c), _d)
214
215 #ifdef ECORE_STOP_ON_ERROR
216
217 #define ECORE_DBG_BREAK_IF(exp)     \
218     do {                            \
219         if (__predict_false(exp)) { \
220             panic("ECORE");         \
221         }                           \
222     } while (0)
223
224 #define ECORE_BUG()                               \
225     do {                                          \
226         panic("BUG (%s:%d)", __FILE__, __LINE__); \
227     } while(0);
228
229 #define ECORE_BUG_ON(exp)                                \
230     do {                                                 \
231         if (__predict_true(exp)) {                       \
232             panic("BUG_ON (%s:%d)", __FILE__, __LINE__); \
233         }                                                \
234     } while (0)
235
236 #else
237
238 extern unsigned long bxe_debug;
239
240 #define BXE_DEBUG_ECORE_DBG_BREAK_IF   0x01
241 #define BXE_DEBUG_ECORE_BUG            0x02
242 #define BXE_DEBUG_ECORE_BUG_ON         0x04
243
244 #define ECORE_DBG_BREAK_IF(exp)     \
245     if (bxe_debug & BXE_DEBUG_ECORE_DBG_BREAK_IF) \
246         printk("%s (%s,%d)\n", __FUNCTION__, __FILE__, __LINE__);
247
248 #define ECORE_BUG(exp)     \
249     if (bxe_debug & BXE_DEBUG_ECORE_BUG) \
250         printk("%s (%s,%d)\n", __FUNCTION__, __FILE__, __LINE__);
251
252 #define ECORE_BUG_ON(exp)     \
253     if (bxe_debug & BXE_DEBUG_ECORE_BUG_ON) \
254         printk("%s (%s,%d)\n", __FUNCTION__, __FILE__, __LINE__);
255
256
257 #endif /* #ifdef ECORE_STOP_ON_ERROR */
258
259 #define ECORE_ERR(str, ...) \
260     BLOGE(sc, "ECORE: " str, ##__VA_ARGS__)
261
262 #define DBG_SP 0x00000004 /* defined in bxe.h */
263
264 #define ECORE_MSG(sc, m, ...) \
265     BLOGD(sc, DBG_SP, "ECORE: " m, ##__VA_ARGS__)
266
267 typedef struct _ecore_list_entry_t
268 {
269     struct _ecore_list_entry_t *next, *prev;
270 } ecore_list_entry_t;
271
272 typedef struct ecore_list_t
273 {
274     ecore_list_entry_t *head, *tail;
275     unsigned long cnt;
276 } ecore_list_t;
277
278 /* initialize the list */
279 #define ECORE_LIST_INIT(_list) \
280     do {                       \
281         (_list)->head = NULL;  \
282         (_list)->tail = NULL;  \
283         (_list)->cnt  = 0;     \
284     } while (0)
285
286 /* return TRUE if the element is the last on the list */
287 #define ECORE_LIST_IS_LAST(_elem, _list) \
288     (_elem == (_list)->tail)
289
290 /* return TRUE if the list is empty */
291 #define ECORE_LIST_IS_EMPTY(_list) \
292     ((_list)->cnt == 0)
293
294 /* return the first element */
295 #define ECORE_LIST_FIRST_ENTRY(_list, cast, _link) \
296     (cast *)((_list)->head)
297
298 /* return the next element */
299 #define ECORE_LIST_NEXT(_elem, _link, cast) \
300     (cast *)((&((_elem)->_link))->next)
301
302 /* push an element on the head of the list */
303 #define ECORE_LIST_PUSH_HEAD(_elem, _list)              \
304     do {                                                \
305         (_elem)->prev = (ecore_list_entry_t *)0;        \
306         (_elem)->next = (_list)->head;                  \
307         if ((_list)->tail == (ecore_list_entry_t *)0) { \
308             (_list)->tail = (_elem);                    \
309         } else {                                        \
310             (_list)->head->prev = (_elem);              \
311         }                                               \
312         (_list)->head = (_elem);                        \
313         (_list)->cnt++;                                 \
314     } while (0)
315
316 /* push an element on the tail of the list */
317 #define ECORE_LIST_PUSH_TAIL(_elem, _list)       \
318     do {                                         \
319         (_elem)->next = (ecore_list_entry_t *)0; \
320         (_elem)->prev = (_list)->tail;           \
321         if ((_list)->tail) {                     \
322             (_list)->tail->next = (_elem);       \
323         } else {                                 \
324             (_list)->head = (_elem);             \
325         }                                        \
326         (_list)->tail = (_elem);                 \
327         (_list)->cnt++;                          \
328     } while (0)
329
330 /* push list1 on the head of list2 and return with list1 as empty */
331 #define ECORE_LIST_SPLICE_INIT(_list1, _list2)     \
332     do {                                           \
333         (_list1)->tail->next = (_list2)->head;     \
334         if ((_list2)->head) {                      \
335             (_list2)->head->prev = (_list1)->tail; \
336         } else {                                   \
337             (_list2)->tail = (_list1)->tail;       \
338         }                                          \
339         (_list2)->head = (_list1)->head;           \
340         (_list2)->cnt += (_list1)->cnt;            \
341         (_list1)->head = NULL;                     \
342         (_list1)->tail = NULL;                     \
343         (_list1)->cnt  = 0;                        \
344     } while (0)
345
346 /* remove an element from the list */
347 #define ECORE_LIST_REMOVE_ENTRY(_elem, _list)                      \
348     do {                                                           \
349         if ((_list)->head == (_elem)) {                            \
350             if ((_list)->head) {                                   \
351                 (_list)->head = (_list)->head->next;               \
352                 if ((_list)->head) {                               \
353                     (_list)->head->prev = (ecore_list_entry_t *)0; \
354                 } else {                                           \
355                     (_list)->tail = (ecore_list_entry_t *)0;       \
356                 }                                                  \
357                 (_list)->cnt--;                                    \
358             }                                                      \
359         } else if ((_list)->tail == (_elem)) {                     \
360             if ((_list)->tail) {                                   \
361                 (_list)->tail = (_list)->tail->prev;               \
362                 if ((_list)->tail) {                               \
363                     (_list)->tail->next = (ecore_list_entry_t *)0; \
364                 } else {                                           \
365                     (_list)->head = (ecore_list_entry_t *)0;       \
366                 }                                                  \
367                 (_list)->cnt--;                                    \
368             }                                                      \
369         } else {                                                   \
370             (_elem)->prev->next = (_elem)->next;                   \
371             (_elem)->next->prev = (_elem)->prev;                   \
372             (_list)->cnt--;                                        \
373         }                                                          \
374     } while (0)
375
376 /* walk the list */
377 #define ECORE_LIST_FOR_EACH_ENTRY(pos, _list, _link, cast) \
378     for (pos = ECORE_LIST_FIRST_ENTRY(_list, cast, _link); \
379          pos;                                              \
380          pos = ECORE_LIST_NEXT(pos, _link, cast))
381
382 /* walk the list (safely) */
383 #define ECORE_LIST_FOR_EACH_ENTRY_SAFE(pos, n, _list, _link, cast) \
384      for (pos = ECORE_LIST_FIRST_ENTRY(_list, cast, _lint),        \
385           n = (pos) ? ECORE_LIST_NEXT(pos, _link, cast) : NULL;    \
386           pos != NULL;                                             \
387           pos = (cast *)n,                                         \
388           n = (pos) ? ECORE_LIST_NEXT(pos, _link, cast) : NULL)
389
390
391 /* Manipulate a bit vector defined as an array of uint64_t */
392
393 /* Number of bits in one sge_mask array element */
394 #define BIT_VEC64_ELEM_SZ     64
395 #define BIT_VEC64_ELEM_SHIFT  6
396 #define BIT_VEC64_ELEM_MASK   ((uint64_t)BIT_VEC64_ELEM_SZ - 1)
397
398 #define __BIT_VEC64_SET_BIT(el, bit)            \
399     do {                                        \
400         el = ((el) | ((uint64_t)0x1 << (bit))); \
401     } while (0)
402
403 #define __BIT_VEC64_CLEAR_BIT(el, bit)             \
404     do {                                           \
405         el = ((el) & (~((uint64_t)0x1 << (bit)))); \
406     } while (0)
407
408 #define BIT_VEC64_SET_BIT(vec64, idx)                           \
409     __BIT_VEC64_SET_BIT((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT], \
410                         (idx) & BIT_VEC64_ELEM_MASK)
411
412 #define BIT_VEC64_CLEAR_BIT(vec64, idx)                           \
413     __BIT_VEC64_CLEAR_BIT((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT], \
414                           (idx) & BIT_VEC64_ELEM_MASK)
415
416 #define BIT_VEC64_TEST_BIT(vec64, idx)          \
417     (((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT] >> \
418       ((idx) & BIT_VEC64_ELEM_MASK)) & 0x1)
419
420 /*
421  * Creates a bitmask of all ones in less significant bits.
422  * idx - index of the most significant bit in the created mask
423  */
424 #define BIT_VEC64_ONES_MASK(idx)                                 \
425     (((uint64_t)0x1 << (((idx) & BIT_VEC64_ELEM_MASK) + 1)) - 1)
426 #define BIT_VEC64_ELEM_ONE_MASK ((uint64_t)(~0))
427
428 /* fill in a MAC address the way the FW likes it */
429 static inline void
430 ecore_set_fw_mac_addr(uint16_t *fw_hi,
431                       uint16_t *fw_mid,
432                       uint16_t *fw_lo,
433                       uint8_t  *mac)
434 {
435     ((uint8_t *)fw_hi)[0]  = mac[1];
436     ((uint8_t *)fw_hi)[1]  = mac[0];
437     ((uint8_t *)fw_mid)[0] = mac[3];
438     ((uint8_t *)fw_mid)[1] = mac[2];
439     ((uint8_t *)fw_lo)[0]  = mac[5];
440     ((uint8_t *)fw_lo)[1]  = mac[4];
441 }
442
443
444 enum ecore_status_t {
445     ECORE_EXISTS  = -6,
446     ECORE_IO      = -5,
447     ECORE_TIMEOUT = -4,
448     ECORE_INVAL   = -3,
449     ECORE_BUSY    = -2,
450     ECORE_NOMEM   = -1,
451     ECORE_SUCCESS = 0,
452     /* PENDING is not an error and should be positive */
453     ECORE_PENDING = 1,
454 };
455
456 enum {
457     SWITCH_UPDATE,
458     AFEX_UPDATE,
459 };
460
461
462
463
464 struct bxe_adapter;
465 struct eth_context;
466
467 /* Bits representing general command's configuration */
468 enum {
469         RAMROD_TX,
470         RAMROD_RX,
471         /* Wait until all pending commands complete */
472         RAMROD_COMP_WAIT,
473         /* Don't send a ramrod, only update a registry */
474         RAMROD_DRV_CLR_ONLY,
475         /* Configure HW according to the current object state */
476         RAMROD_RESTORE,
477          /* Execute the next command now */
478         RAMROD_EXEC,
479         /* Don't add a new command and continue execution of posponed
480          * commands. If not set a new command will be added to the
481          * pending commands list.
482          */
483         RAMROD_CONT,
484         /* If there is another pending ramrod, wait until it finishes and
485          * re-try to submit this one. This flag can be set only in sleepable
486          * context, and should not be set from the context that completes the
487          * ramrods as deadlock will occur.
488          */
489         RAMROD_RETRY,
490 };
491
492 typedef enum {
493         ECORE_OBJ_TYPE_RX,
494         ECORE_OBJ_TYPE_TX,
495         ECORE_OBJ_TYPE_RX_TX,
496 } ecore_obj_type;
497
498 /* Public slow path states */
499 enum {
500         ECORE_FILTER_MAC_PENDING,
501         ECORE_FILTER_VLAN_PENDING,
502         ECORE_FILTER_VLAN_MAC_PENDING,
503         ECORE_FILTER_RX_MODE_PENDING,
504         ECORE_FILTER_RX_MODE_SCHED,
505         ECORE_FILTER_ISCSI_ETH_START_SCHED,
506         ECORE_FILTER_ISCSI_ETH_STOP_SCHED,
507         ECORE_FILTER_FCOE_ETH_START_SCHED,
508         ECORE_FILTER_FCOE_ETH_STOP_SCHED,
509         ECORE_FILTER_BYPASS_RX_MODE_PENDING,
510         ECORE_FILTER_BYPASS_MAC_PENDING,
511         ECORE_FILTER_BYPASS_RSS_CONF_PENDING,
512         ECORE_FILTER_MCAST_PENDING,
513         ECORE_FILTER_MCAST_SCHED,
514         ECORE_FILTER_RSS_CONF_PENDING,
515         ECORE_AFEX_FCOE_Q_UPDATE_PENDING,
516         ECORE_AFEX_PENDING_VIFSET_MCP_ACK
517 };
518
519 struct ecore_raw_obj {
520         uint8_t         func_id;
521
522         /* Queue params */
523         uint8_t         cl_id;
524         uint32_t                cid;
525
526         /* Ramrod data buffer params */
527         void            *rdata;
528         ecore_dma_addr_t        rdata_mapping;
529
530         /* Ramrod state params */
531         int             state;   /* "ramrod is pending" state bit */
532         unsigned long   *pstate; /* pointer to state buffer */
533
534         ecore_obj_type  obj_type;
535
536         int (*wait_comp)(struct bxe_adapter *sc,
537                          struct ecore_raw_obj *o);
538
539         bool (*check_pending)(struct ecore_raw_obj *o);
540         void (*clear_pending)(struct ecore_raw_obj *o);
541         void (*set_pending)(struct ecore_raw_obj *o);
542 };
543
544 /************************* VLAN-MAC commands related parameters ***************/
545 struct ecore_mac_ramrod_data {
546         uint8_t mac[ETH_ALEN];
547         uint8_t is_inner_mac;
548 };
549
550 struct ecore_vlan_ramrod_data {
551         uint16_t vlan;
552 };
553
554 struct ecore_vlan_mac_ramrod_data {
555         uint8_t mac[ETH_ALEN];
556         uint8_t is_inner_mac;
557         uint16_t vlan;
558 };
559
560 union ecore_classification_ramrod_data {
561         struct ecore_mac_ramrod_data mac;
562         struct ecore_vlan_ramrod_data vlan;
563         struct ecore_vlan_mac_ramrod_data vlan_mac;
564 };
565
566 /* VLAN_MAC commands */
567 enum ecore_vlan_mac_cmd {
568         ECORE_VLAN_MAC_ADD,
569         ECORE_VLAN_MAC_DEL,
570         ECORE_VLAN_MAC_MOVE,
571 };
572
573 struct ecore_vlan_mac_data {
574         /* Requested command: ECORE_VLAN_MAC_XX */
575         enum ecore_vlan_mac_cmd cmd;
576         /* used to contain the data related vlan_mac_flags bits from
577          * ramrod parameters.
578          */
579         unsigned long vlan_mac_flags;
580
581         /* Needed for MOVE command */
582         struct ecore_vlan_mac_obj *target_obj;
583
584         union ecore_classification_ramrod_data u;
585 };
586
587 /*************************** Exe Queue obj ************************************/
588 union ecore_exe_queue_cmd_data {
589         struct ecore_vlan_mac_data vlan_mac;
590
591         struct {
592                 /* TODO */
593         } mcast;
594 };
595
596 struct ecore_exeq_elem {
597         ecore_list_entry_t              link;
598
599         /* Length of this element in the exe_chunk. */
600         int                             cmd_len;
601
602         union ecore_exe_queue_cmd_data  cmd_data;
603 };
604
605 union ecore_qable_obj;
606
607 union ecore_exeq_comp_elem {
608         union event_ring_elem *elem;
609 };
610
611 struct ecore_exe_queue_obj;
612
613 typedef int (*exe_q_validate)(struct bxe_adapter *sc,
614                               union ecore_qable_obj *o,
615                               struct ecore_exeq_elem *elem);
616
617 typedef int (*exe_q_remove)(struct bxe_adapter *sc,
618                             union ecore_qable_obj *o,
619                             struct ecore_exeq_elem *elem);
620
621 /* Return positive if entry was optimized, 0 - if not, negative
622  * in case of an error.
623  */
624 typedef int (*exe_q_optimize)(struct bxe_adapter *sc,
625                               union ecore_qable_obj *o,
626                               struct ecore_exeq_elem *elem);
627 typedef int (*exe_q_execute)(struct bxe_adapter *sc,
628                              union ecore_qable_obj *o,
629                              ecore_list_t *exe_chunk,
630                              unsigned long *ramrod_flags);
631 typedef struct ecore_exeq_elem *
632                         (*exe_q_get)(struct ecore_exe_queue_obj *o,
633                                      struct ecore_exeq_elem *elem);
634
635 struct ecore_exe_queue_obj {
636         /* Commands pending for an execution. */
637         ecore_list_t    exe_queue;
638
639         /* Commands pending for an completion. */
640         ecore_list_t    pending_comp;
641
642         spinlock_t              lock;
643
644         /* Maximum length of commands' list for one execution */
645         int                     exe_chunk_len;
646
647         union ecore_qable_obj   *owner;
648
649         /****** Virtual functions ******/
650         /**
651          * Called before commands execution for commands that are really
652          * going to be executed (after 'optimize').
653          *
654          * Must run under exe_queue->lock
655          */
656         exe_q_validate          validate;
657
658         /**
659          * Called before removing pending commands, cleaning allocated
660          * resources (e.g., credits from validate)
661          */
662          exe_q_remove           remove;
663
664         /**
665          * This will try to cancel the current pending commands list
666          * considering the new command.
667          *
668          * Returns the number of optimized commands or a negative error code
669          *
670          * Must run under exe_queue->lock
671          */
672         exe_q_optimize          optimize;
673
674         /**
675          * Run the next commands chunk (owner specific).
676          */
677         exe_q_execute           execute;
678
679         /**
680          * Return the exe_queue element containing the specific command
681          * if any. Otherwise return NULL.
682          */
683         exe_q_get               get;
684 };
685 /***************** Classification verbs: Set/Del MAC/VLAN/VLAN-MAC ************/
686 /*
687  * Element in the VLAN_MAC registry list having all current configured
688  * rules.
689  */
690 struct ecore_vlan_mac_registry_elem {
691         ecore_list_entry_t      link;
692
693         /* Used to store the cam offset used for the mac/vlan/vlan-mac.
694          * Relevant for 57710 and 57711 only. VLANs and MACs share the
695          * same CAM for these chips.
696          */
697         int                     cam_offset;
698
699         /* Needed for DEL and RESTORE flows */
700         unsigned long           vlan_mac_flags;
701
702         union ecore_classification_ramrod_data u;
703 };
704
705 /* Bits representing VLAN_MAC commands specific flags */
706 enum {
707         ECORE_UC_LIST_MAC,
708         ECORE_ETH_MAC,
709         ECORE_ISCSI_ETH_MAC,
710         ECORE_NETQ_ETH_MAC,
711         ECORE_DONT_CONSUME_CAM_CREDIT,
712         ECORE_DONT_CONSUME_CAM_CREDIT_DEST,
713 };
714
715 struct ecore_vlan_mac_ramrod_params {
716         /* Object to run the command from */
717         struct ecore_vlan_mac_obj *vlan_mac_obj;
718
719         /* General command flags: COMP_WAIT, etc. */
720         unsigned long ramrod_flags;
721
722         /* Command specific configuration request */
723         struct ecore_vlan_mac_data user_req;
724 };
725
726 struct ecore_vlan_mac_obj {
727         struct ecore_raw_obj raw;
728
729         /* Bookkeeping list: will prevent the addition of already existing
730          * entries.
731          */
732         ecore_list_t            head;
733         /* Implement a simple reader/writer lock on the head list.
734          * all these fields should only be accessed under the exe_queue lock
735          */
736         uint8_t         head_reader; /* Num. of readers accessing head list */
737         bool            head_exe_request; /* Pending execution request. */
738         unsigned long   saved_ramrod_flags; /* Ramrods of pending execution */
739
740         /* Execution queue interface instance */
741         struct ecore_exe_queue_obj      exe_queue;
742
743         /* MACs credit pool */
744         struct ecore_credit_pool_obj    *macs_pool;
745
746         /* VLANs credit pool */
747         struct ecore_credit_pool_obj    *vlans_pool;
748
749         /* RAMROD command to be used */
750         int                             ramrod_cmd;
751
752         /* copy first n elements onto preallocated buffer
753          *
754          * @param n number of elements to get
755          * @param buf buffer preallocated by caller into which elements
756          *            will be copied. Note elements are 4-byte aligned
757          *            so buffer size must be able to accommodate the
758          *            aligned elements.
759          *
760          * @return number of copied bytes
761          */
762
763         int (*get_n_elements)(struct bxe_adapter *sc,
764                               struct ecore_vlan_mac_obj *o, int n, uint8_t *base,
765                               uint8_t stride, uint8_t size);
766
767         /**
768          * Checks if ADD-ramrod with the given params may be performed.
769          *
770          * @return zero if the element may be added
771          */
772
773         int (*check_add)(struct bxe_adapter *sc,
774                          struct ecore_vlan_mac_obj *o,
775                          union ecore_classification_ramrod_data *data);
776
777         /**
778          * Checks if DEL-ramrod with the given params may be performed.
779          *
780          * @return TRUE if the element may be deleted
781          */
782         struct ecore_vlan_mac_registry_elem *
783                 (*check_del)(struct bxe_adapter *sc,
784                              struct ecore_vlan_mac_obj *o,
785                              union ecore_classification_ramrod_data *data);
786
787         /**
788          * Checks if DEL-ramrod with the given params may be performed.
789          *
790          * @return TRUE if the element may be deleted
791          */
792         bool (*check_move)(struct bxe_adapter *sc,
793                            struct ecore_vlan_mac_obj *src_o,
794                            struct ecore_vlan_mac_obj *dst_o,
795                            union ecore_classification_ramrod_data *data);
796
797         /**
798          *  Update the relevant credit object(s) (consume/return
799          *  correspondingly).
800          */
801         bool (*get_credit)(struct ecore_vlan_mac_obj *o);
802         bool (*put_credit)(struct ecore_vlan_mac_obj *o);
803         bool (*get_cam_offset)(struct ecore_vlan_mac_obj *o, int *offset);
804         bool (*put_cam_offset)(struct ecore_vlan_mac_obj *o, int offset);
805
806         /**
807          * Configures one rule in the ramrod data buffer.
808          */
809         void (*set_one_rule)(struct bxe_adapter *sc,
810                              struct ecore_vlan_mac_obj *o,
811                              struct ecore_exeq_elem *elem, int rule_idx,
812                              int cam_offset);
813
814         /**
815         *  Delete all configured elements having the given
816         *  vlan_mac_flags specification. Assumes no pending for
817         *  execution commands. Will schedule all all currently
818         *  configured MACs/VLANs/VLAN-MACs matching the vlan_mac_flags
819         *  specification for deletion and will use the given
820         *  ramrod_flags for the last DEL operation.
821          *
822          * @param sc
823          * @param o
824          * @param ramrod_flags RAMROD_XX flags
825          *
826          * @return 0 if the last operation has completed successfully
827          *         and there are no more elements left, positive value
828          *         if there are pending for completion commands,
829          *         negative value in case of failure.
830          */
831         int (*delete_all)(struct bxe_adapter *sc,
832                           struct ecore_vlan_mac_obj *o,
833                           unsigned long *vlan_mac_flags,
834                           unsigned long *ramrod_flags);
835
836         /**
837          * Reconfigures the next MAC/VLAN/VLAN-MAC element from the previously
838          * configured elements list.
839          *
840          * @param sc
841          * @param p Command parameters (RAMROD_COMP_WAIT bit in
842          *          ramrod_flags is only taken into an account)
843          * @param ppos a pointer to the cookie that should be given back in the
844          *        next call to make function handle the next element. If
845          *        *ppos is set to NULL it will restart the iterator.
846          *        If returned *ppos == NULL this means that the last
847          *        element has been handled.
848          *
849          * @return int
850          */
851         int (*restore)(struct bxe_adapter *sc,
852                        struct ecore_vlan_mac_ramrod_params *p,
853                        struct ecore_vlan_mac_registry_elem **ppos);
854
855         /**
856          * Should be called on a completion arrival.
857          *
858          * @param sc
859          * @param o
860          * @param cqe Completion element we are handling
861          * @param ramrod_flags if RAMROD_CONT is set the next bulk of
862          *                     pending commands will be executed.
863          *                     RAMROD_DRV_CLR_ONLY and RAMROD_RESTORE
864          *                     may also be set if needed.
865          *
866          * @return 0 if there are neither pending nor waiting for
867          *         completion commands. Positive value if there are
868          *         pending for execution or for completion commands.
869          *         Negative value in case of an error (including an
870          *         error in the cqe).
871          */
872         int (*complete)(struct bxe_adapter *sc, struct ecore_vlan_mac_obj *o,
873                         union event_ring_elem *cqe,
874                         unsigned long *ramrod_flags);
875
876         /**
877          * Wait for completion of all commands. Don't schedule new ones,
878          * just wait. It assumes that the completion code will schedule
879          * for new commands.
880          */
881         int (*wait)(struct bxe_adapter *sc, struct ecore_vlan_mac_obj *o);
882 };
883
884 enum {
885         ECORE_LLH_CAM_ISCSI_ETH_LINE = 0,
886         ECORE_LLH_CAM_ETH_LINE,
887         ECORE_LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE / 2
888 };
889
890 void ecore_set_mac_in_nig(struct bxe_adapter *sc,
891                           bool add, unsigned char *dev_addr, int index);
892
893 /** RX_MODE verbs:DROP_ALL/ACCEPT_ALL/ACCEPT_ALL_MULTI/ACCEPT_ALL_VLAN/NORMAL */
894
895 /* RX_MODE ramrod special flags: set in rx_mode_flags field in
896  * a ecore_rx_mode_ramrod_params.
897  */
898 enum {
899         ECORE_RX_MODE_FCOE_ETH,
900         ECORE_RX_MODE_ISCSI_ETH,
901 };
902
903 enum {
904         ECORE_ACCEPT_UNICAST,
905         ECORE_ACCEPT_MULTICAST,
906         ECORE_ACCEPT_ALL_UNICAST,
907         ECORE_ACCEPT_ALL_MULTICAST,
908         ECORE_ACCEPT_BROADCAST,
909         ECORE_ACCEPT_UNMATCHED,
910         ECORE_ACCEPT_ANY_VLAN
911 };
912
913 struct ecore_rx_mode_ramrod_params {
914         struct ecore_rx_mode_obj *rx_mode_obj;
915         unsigned long *pstate;
916         int state;
917         uint8_t cl_id;
918         uint32_t cid;
919         uint8_t func_id;
920         unsigned long ramrod_flags;
921         unsigned long rx_mode_flags;
922
923         /* rdata is either a pointer to eth_filter_rules_ramrod_data(e2) or to
924          * a tstorm_eth_mac_filter_config (e1x).
925          */
926         void *rdata;
927         ecore_dma_addr_t rdata_mapping;
928
929         /* Rx mode settings */
930         unsigned long rx_accept_flags;
931
932         /* internal switching settings */
933         unsigned long tx_accept_flags;
934 };
935
936 struct ecore_rx_mode_obj {
937         int (*config_rx_mode)(struct bxe_adapter *sc,
938                               struct ecore_rx_mode_ramrod_params *p);
939
940         int (*wait_comp)(struct bxe_adapter *sc,
941                          struct ecore_rx_mode_ramrod_params *p);
942 };
943
944 /********************** Set multicast group ***********************************/
945
946 struct ecore_mcast_list_elem {
947         ecore_list_entry_t link;
948         uint8_t *mac;
949 };
950
951 union ecore_mcast_config_data {
952         uint8_t *mac;
953         uint8_t bin; /* used in a RESTORE flow */
954 };
955
956 struct ecore_mcast_ramrod_params {
957         struct ecore_mcast_obj *mcast_obj;
958
959         /* Relevant options are RAMROD_COMP_WAIT and RAMROD_DRV_CLR_ONLY */
960         unsigned long ramrod_flags;
961
962         ecore_list_t mcast_list; /* list of struct ecore_mcast_list_elem */
963         /** TODO:
964          *      - rename it to macs_num.
965          *      - Add a new command type for handling pending commands
966          *        (remove "zero semantics").
967          *
968          *  Length of mcast_list. If zero and ADD_CONT command - post
969          *  pending commands.
970          */
971         int mcast_list_len;
972 };
973
974 enum ecore_mcast_cmd {
975         ECORE_MCAST_CMD_ADD,
976         ECORE_MCAST_CMD_CONT,
977         ECORE_MCAST_CMD_DEL,
978         ECORE_MCAST_CMD_RESTORE,
979 };
980
981 struct ecore_mcast_obj {
982         struct ecore_raw_obj raw;
983
984         union {
985                 struct {
986                 #define ECORE_MCAST_BINS_NUM    256
987                 #define ECORE_MCAST_VEC_SZ      (ECORE_MCAST_BINS_NUM / 64)
988                         uint64_t vec[ECORE_MCAST_VEC_SZ];
989
990                         /** Number of BINs to clear. Should be updated
991                          *  immediately when a command arrives in order to
992                          *  properly create DEL commands.
993                          */
994                         int num_bins_set;
995                 } aprox_match;
996
997                 struct {
998                         ecore_list_t macs;
999                         int num_macs_set;
1000                 } exact_match;
1001         } registry;
1002
1003         /* Pending commands */
1004         ecore_list_t pending_cmds_head;
1005
1006         /* A state that is set in raw.pstate, when there are pending commands */
1007         int sched_state;
1008
1009         /* Maximal number of mcast MACs configured in one command */
1010         int max_cmd_len;
1011
1012         /* Total number of currently pending MACs to configure: both
1013          * in the pending commands list and in the current command.
1014          */
1015         int total_pending_num;
1016
1017         uint8_t engine_id;
1018
1019         /**
1020          * @param cmd command to execute (ECORE_MCAST_CMD_X, see above)
1021          */
1022         int (*config_mcast)(struct bxe_adapter *sc,
1023                             struct ecore_mcast_ramrod_params *p,
1024                             enum ecore_mcast_cmd cmd);
1025
1026         /**
1027          * Fills the ramrod data during the RESTORE flow.
1028          *
1029          * @param sc
1030          * @param o
1031          * @param start_idx Registry index to start from
1032          * @param rdata_idx Index in the ramrod data to start from
1033          *
1034          * @return -1 if we handled the whole registry or index of the last
1035          *         handled registry element.
1036          */
1037         int (*hdl_restore)(struct bxe_adapter *sc, struct ecore_mcast_obj *o,
1038                            int start_bin, int *rdata_idx);
1039
1040         int (*enqueue_cmd)(struct bxe_adapter *sc, struct ecore_mcast_obj *o,
1041                            struct ecore_mcast_ramrod_params *p,
1042                            enum ecore_mcast_cmd cmd);
1043
1044         void (*set_one_rule)(struct bxe_adapter *sc,
1045                              struct ecore_mcast_obj *o, int idx,
1046                              union ecore_mcast_config_data *cfg_data,
1047                              enum ecore_mcast_cmd cmd);
1048
1049         /** Checks if there are more mcast MACs to be set or a previous
1050          *  command is still pending.
1051          */
1052         bool (*check_pending)(struct ecore_mcast_obj *o);
1053
1054         /**
1055          * Set/Clear/Check SCHEDULED state of the object
1056          */
1057         void (*set_sched)(struct ecore_mcast_obj *o);
1058         void (*clear_sched)(struct ecore_mcast_obj *o);
1059         bool (*check_sched)(struct ecore_mcast_obj *o);
1060
1061         /* Wait until all pending commands complete */
1062         int (*wait_comp)(struct bxe_adapter *sc, struct ecore_mcast_obj *o);
1063
1064         /**
1065          * Handle the internal object counters needed for proper
1066          * commands handling. Checks that the provided parameters are
1067          * feasible.
1068          */
1069         int (*validate)(struct bxe_adapter *sc,
1070                         struct ecore_mcast_ramrod_params *p,
1071                         enum ecore_mcast_cmd cmd);
1072
1073         /**
1074          * Restore the values of internal counters in case of a failure.
1075          */
1076         void (*revert)(struct bxe_adapter *sc,
1077                        struct ecore_mcast_ramrod_params *p,
1078                        int old_num_bins);
1079
1080         int (*get_registry_size)(struct ecore_mcast_obj *o);
1081         void (*set_registry_size)(struct ecore_mcast_obj *o, int n);
1082 };
1083
1084 /*************************** Credit handling **********************************/
1085 struct ecore_credit_pool_obj {
1086
1087         /* Current amount of credit in the pool */
1088         ecore_atomic_t  credit;
1089
1090         /* Maximum allowed credit. put() will check against it. */
1091         int             pool_sz;
1092
1093         /* Allocate a pool table statically.
1094          *
1095          * Currently the maximum allowed size is MAX_MAC_CREDIT_E2(272)
1096          *
1097          * The set bit in the table will mean that the entry is available.
1098          */
1099 #define ECORE_POOL_VEC_SIZE     (MAX_MAC_CREDIT_E2 / 64)
1100         uint64_t                pool_mirror[ECORE_POOL_VEC_SIZE];
1101
1102         /* Base pool offset (initialized differently */
1103         int             base_pool_offset;
1104
1105         /**
1106          * Get the next free pool entry.
1107          *
1108          * @return TRUE if there was a free entry in the pool
1109          */
1110         bool (*get_entry)(struct ecore_credit_pool_obj *o, int *entry);
1111
1112         /**
1113          * Return the entry back to the pool.
1114          *
1115          * @return TRUE if entry is legal and has been successfully
1116          *         returned to the pool.
1117          */
1118         bool (*put_entry)(struct ecore_credit_pool_obj *o, int entry);
1119
1120         /**
1121          * Get the requested amount of credit from the pool.
1122          *
1123          * @param cnt Amount of requested credit
1124          * @return TRUE if the operation is successful
1125          */
1126         bool (*get)(struct ecore_credit_pool_obj *o, int cnt);
1127
1128         /**
1129          * Returns the credit to the pool.
1130          *
1131          * @param cnt Amount of credit to return
1132          * @return TRUE if the operation is successful
1133          */
1134         bool (*put)(struct ecore_credit_pool_obj *o, int cnt);
1135
1136         /**
1137          * Reads the current amount of credit.
1138          */
1139         int (*check)(struct ecore_credit_pool_obj *o);
1140 };
1141
1142 /*************************** RSS configuration ********************************/
1143 enum {
1144         /* RSS_MODE bits are mutually exclusive */
1145         ECORE_RSS_MODE_DISABLED,
1146         ECORE_RSS_MODE_REGULAR,
1147
1148         ECORE_RSS_SET_SRCH, /* Setup searcher, E1x specific flag */
1149
1150         ECORE_RSS_IPV4,
1151         ECORE_RSS_IPV4_TCP,
1152         ECORE_RSS_IPV4_UDP,
1153         ECORE_RSS_IPV6,
1154         ECORE_RSS_IPV6_TCP,
1155         ECORE_RSS_IPV6_UDP,
1156
1157         ECORE_RSS_TUNNELING,
1158 #if defined(__VMKLNX__) && (VMWARE_ESX_DDK_VERSION < 55000) /* ! BNX2X_UPSTREAM */
1159         ECORE_RSS_MODE_ESX51,
1160 #endif
1161 };
1162
1163 struct ecore_config_rss_params {
1164         struct ecore_rss_config_obj *rss_obj;
1165
1166         /* may have RAMROD_COMP_WAIT set only */
1167         unsigned long   ramrod_flags;
1168
1169         /* ECORE_RSS_X bits */
1170         unsigned long   rss_flags;
1171
1172         /* Number hash bits to take into an account */
1173         uint8_t         rss_result_mask;
1174
1175         /* Indirection table */
1176         uint8_t         ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
1177
1178         /* RSS hash values */
1179         uint32_t                rss_key[10];
1180
1181         /* valid only iff ECORE_RSS_UPDATE_TOE is set */
1182         uint16_t                toe_rss_bitmap;
1183
1184         /* valid iff ECORE_RSS_TUNNELING is set */
1185         uint16_t                tunnel_value;
1186         uint16_t                tunnel_mask;
1187 };
1188
1189 struct ecore_rss_config_obj {
1190         struct ecore_raw_obj    raw;
1191
1192         /* RSS engine to use */
1193         uint8_t                 engine_id;
1194
1195         /* Last configured indirection table */
1196         uint8_t                 ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
1197
1198         /* flags for enabling 4-tupple hash on UDP */
1199         uint8_t                 udp_rss_v4;
1200         uint8_t                 udp_rss_v6;
1201
1202         int (*config_rss)(struct bxe_adapter *sc,
1203                           struct ecore_config_rss_params *p);
1204 };
1205
1206 /*********************** Queue state update ***********************************/
1207
1208 /* UPDATE command options */
1209 enum {
1210         ECORE_Q_UPDATE_IN_VLAN_REM,
1211         ECORE_Q_UPDATE_IN_VLAN_REM_CHNG,
1212         ECORE_Q_UPDATE_OUT_VLAN_REM,
1213         ECORE_Q_UPDATE_OUT_VLAN_REM_CHNG,
1214         ECORE_Q_UPDATE_ANTI_SPOOF,
1215         ECORE_Q_UPDATE_ANTI_SPOOF_CHNG,
1216         ECORE_Q_UPDATE_ACTIVATE,
1217         ECORE_Q_UPDATE_ACTIVATE_CHNG,
1218         ECORE_Q_UPDATE_DEF_VLAN_EN,
1219         ECORE_Q_UPDATE_DEF_VLAN_EN_CHNG,
1220         ECORE_Q_UPDATE_SILENT_VLAN_REM_CHNG,
1221         ECORE_Q_UPDATE_SILENT_VLAN_REM,
1222         ECORE_Q_UPDATE_TX_SWITCHING_CHNG,
1223         ECORE_Q_UPDATE_TX_SWITCHING,
1224 };
1225
1226 /* Allowed Queue states */
1227 enum ecore_q_state {
1228         ECORE_Q_STATE_RESET,
1229         ECORE_Q_STATE_INITIALIZED,
1230         ECORE_Q_STATE_ACTIVE,
1231         ECORE_Q_STATE_MULTI_COS,
1232         ECORE_Q_STATE_MCOS_TERMINATED,
1233         ECORE_Q_STATE_INACTIVE,
1234         ECORE_Q_STATE_STOPPED,
1235         ECORE_Q_STATE_TERMINATED,
1236         ECORE_Q_STATE_FLRED,
1237         ECORE_Q_STATE_MAX,
1238 };
1239
1240 /* Allowed Queue states */
1241 enum ecore_q_logical_state {
1242         ECORE_Q_LOGICAL_STATE_ACTIVE,
1243         ECORE_Q_LOGICAL_STATE_STOPPED,
1244 };
1245
1246 /* Allowed commands */
1247 enum ecore_queue_cmd {
1248         ECORE_Q_CMD_INIT,
1249         ECORE_Q_CMD_SETUP,
1250         ECORE_Q_CMD_SETUP_TX_ONLY,
1251         ECORE_Q_CMD_DEACTIVATE,
1252         ECORE_Q_CMD_ACTIVATE,
1253         ECORE_Q_CMD_UPDATE,
1254         ECORE_Q_CMD_UPDATE_TPA,
1255         ECORE_Q_CMD_HALT,
1256         ECORE_Q_CMD_CFC_DEL,
1257         ECORE_Q_CMD_TERMINATE,
1258         ECORE_Q_CMD_EMPTY,
1259         ECORE_Q_CMD_MAX,
1260 };
1261
1262 /* queue SETUP + INIT flags */
1263 enum {
1264         ECORE_Q_FLG_TPA,
1265         ECORE_Q_FLG_TPA_IPV6,
1266         ECORE_Q_FLG_TPA_GRO,
1267         ECORE_Q_FLG_STATS,
1268         ECORE_Q_FLG_ZERO_STATS,
1269         ECORE_Q_FLG_ACTIVE,
1270         ECORE_Q_FLG_OV,
1271         ECORE_Q_FLG_VLAN,
1272         ECORE_Q_FLG_COS,
1273         ECORE_Q_FLG_HC,
1274         ECORE_Q_FLG_HC_EN,
1275         ECORE_Q_FLG_DHC,
1276         ECORE_Q_FLG_OOO,
1277         ECORE_Q_FLG_FCOE,
1278         ECORE_Q_FLG_LEADING_RSS,
1279         ECORE_Q_FLG_MCAST,
1280         ECORE_Q_FLG_DEF_VLAN,
1281         ECORE_Q_FLG_TX_SWITCH,
1282         ECORE_Q_FLG_TX_SEC,
1283         ECORE_Q_FLG_ANTI_SPOOF,
1284         ECORE_Q_FLG_SILENT_VLAN_REM,
1285         ECORE_Q_FLG_FORCE_DEFAULT_PRI,
1286         ECORE_Q_FLG_REFUSE_OUTBAND_VLAN,
1287         ECORE_Q_FLG_PCSUM_ON_PKT,
1288         ECORE_Q_FLG_TUN_INC_INNER_IP_ID
1289 };
1290
1291 /* Queue type options: queue type may be a combination of below. */
1292 enum ecore_q_type {
1293         ECORE_Q_TYPE_FWD,
1294         /** TODO: Consider moving both these flags into the init()
1295          *        ramrod params.
1296          */
1297         ECORE_Q_TYPE_HAS_RX,
1298         ECORE_Q_TYPE_HAS_TX,
1299 };
1300
1301 #define ECORE_PRIMARY_CID_INDEX                 0
1302 #define ECORE_MULTI_TX_COS_E1X                  3 /* QM only */
1303 #define ECORE_MULTI_TX_COS_E2_E3A0              2
1304 #define ECORE_MULTI_TX_COS_E3B0                 3
1305 #define ECORE_MULTI_TX_COS                      3 /* Maximum possible */
1306 #define MAC_PAD (ECORE_ALIGN(ETH_ALEN, sizeof(uint32_t)) - ETH_ALEN)
1307
1308 struct ecore_queue_init_params {
1309         struct {
1310                 unsigned long   flags;
1311                 uint16_t                hc_rate;
1312                 uint8_t         fw_sb_id;
1313                 uint8_t         sb_cq_index;
1314         } tx;
1315
1316         struct {
1317                 unsigned long   flags;
1318                 uint16_t                hc_rate;
1319                 uint8_t         fw_sb_id;
1320                 uint8_t         sb_cq_index;
1321         } rx;
1322
1323         /* CID context in the host memory */
1324         struct eth_context *cxts[ECORE_MULTI_TX_COS];
1325
1326         /* maximum number of cos supported by hardware */
1327         uint8_t max_cos;
1328 };
1329
1330 struct ecore_queue_terminate_params {
1331         /* index within the tx_only cids of this queue object */
1332         uint8_t cid_index;
1333 };
1334
1335 struct ecore_queue_cfc_del_params {
1336         /* index within the tx_only cids of this queue object */
1337         uint8_t cid_index;
1338 };
1339
1340 struct ecore_queue_update_params {
1341         unsigned long   update_flags; /* ECORE_Q_UPDATE_XX bits */
1342         uint16_t                def_vlan;
1343         uint16_t                silent_removal_value;
1344         uint16_t                silent_removal_mask;
1345 /* index within the tx_only cids of this queue object */
1346         uint8_t         cid_index;
1347 };
1348
1349 struct rxq_pause_params {
1350         uint16_t                bd_th_lo;
1351         uint16_t                bd_th_hi;
1352         uint16_t                rcq_th_lo;
1353         uint16_t                rcq_th_hi;
1354         uint16_t                sge_th_lo; /* valid iff ECORE_Q_FLG_TPA */
1355         uint16_t                sge_th_hi; /* valid iff ECORE_Q_FLG_TPA */
1356         uint16_t                pri_map;
1357 };
1358
1359 /* general */
1360 struct ecore_general_setup_params {
1361         /* valid iff ECORE_Q_FLG_STATS */
1362         uint8_t         stat_id;
1363
1364         uint8_t         spcl_id;
1365         uint16_t                mtu;
1366         uint8_t         cos;
1367 };
1368
1369 struct ecore_rxq_setup_params {
1370         /* dma */
1371         ecore_dma_addr_t        dscr_map;
1372         ecore_dma_addr_t        sge_map;
1373         ecore_dma_addr_t        rcq_map;
1374         ecore_dma_addr_t        rcq_np_map;
1375
1376         uint16_t                drop_flags;
1377         uint16_t                buf_sz;
1378         uint8_t         fw_sb_id;
1379         uint8_t         cl_qzone_id;
1380
1381         /* valid iff ECORE_Q_FLG_TPA */
1382         uint16_t                tpa_agg_sz;
1383         uint16_t                sge_buf_sz;
1384         uint8_t         max_sges_pkt;
1385         uint8_t         max_tpa_queues;
1386         uint8_t         rss_engine_id;
1387
1388         /* valid iff ECORE_Q_FLG_MCAST */
1389         uint8_t         mcast_engine_id;
1390
1391         uint8_t         cache_line_log;
1392
1393         uint8_t         sb_cq_index;
1394
1395         /* valid iff BXN2X_Q_FLG_SILENT_VLAN_REM */
1396         uint16_t silent_removal_value;
1397         uint16_t silent_removal_mask;
1398 };
1399
1400 struct ecore_txq_setup_params {
1401         /* dma */
1402         ecore_dma_addr_t        dscr_map;
1403
1404         uint8_t         fw_sb_id;
1405         uint8_t         sb_cq_index;
1406         uint8_t         cos;            /* valid iff ECORE_Q_FLG_COS */
1407         uint16_t                traffic_type;
1408         /* equals to the leading rss client id, used for TX classification*/
1409         uint8_t         tss_leading_cl_id;
1410
1411         /* valid iff ECORE_Q_FLG_DEF_VLAN */
1412         uint16_t                default_vlan;
1413 };
1414
1415 struct ecore_queue_setup_params {
1416         struct ecore_general_setup_params gen_params;
1417         struct ecore_txq_setup_params txq_params;
1418         struct ecore_rxq_setup_params rxq_params;
1419         struct rxq_pause_params pause_params;
1420         unsigned long flags;
1421 };
1422
1423 struct ecore_queue_setup_tx_only_params {
1424         struct ecore_general_setup_params       gen_params;
1425         struct ecore_txq_setup_params           txq_params;
1426         unsigned long                           flags;
1427         /* index within the tx_only cids of this queue object */
1428         uint8_t                                 cid_index;
1429 };
1430
1431 struct ecore_queue_state_params {
1432         struct ecore_queue_sp_obj *q_obj;
1433
1434         /* Current command */
1435         enum ecore_queue_cmd cmd;
1436
1437         /* may have RAMROD_COMP_WAIT set only */
1438         unsigned long ramrod_flags;
1439
1440         /* Params according to the current command */
1441         union {
1442                 struct ecore_queue_update_params        update;
1443                 struct ecore_queue_setup_params         setup;
1444                 struct ecore_queue_init_params          init;
1445                 struct ecore_queue_setup_tx_only_params tx_only;
1446                 struct ecore_queue_terminate_params     terminate;
1447                 struct ecore_queue_cfc_del_params       cfc_del;
1448         } params;
1449 };
1450
1451 struct ecore_viflist_params {
1452         uint8_t echo_res;
1453         uint8_t func_bit_map_res;
1454 };
1455
1456 struct ecore_queue_sp_obj {
1457         uint32_t                cids[ECORE_MULTI_TX_COS];
1458         uint8_t         cl_id;
1459         uint8_t         func_id;
1460
1461         /* number of traffic classes supported by queue.
1462          * The primary connection of the queue supports the first traffic
1463          * class. Any further traffic class is supported by a tx-only
1464          * connection.
1465          *
1466          * Therefore max_cos is also a number of valid entries in the cids
1467          * array.
1468          */
1469         uint8_t max_cos;
1470         uint8_t num_tx_only, next_tx_only;
1471
1472         enum ecore_q_state state, next_state;
1473
1474         /* bits from enum ecore_q_type */
1475         unsigned long   type;
1476
1477         /* ECORE_Q_CMD_XX bits. This object implements "one
1478          * pending" paradigm but for debug and tracing purposes it's
1479          * more convenient to have different bits for different
1480          * commands.
1481          */
1482         unsigned long   pending;
1483
1484         /* Buffer to use as a ramrod data and its mapping */
1485         void            *rdata;
1486         ecore_dma_addr_t        rdata_mapping;
1487
1488         /**
1489          * Performs one state change according to the given parameters.
1490          *
1491          * @return 0 in case of success and negative value otherwise.
1492          */
1493         int (*send_cmd)(struct bxe_adapter *sc,
1494                         struct ecore_queue_state_params *params);
1495
1496         /**
1497          * Sets the pending bit according to the requested transition.
1498          */
1499         int (*set_pending)(struct ecore_queue_sp_obj *o,
1500                            struct ecore_queue_state_params *params);
1501
1502         /**
1503          * Checks that the requested state transition is legal.
1504          */
1505         int (*check_transition)(struct bxe_adapter *sc,
1506                                 struct ecore_queue_sp_obj *o,
1507                                 struct ecore_queue_state_params *params);
1508
1509         /**
1510          * Completes the pending command.
1511          */
1512         int (*complete_cmd)(struct bxe_adapter *sc,
1513                             struct ecore_queue_sp_obj *o,
1514                             enum ecore_queue_cmd);
1515
1516         int (*wait_comp)(struct bxe_adapter *sc,
1517                          struct ecore_queue_sp_obj *o,
1518                          enum ecore_queue_cmd cmd);
1519 };
1520
1521 /********************** Function state update *********************************/
1522 /* Allowed Function states */
1523 enum ecore_func_state {
1524         ECORE_F_STATE_RESET,
1525         ECORE_F_STATE_INITIALIZED,
1526         ECORE_F_STATE_STARTED,
1527         ECORE_F_STATE_TX_STOPPED,
1528         ECORE_F_STATE_MAX,
1529 };
1530
1531 /* Allowed Function commands */
1532 enum ecore_func_cmd {
1533         ECORE_F_CMD_HW_INIT,
1534         ECORE_F_CMD_START,
1535         ECORE_F_CMD_STOP,
1536         ECORE_F_CMD_HW_RESET,
1537         ECORE_F_CMD_AFEX_UPDATE,
1538         ECORE_F_CMD_AFEX_VIFLISTS,
1539         ECORE_F_CMD_TX_STOP,
1540         ECORE_F_CMD_TX_START,
1541         ECORE_F_CMD_SWITCH_UPDATE,
1542         ECORE_F_CMD_MAX,
1543 };
1544
1545 struct ecore_func_hw_init_params {
1546         /* A load phase returned by MCP.
1547          *
1548          * May be:
1549          *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
1550          *              FW_MSG_CODE_DRV_LOAD_COMMON
1551          *              FW_MSG_CODE_DRV_LOAD_PORT
1552          *              FW_MSG_CODE_DRV_LOAD_FUNCTION
1553          */
1554         uint32_t load_phase;
1555 };
1556
1557 struct ecore_func_hw_reset_params {
1558         /* A load phase returned by MCP.
1559          *
1560          * May be:
1561          *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
1562          *              FW_MSG_CODE_DRV_LOAD_COMMON
1563          *              FW_MSG_CODE_DRV_LOAD_PORT
1564          *              FW_MSG_CODE_DRV_LOAD_FUNCTION
1565          */
1566         uint32_t reset_phase;
1567 };
1568
1569 struct ecore_func_start_params {
1570         /* Multi Function mode:
1571          *      - Single Function
1572          *      - Switch Dependent
1573          *      - Switch Independent
1574          */
1575         uint16_t mf_mode;
1576
1577         /* Switch Dependent mode outer VLAN tag */
1578         uint16_t sd_vlan_tag;
1579
1580         /* Function cos mode */
1581         uint8_t network_cos_mode;
1582
1583         /* NVGRE classification enablement */
1584         uint8_t nvgre_clss_en;
1585
1586         /* NO_GRE_TUNNEL/NVGRE_TUNNEL/L2GRE_TUNNEL/IPGRE_TUNNEL */
1587         uint8_t gre_tunnel_mode;
1588
1589         /* GRE_OUTER_HEADERS_RSS/GRE_INNER_HEADERS_RSS/NVGRE_KEY_ENTROPY_RSS */
1590         uint8_t gre_tunnel_rss;
1591
1592 };
1593
1594 struct ecore_func_switch_update_params {
1595         uint8_t suspend;
1596 };
1597
1598 struct ecore_func_afex_update_params {
1599         uint16_t vif_id;
1600         uint16_t afex_default_vlan;
1601         uint8_t allowed_priorities;
1602 };
1603
1604 struct ecore_func_afex_viflists_params {
1605         uint16_t vif_list_index;
1606         uint8_t func_bit_map;
1607         uint8_t afex_vif_list_command;
1608         uint8_t func_to_clear;
1609 };
1610 struct ecore_func_tx_start_params {
1611         struct priority_cos traffic_type_to_priority_cos[MAX_TRAFFIC_TYPES];
1612         uint8_t dcb_enabled;
1613         uint8_t dcb_version;
1614         uint8_t dont_add_pri_0;
1615 };
1616
1617 struct ecore_func_state_params {
1618         struct ecore_func_sp_obj *f_obj;
1619
1620         /* Current command */
1621         enum ecore_func_cmd cmd;
1622
1623         /* may have RAMROD_COMP_WAIT set only */
1624         unsigned long   ramrod_flags;
1625
1626         /* Params according to the current command */
1627         union {
1628                 struct ecore_func_hw_init_params hw_init;
1629                 struct ecore_func_hw_reset_params hw_reset;
1630                 struct ecore_func_start_params start;
1631                 struct ecore_func_switch_update_params switch_update;
1632                 struct ecore_func_afex_update_params afex_update;
1633                 struct ecore_func_afex_viflists_params afex_viflists;
1634                 struct ecore_func_tx_start_params tx_start;
1635         } params;
1636 };
1637
1638 struct ecore_func_sp_drv_ops {
1639         /* Init tool + runtime initialization:
1640          *      - Common Chip
1641          *      - Common (per Path)
1642          *      - Port
1643          *      - Function phases
1644          */
1645         int (*init_hw_cmn_chip)(struct bxe_adapter *sc);
1646         int (*init_hw_cmn)(struct bxe_adapter *sc);
1647         int (*init_hw_port)(struct bxe_adapter *sc);
1648         int (*init_hw_func)(struct bxe_adapter *sc);
1649
1650         /* Reset Function HW: Common, Port, Function phases. */
1651         void (*reset_hw_cmn)(struct bxe_adapter *sc);
1652         void (*reset_hw_port)(struct bxe_adapter *sc);
1653         void (*reset_hw_func)(struct bxe_adapter *sc);
1654
1655         /* Init/Free GUNZIP resources */
1656         int (*gunzip_init)(struct bxe_adapter *sc);
1657         void (*gunzip_end)(struct bxe_adapter *sc);
1658
1659         /* Prepare/Release FW resources */
1660         int (*init_fw)(struct bxe_adapter *sc);
1661         void (*release_fw)(struct bxe_adapter *sc);
1662 };
1663
1664 struct ecore_func_sp_obj {
1665         enum ecore_func_state   state, next_state;
1666
1667         /* ECORE_FUNC_CMD_XX bits. This object implements "one
1668          * pending" paradigm but for debug and tracing purposes it's
1669          * more convenient to have different bits for different
1670          * commands.
1671          */
1672         unsigned long           pending;
1673
1674         /* Buffer to use as a ramrod data and its mapping */
1675         void                    *rdata;
1676         ecore_dma_addr_t                rdata_mapping;
1677
1678         /* Buffer to use as a afex ramrod data and its mapping.
1679          * This can't be same rdata as above because afex ramrod requests
1680          * can arrive to the object in parallel to other ramrod requests.
1681          */
1682         void                    *afex_rdata;
1683         ecore_dma_addr_t                afex_rdata_mapping;
1684
1685         /* this mutex validates that when pending flag is taken, the next
1686          * ramrod to be sent will be the one set the pending bit
1687          */
1688         qlock_t         one_pending_mutex;
1689
1690         /* Driver interface */
1691         struct ecore_func_sp_drv_ops    *drv;
1692
1693         /**
1694          * Performs one state change according to the given parameters.
1695          *
1696          * @return 0 in case of success and negative value otherwise.
1697          */
1698         int (*send_cmd)(struct bxe_adapter *sc,
1699                         struct ecore_func_state_params *params);
1700
1701         /**
1702          * Checks that the requested state transition is legal.
1703          */
1704         int (*check_transition)(struct bxe_adapter *sc,
1705                                 struct ecore_func_sp_obj *o,
1706                                 struct ecore_func_state_params *params);
1707
1708         /**
1709          * Completes the pending command.
1710          */
1711         int (*complete_cmd)(struct bxe_adapter *sc,
1712                             struct ecore_func_sp_obj *o,
1713                             enum ecore_func_cmd cmd);
1714
1715         int (*wait_comp)(struct bxe_adapter *sc, struct ecore_func_sp_obj *o,
1716                          enum ecore_func_cmd cmd);
1717 };
1718
1719 /********************** Interfaces ********************************************/
1720 /* Queueable objects set */
1721 union ecore_qable_obj {
1722         struct ecore_vlan_mac_obj vlan_mac;
1723 };
1724 /************** Function state update *********/
1725 void ecore_init_func_obj(struct bxe_adapter *sc,
1726                          struct ecore_func_sp_obj *obj,
1727                          void *rdata, ecore_dma_addr_t rdata_mapping,
1728                          void *afex_rdata, ecore_dma_addr_t afex_rdata_mapping,
1729                          struct ecore_func_sp_drv_ops *drv_iface);
1730
1731 int ecore_func_state_change(struct bxe_adapter *sc,
1732                             struct ecore_func_state_params *params);
1733
1734 enum ecore_func_state ecore_func_get_state(struct bxe_adapter *sc,
1735                                            struct ecore_func_sp_obj *o);
1736 /******************* Queue State **************/
1737 void ecore_init_queue_obj(struct bxe_adapter *sc,
1738                           struct ecore_queue_sp_obj *obj, uint8_t cl_id, uint32_t *cids,
1739                           uint8_t cid_cnt, uint8_t func_id, void *rdata,
1740                           ecore_dma_addr_t rdata_mapping, unsigned long type);
1741
1742 int ecore_queue_state_change(struct bxe_adapter *sc,
1743                              struct ecore_queue_state_params *params);
1744
1745 int ecore_get_q_logical_state(struct bxe_adapter *sc,
1746                                struct ecore_queue_sp_obj *obj);
1747
1748 /********************* VLAN-MAC ****************/
1749 void ecore_init_mac_obj(struct bxe_adapter *sc,
1750                         struct ecore_vlan_mac_obj *mac_obj,
1751                         uint8_t cl_id, uint32_t cid, uint8_t func_id, void *rdata,
1752                         ecore_dma_addr_t rdata_mapping, int state,
1753                         unsigned long *pstate, ecore_obj_type type,
1754                         struct ecore_credit_pool_obj *macs_pool);
1755
1756 void ecore_init_vlan_obj(struct bxe_adapter *sc,
1757                          struct ecore_vlan_mac_obj *vlan_obj,
1758                          uint8_t cl_id, uint32_t cid, uint8_t func_id, void *rdata,
1759                          ecore_dma_addr_t rdata_mapping, int state,
1760                          unsigned long *pstate, ecore_obj_type type,
1761                          struct ecore_credit_pool_obj *vlans_pool);
1762
1763 void ecore_init_vlan_mac_obj(struct bxe_adapter *sc,
1764                              struct ecore_vlan_mac_obj *vlan_mac_obj,
1765                              uint8_t cl_id, uint32_t cid, uint8_t func_id, void *rdata,
1766                              ecore_dma_addr_t rdata_mapping, int state,
1767                              unsigned long *pstate, ecore_obj_type type,
1768                              struct ecore_credit_pool_obj *macs_pool,
1769                              struct ecore_credit_pool_obj *vlans_pool);
1770
1771 int ecore_vlan_mac_h_read_lock(struct bxe_adapter *sc,
1772                                         struct ecore_vlan_mac_obj *o);
1773 void ecore_vlan_mac_h_read_unlock(struct bxe_adapter *sc,
1774                                   struct ecore_vlan_mac_obj *o);
1775 int ecore_vlan_mac_h_write_lock(struct bxe_adapter *sc,
1776                                 struct ecore_vlan_mac_obj *o);
1777 void ecore_vlan_mac_h_write_unlock(struct bxe_adapter *sc,
1778                                           struct ecore_vlan_mac_obj *o);
1779 int ecore_config_vlan_mac(struct bxe_adapter *sc,
1780                            struct ecore_vlan_mac_ramrod_params *p);
1781
1782 int ecore_vlan_mac_move(struct bxe_adapter *sc,
1783                         struct ecore_vlan_mac_ramrod_params *p,
1784                         struct ecore_vlan_mac_obj *dest_o);
1785
1786 /********************* RX MODE ****************/
1787
1788 void ecore_init_rx_mode_obj(struct bxe_adapter *sc,
1789                             struct ecore_rx_mode_obj *o);
1790
1791 /**
1792  * ecore_config_rx_mode - Send and RX_MODE ramrod according to the provided parameters.
1793  *
1794  * @p: Command parameters
1795  *
1796  * Return: 0 - if operation was successful and there is no pending completions,
1797  *         positive number - if there are pending completions,
1798  *         negative - if there were errors
1799  */
1800 int ecore_config_rx_mode(struct bxe_adapter *sc,
1801                          struct ecore_rx_mode_ramrod_params *p);
1802
1803 /****************** MULTICASTS ****************/
1804
1805 void ecore_init_mcast_obj(struct bxe_adapter *sc,
1806                           struct ecore_mcast_obj *mcast_obj,
1807                           uint8_t mcast_cl_id, uint32_t mcast_cid, uint8_t func_id,
1808                           uint8_t engine_id, void *rdata, ecore_dma_addr_t rdata_mapping,
1809                           int state, unsigned long *pstate,
1810                           ecore_obj_type type);
1811
1812 /**
1813  * ecore_config_mcast - Configure multicast MACs list.
1814  *
1815  * @cmd: command to execute: BNX2X_MCAST_CMD_X
1816  *
1817  * May configure a new list
1818  * provided in p->mcast_list (ECORE_MCAST_CMD_ADD), clean up
1819  * (ECORE_MCAST_CMD_DEL) or restore (ECORE_MCAST_CMD_RESTORE) a current
1820  * configuration, continue to execute the pending commands
1821  * (ECORE_MCAST_CMD_CONT).
1822  *
1823  * If previous command is still pending or if number of MACs to
1824  * configure is more that maximum number of MACs in one command,
1825  * the current command will be enqueued to the tail of the
1826  * pending commands list.
1827  *
1828  * Return: 0 is operation was successfull and there are no pending completions,
1829  *         negative if there were errors, positive if there are pending
1830  *         completions.
1831  */
1832 int ecore_config_mcast(struct bxe_adapter *sc,
1833                        struct ecore_mcast_ramrod_params *p,
1834                        enum ecore_mcast_cmd cmd);
1835
1836 /****************** CREDIT POOL ****************/
1837 void ecore_init_mac_credit_pool(struct bxe_adapter *sc,
1838                                 struct ecore_credit_pool_obj *p, uint8_t func_id,
1839                                 uint8_t func_num);
1840 void ecore_init_vlan_credit_pool(struct bxe_adapter *sc,
1841                                  struct ecore_credit_pool_obj *p, uint8_t func_id,
1842                                  uint8_t func_num);
1843
1844 /****************** RSS CONFIGURATION ****************/
1845 void ecore_init_rss_config_obj(struct bxe_adapter *sc,
1846                                struct ecore_rss_config_obj *rss_obj,
1847                                uint8_t cl_id, uint32_t cid, uint8_t func_id, uint8_t engine_id,
1848                                void *rdata, ecore_dma_addr_t rdata_mapping,
1849                                int state, unsigned long *pstate,
1850                                ecore_obj_type type);
1851
1852 /**
1853  * ecore_config_rss - Updates RSS configuration according to provided parameters
1854  *
1855  * Return: 0 in case of success
1856  */
1857 int ecore_config_rss(struct bxe_adapter *sc,
1858                      struct ecore_config_rss_params *p);
1859
1860 /**
1861  * ecore_get_rss_ind_table - Return the current ind_table configuration.
1862  *
1863  * @ind_table: buffer to fill with the current indirection
1864  *                  table content. Should be at least
1865  *                  T_ETH_INDIRECTION_TABLE_SIZE bytes long.
1866  */
1867 void ecore_get_rss_ind_table(struct ecore_rss_config_obj *rss_obj,
1868                              uint8_t *ind_table);
1869
1870 /* set as inline so printout will show the offending function */
1871 int validate_vlan_mac(struct bxe_adapter *sc,
1872                       struct ecore_vlan_mac_obj *vlan_mac);
1873
1874 #endif /* ECORE_SP_H */
1875