BNX2X: initialization
[akaros.git] / kern / drivers / net / bnx2x / bnx2x_sp.h
1 /* bnx2x_sp.h: Broadcom Everest network driver.
2  *
3  * Copyright (c) 2011-2013 Broadcom Corporation
4  *
5  * Unless you and Broadcom execute a separate written software license
6  * agreement governing use of this software, this software is licensed to you
7  * under the terms of the GNU General Public License version 2, available
8  * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
9  *
10  * Notwithstanding the above, under no circumstances may you combine this
11  * software in any way with any other Broadcom software provided under a
12  * license other than the GPL, without Broadcom's express prior written
13  * consent.
14  *
15  * Maintained by: Ariel Elior <ariel.elior@qlogic.com>
16  * Written by: Vladislav Zolotarov
17  *
18  */
19 #ifndef BNX2X_SP_VERBS
20 #define BNX2X_SP_VERBS
21
22 struct bnx2x;
23 struct eth_context;
24
25 /* Bits representing general command's configuration */
26 enum {
27         RAMROD_TX,
28         RAMROD_RX,
29         /* Wait until all pending commands complete */
30         RAMROD_COMP_WAIT,
31         /* Don't send a ramrod, only update a registry */
32         RAMROD_DRV_CLR_ONLY,
33         /* Configure HW according to the current object state */
34         RAMROD_RESTORE,
35          /* Execute the next command now */
36         RAMROD_EXEC,
37         /* Don't add a new command and continue execution of postponed
38          * commands. If not set a new command will be added to the
39          * pending commands list.
40          */
41         RAMROD_CONT,
42         /* If there is another pending ramrod, wait until it finishes and
43          * re-try to submit this one. This flag can be set only in sleepable
44          * context, and should not be set from the context that completes the
45          * ramrods as deadlock will occur.
46          */
47         RAMROD_RETRY,
48 };
49
50 typedef enum {
51         BNX2X_OBJ_TYPE_RX,
52         BNX2X_OBJ_TYPE_TX,
53         BNX2X_OBJ_TYPE_RX_TX,
54 } bnx2x_obj_type;
55
56 /* Public slow path states */
57 enum {
58         BNX2X_FILTER_MAC_PENDING,
59         BNX2X_FILTER_VLAN_PENDING,
60         BNX2X_FILTER_VLAN_MAC_PENDING,
61         BNX2X_FILTER_RX_MODE_PENDING,
62         BNX2X_FILTER_RX_MODE_SCHED,
63         BNX2X_FILTER_ISCSI_ETH_START_SCHED,
64         BNX2X_FILTER_ISCSI_ETH_STOP_SCHED,
65         BNX2X_FILTER_FCOE_ETH_START_SCHED,
66         BNX2X_FILTER_FCOE_ETH_STOP_SCHED,
67         BNX2X_FILTER_MCAST_PENDING,
68         BNX2X_FILTER_MCAST_SCHED,
69         BNX2X_FILTER_RSS_CONF_PENDING,
70         BNX2X_AFEX_FCOE_Q_UPDATE_PENDING,
71         BNX2X_AFEX_PENDING_VIFSET_MCP_ACK
72 };
73
74 struct bnx2x_raw_obj {
75         uint8_t         func_id;
76
77         /* Queue params */
78         uint8_t         cl_id;
79         uint32_t                cid;
80
81         /* Ramrod data buffer params */
82         void            *rdata;
83         dma_addr_t      rdata_mapping;
84
85         /* Ramrod state params */
86         int             state;   /* "ramrod is pending" state bit */
87         unsigned long   *pstate; /* pointer to state buffer */
88
89         bnx2x_obj_type  obj_type;
90
91         int (*wait_comp)(struct bnx2x *bp,
92                          struct bnx2x_raw_obj *o);
93
94         bool (*check_pending)(struct bnx2x_raw_obj *o);
95         void (*clear_pending)(struct bnx2x_raw_obj *o);
96         void (*set_pending)(struct bnx2x_raw_obj *o);
97 };
98
99 /************************* VLAN-MAC commands related parameters ***************/
100 struct bnx2x_mac_ramrod_data {
101         uint8_t mac[Eaddrlen];
102         uint8_t is_inner_mac;
103 };
104
105 struct bnx2x_vlan_ramrod_data {
106         uint16_t vlan;
107 };
108
109 struct bnx2x_vlan_mac_ramrod_data {
110         uint8_t mac[Eaddrlen];
111         uint8_t is_inner_mac;
112         uint16_t vlan;
113 };
114
115 union bnx2x_classification_ramrod_data {
116         struct bnx2x_mac_ramrod_data mac;
117         struct bnx2x_vlan_ramrod_data vlan;
118         struct bnx2x_vlan_mac_ramrod_data vlan_mac;
119 };
120
121 /* VLAN_MAC commands */
122 enum bnx2x_vlan_mac_cmd {
123         BNX2X_VLAN_MAC_ADD,
124         BNX2X_VLAN_MAC_DEL,
125         BNX2X_VLAN_MAC_MOVE,
126 };
127
128 struct bnx2x_vlan_mac_data {
129         /* Requested command: BNX2X_VLAN_MAC_XX */
130         enum bnx2x_vlan_mac_cmd cmd;
131         /* used to contain the data related vlan_mac_flags bits from
132          * ramrod parameters.
133          */
134         unsigned long vlan_mac_flags;
135
136         /* Needed for MOVE command */
137         struct bnx2x_vlan_mac_obj *target_obj;
138
139         union bnx2x_classification_ramrod_data u;
140 };
141
142 /*************************** Exe Queue obj ************************************/
143 union bnx2x_exe_queue_cmd_data {
144         struct bnx2x_vlan_mac_data vlan_mac;
145
146         struct {
147                 /* TODO */
148         } mcast;
149 };
150
151 struct bnx2x_exeq_elem {
152         struct list_head                link;
153
154         /* Length of this element in the exe_chunk. */
155         int                             cmd_len;
156
157         union bnx2x_exe_queue_cmd_data  cmd_data;
158 };
159
160 union bnx2x_qable_obj;
161
162 union bnx2x_exeq_comp_elem {
163         union event_ring_elem *elem;
164 };
165
166 struct bnx2x_exe_queue_obj;
167
168 typedef int (*exe_q_validate)(struct bnx2x *bp,
169                               union bnx2x_qable_obj *o,
170                               struct bnx2x_exeq_elem *elem);
171
172 typedef int (*exe_q_remove)(struct bnx2x *bp,
173                             union bnx2x_qable_obj *o,
174                             struct bnx2x_exeq_elem *elem);
175
176 /* Return positive if entry was optimized, 0 - if not, negative
177  * in case of an error.
178  */
179 typedef int (*exe_q_optimize)(struct bnx2x *bp,
180                               union bnx2x_qable_obj *o,
181                               struct bnx2x_exeq_elem *elem);
182 typedef int (*exe_q_execute)(struct bnx2x *bp,
183                              union bnx2x_qable_obj *o,
184                              struct list_head *exe_chunk,
185                              unsigned long *ramrod_flags);
186 typedef struct bnx2x_exeq_elem *
187                         (*exe_q_get)(struct bnx2x_exe_queue_obj *o,
188                                      struct bnx2x_exeq_elem *elem);
189
190 struct bnx2x_exe_queue_obj {
191         /* Commands pending for an execution. */
192         struct list_head        exe_queue;
193
194         /* Commands pending for an completion. */
195         struct list_head        pending_comp;
196
197         spinlock_t              lock;
198
199         /* Maximum length of commands' list for one execution */
200         int                     exe_chunk_len;
201
202         union bnx2x_qable_obj   *owner;
203
204         /****** Virtual functions ******/
205         /**
206          * Called before commands execution for commands that are really
207          * going to be executed (after 'optimize').
208          *
209          * Must run under exe_queue->lock
210          */
211         exe_q_validate          validate;
212
213         /**
214          * Called before removing pending commands, cleaning allocated
215          * resources (e.g., credits from validate)
216          */
217          exe_q_remove           remove;
218
219         /**
220          * This will try to cancel the current pending commands list
221          * considering the new command.
222          *
223          * Returns the number of optimized commands or a negative error code
224          *
225          * Must run under exe_queue->lock
226          */
227         exe_q_optimize          optimize;
228
229         /**
230          * Run the next commands chunk (owner specific).
231          */
232         exe_q_execute           execute;
233
234         /**
235          * Return the exe_queue element containing the specific command
236          * if any. Otherwise return NULL.
237          */
238         exe_q_get               get;
239 };
240 /***************** Classification verbs: Set/Del MAC/VLAN/VLAN-MAC ************/
241 /*
242  * Element in the VLAN_MAC registry list having all currently configured
243  * rules.
244  */
245 struct bnx2x_vlan_mac_registry_elem {
246         struct list_head        link;
247
248         /* Used to store the cam offset used for the mac/vlan/vlan-mac.
249          * Relevant for 57710 and 57711 only. VLANs and MACs share the
250          * same CAM for these chips.
251          */
252         int                     cam_offset;
253
254         /* Needed for DEL and RESTORE flows */
255         unsigned long           vlan_mac_flags;
256
257         union bnx2x_classification_ramrod_data u;
258 };
259
260 /* Bits representing VLAN_MAC commands specific flags */
261 enum {
262         BNX2X_UC_LIST_MAC,
263         BNX2X_ETH_MAC,
264         BNX2X_ISCSI_ETH_MAC,
265         BNX2X_NETQ_ETH_MAC,
266         BNX2X_DONT_CONSUME_CAM_CREDIT,
267         BNX2X_DONT_CONSUME_CAM_CREDIT_DEST,
268 };
269 /* When looking for matching filters, some flags are not interesting */
270 #define BNX2X_VLAN_MAC_CMP_MASK (1 << BNX2X_UC_LIST_MAC | \
271                                  1 << BNX2X_ETH_MAC | \
272                                  1 << BNX2X_ISCSI_ETH_MAC | \
273                                  1 << BNX2X_NETQ_ETH_MAC)
274 #define BNX2X_VLAN_MAC_CMP_FLAGS(flags) \
275         ((flags) & BNX2X_VLAN_MAC_CMP_MASK)
276
277 struct bnx2x_vlan_mac_ramrod_params {
278         /* Object to run the command from */
279         struct bnx2x_vlan_mac_obj *vlan_mac_obj;
280
281         /* General command flags: COMP_WAIT, etc. */
282         unsigned long ramrod_flags;
283
284         /* Command specific configuration request */
285         struct bnx2x_vlan_mac_data user_req;
286 };
287
288 struct bnx2x_vlan_mac_obj {
289         struct bnx2x_raw_obj raw;
290
291         /* Bookkeeping list: will prevent the addition of already existing
292          * entries.
293          */
294         struct list_head                head;
295         /* Implement a simple reader/writer lock on the head list.
296          * all these fields should only be accessed under the exe_queue lock
297          */
298         uint8_t         head_reader; /* Num. of readers accessing head list */
299         bool            head_exe_request; /* Pending execution request. */
300         unsigned long   saved_ramrod_flags; /* Ramrods of pending execution */
301
302         /* TODO: Add it's initialization in the init functions */
303         struct bnx2x_exe_queue_obj      exe_queue;
304
305         /* MACs credit pool */
306         struct bnx2x_credit_pool_obj    *macs_pool;
307
308         /* VLANs credit pool */
309         struct bnx2x_credit_pool_obj    *vlans_pool;
310
311         /* RAMROD command to be used */
312         int                             ramrod_cmd;
313
314         /* copy first n elements onto preallocated buffer
315          *
316          * @param n number of elements to get
317          * @param buf buffer preallocated by caller into which elements
318          *            will be copied. Note elements are 4-byte aligned
319          *            so buffer size must be able to accommodate the
320          *            aligned elements.
321          *
322          * @return number of copied bytes
323          */
324         int (*get_n_elements)(struct bnx2x *bp,
325                               struct bnx2x_vlan_mac_obj *o, int n,
326                               uint8_t *base,
327                               uint8_t stride, uint8_t size);
328
329         /**
330          * Checks if ADD-ramrod with the given params may be performed.
331          *
332          * @return zero if the element may be added
333          */
334
335         int (*check_add)(struct bnx2x *bp,
336                          struct bnx2x_vlan_mac_obj *o,
337                          union bnx2x_classification_ramrod_data *data);
338
339         /**
340          * Checks if DEL-ramrod with the given params may be performed.
341          *
342          * @return true if the element may be deleted
343          */
344         struct bnx2x_vlan_mac_registry_elem *
345                 (*check_del)(struct bnx2x *bp,
346                              struct bnx2x_vlan_mac_obj *o,
347                              union bnx2x_classification_ramrod_data *data);
348
349         /**
350          * Checks if DEL-ramrod with the given params may be performed.
351          *
352          * @return true if the element may be deleted
353          */
354         bool (*check_move)(struct bnx2x *bp,
355                            struct bnx2x_vlan_mac_obj *src_o,
356                            struct bnx2x_vlan_mac_obj *dst_o,
357                            union bnx2x_classification_ramrod_data *data);
358
359         /**
360          *  Update the relevant credit object(s) (consume/return
361          *  correspondingly).
362          */
363         bool (*get_credit)(struct bnx2x_vlan_mac_obj *o);
364         bool (*put_credit)(struct bnx2x_vlan_mac_obj *o);
365         bool (*get_cam_offset)(struct bnx2x_vlan_mac_obj *o, int *offset);
366         bool (*put_cam_offset)(struct bnx2x_vlan_mac_obj *o, int offset);
367
368         /**
369          * Configures one rule in the ramrod data buffer.
370          */
371         void (*set_one_rule)(struct bnx2x *bp,
372                              struct bnx2x_vlan_mac_obj *o,
373                              struct bnx2x_exeq_elem *elem, int rule_idx,
374                              int cam_offset);
375
376         /**
377         *  Delete all configured elements having the given
378         *  vlan_mac_flags specification. Assumes no pending for
379         *  execution commands. Will schedule all all currently
380         *  configured MACs/VLANs/VLAN-MACs matching the vlan_mac_flags
381         *  specification for deletion and will use the given
382         *  ramrod_flags for the last DEL operation.
383          *
384          * @param bp
385          * @param o
386          * @param ramrod_flags RAMROD_XX flags
387          *
388          * @return 0 if the last operation has completed successfully
389          *         and there are no more elements left, positive value
390          *         if there are pending for completion commands,
391          *         negative value in case of failure.
392          */
393         int (*delete_all)(struct bnx2x *bp,
394                           struct bnx2x_vlan_mac_obj *o,
395                           unsigned long *vlan_mac_flags,
396                           unsigned long *ramrod_flags);
397
398         /**
399          * Reconfigures the next MAC/VLAN/VLAN-MAC element from the previously
400          * configured elements list.
401          *
402          * @param bp
403          * @param p Command parameters (RAMROD_COMP_WAIT bit in
404          *          ramrod_flags is only taken into an account)
405          * @param ppos a pointer to the cookie that should be given back in the
406          *        next call to make function handle the next element. If
407          *        *ppos is set to NULL it will restart the iterator.
408          *        If returned *ppos == NULL this means that the last
409          *        element has been handled.
410          *
411          * @return int
412          */
413         int (*restore)(struct bnx2x *bp,
414                        struct bnx2x_vlan_mac_ramrod_params *p,
415                        struct bnx2x_vlan_mac_registry_elem **ppos);
416
417         /**
418          * Should be called on a completion arrival.
419          *
420          * @param bp
421          * @param o
422          * @param cqe Completion element we are handling
423          * @param ramrod_flags if RAMROD_CONT is set the next bulk of
424          *                     pending commands will be executed.
425          *                     RAMROD_DRV_CLR_ONLY and RAMROD_RESTORE
426          *                     may also be set if needed.
427          *
428          * @return 0 if there are neither pending nor waiting for
429          *         completion commands. Positive value if there are
430          *         pending for execution or for completion commands.
431          *         Negative value in case of an error (including an
432          *         error in the cqe).
433          */
434         int (*complete)(struct bnx2x *bp, struct bnx2x_vlan_mac_obj *o,
435                         union event_ring_elem *cqe,
436                         unsigned long *ramrod_flags);
437
438         /**
439          * Wait for completion of all commands. Don't schedule new ones,
440          * just wait. It assumes that the completion code will schedule
441          * for new commands.
442          */
443         int (*wait)(struct bnx2x *bp, struct bnx2x_vlan_mac_obj *o);
444 };
445
446 enum {
447         BNX2X_LLH_CAM_ISCSI_ETH_LINE = 0,
448         BNX2X_LLH_CAM_ETH_LINE,
449         BNX2X_LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE / 2
450 };
451
452 /** RX_MODE verbs:DROP_ALL/ACCEPT_ALL/ACCEPT_ALL_MULTI/ACCEPT_ALL_VLAN/NORMAL */
453
454 /* RX_MODE ramrod special flags: set in rx_mode_flags field in
455  * a bnx2x_rx_mode_ramrod_params.
456  */
457 enum {
458         BNX2X_RX_MODE_FCOE_ETH,
459         BNX2X_RX_MODE_ISCSI_ETH,
460 };
461
462 enum {
463         BNX2X_ACCEPT_UNICAST,
464         BNX2X_ACCEPT_MULTICAST,
465         BNX2X_ACCEPT_ALL_UNICAST,
466         BNX2X_ACCEPT_ALL_MULTICAST,
467         BNX2X_ACCEPT_BROADCAST,
468         BNX2X_ACCEPT_UNMATCHED,
469         BNX2X_ACCEPT_ANY_VLAN
470 };
471
472 struct bnx2x_rx_mode_ramrod_params {
473         struct bnx2x_rx_mode_obj *rx_mode_obj;
474         unsigned long *pstate;
475         int state;
476         uint8_t cl_id;
477         uint32_t cid;
478         uint8_t func_id;
479         unsigned long ramrod_flags;
480         unsigned long rx_mode_flags;
481
482         /* rdata is either a pointer to eth_filter_rules_ramrod_data(e2) or to
483          * a tstorm_eth_mac_filter_config (e1x).
484          */
485         void *rdata;
486         dma_addr_t rdata_mapping;
487
488         /* Rx mode settings */
489         unsigned long rx_accept_flags;
490
491         /* internal switching settings */
492         unsigned long tx_accept_flags;
493 };
494
495 struct bnx2x_rx_mode_obj {
496         int (*config_rx_mode)(struct bnx2x *bp,
497                               struct bnx2x_rx_mode_ramrod_params *p);
498
499         int (*wait_comp)(struct bnx2x *bp,
500                          struct bnx2x_rx_mode_ramrod_params *p);
501 };
502
503 /********************** Set multicast group ***********************************/
504
505 struct bnx2x_mcast_list_elem {
506         struct list_head link;
507         uint8_t *mac;
508 };
509
510 union bnx2x_mcast_config_data {
511         uint8_t *mac;
512         uint8_t bin; /* used in a RESTORE flow */
513 };
514
515 struct bnx2x_mcast_ramrod_params {
516         struct bnx2x_mcast_obj *mcast_obj;
517
518         /* Relevant options are RAMROD_COMP_WAIT and RAMROD_DRV_CLR_ONLY */
519         unsigned long ramrod_flags;
520
521         struct list_head mcast_list; /* list of struct bnx2x_mcast_list_elem */
522         /** TODO:
523          *      - rename it to macs_num.
524          *      - Add a new command type for handling pending commands
525          *        (remove "zero semantics").
526          *
527          *  Length of mcast_list. If zero and ADD_CONT command - post
528          *  pending commands.
529          */
530         int mcast_list_len;
531 };
532
533 enum bnx2x_mcast_cmd {
534         BNX2X_MCAST_CMD_ADD,
535         BNX2X_MCAST_CMD_CONT,
536         BNX2X_MCAST_CMD_DEL,
537         BNX2X_MCAST_CMD_RESTORE,
538 };
539
540 struct bnx2x_mcast_obj {
541         struct bnx2x_raw_obj raw;
542
543         union {
544                 struct {
545                 #define BNX2X_MCAST_BINS_NUM    256
546                 #define BNX2X_MCAST_VEC_SZ      (BNX2X_MCAST_BINS_NUM / 64)
547                         uint64_t vec[BNX2X_MCAST_VEC_SZ];
548
549                         /** Number of BINs to clear. Should be updated
550                          *  immediately when a command arrives in order to
551                          *  properly create DEL commands.
552                          */
553                         int num_bins_set;
554                 } aprox_match;
555
556                 struct {
557                         struct list_head macs;
558                         int num_macs_set;
559                 } exact_match;
560         } registry;
561
562         /* Pending commands */
563         struct list_head pending_cmds_head;
564
565         /* A state that is set in raw.pstate, when there are pending commands */
566         int sched_state;
567
568         /* Maximal number of mcast MACs configured in one command */
569         int max_cmd_len;
570
571         /* Total number of currently pending MACs to configure: both
572          * in the pending commands list and in the current command.
573          */
574         int total_pending_num;
575
576         uint8_t engine_id;
577
578         /**
579          * @param cmd command to execute (BNX2X_MCAST_CMD_X, see above)
580          */
581         int (*config_mcast)(struct bnx2x *bp,
582                             struct bnx2x_mcast_ramrod_params *p,
583                             enum bnx2x_mcast_cmd cmd);
584
585         /**
586          * Fills the ramrod data during the RESTORE flow.
587          *
588          * @param bp
589          * @param o
590          * @param start_idx Registry index to start from
591          * @param rdata_idx Index in the ramrod data to start from
592          *
593          * @return -1 if we handled the whole registry or index of the last
594          *         handled registry element.
595          */
596         int (*hdl_restore)(struct bnx2x *bp, struct bnx2x_mcast_obj *o,
597                            int start_bin, int *rdata_idx);
598
599         int (*enqueue_cmd)(struct bnx2x *bp, struct bnx2x_mcast_obj *o,
600                            struct bnx2x_mcast_ramrod_params *p,
601                            enum bnx2x_mcast_cmd cmd);
602
603         void (*set_one_rule)(struct bnx2x *bp,
604                              struct bnx2x_mcast_obj *o, int idx,
605                              union bnx2x_mcast_config_data *cfg_data,
606                              enum bnx2x_mcast_cmd cmd);
607
608         /** Checks if there are more mcast MACs to be set or a previous
609          *  command is still pending.
610          */
611         bool (*check_pending)(struct bnx2x_mcast_obj *o);
612
613         /**
614          * Set/Clear/Check SCHEDULED state of the object
615          */
616         void (*set_sched)(struct bnx2x_mcast_obj *o);
617         void (*clear_sched)(struct bnx2x_mcast_obj *o);
618         bool (*check_sched)(struct bnx2x_mcast_obj *o);
619
620         /* Wait until all pending commands complete */
621         int (*wait_comp)(struct bnx2x *bp, struct bnx2x_mcast_obj *o);
622
623         /**
624          * Handle the internal object counters needed for proper
625          * commands handling. Checks that the provided parameters are
626          * feasible.
627          */
628         int (*validate)(struct bnx2x *bp,
629                         struct bnx2x_mcast_ramrod_params *p,
630                         enum bnx2x_mcast_cmd cmd);
631
632         /**
633          * Restore the values of internal counters in case of a failure.
634          */
635         void (*revert)(struct bnx2x *bp,
636                        struct bnx2x_mcast_ramrod_params *p,
637                        int old_num_bins);
638
639         int (*get_registry_size)(struct bnx2x_mcast_obj *o);
640         void (*set_registry_size)(struct bnx2x_mcast_obj *o, int n);
641 };
642
643 /*************************** Credit handling **********************************/
644 struct bnx2x_credit_pool_obj {
645
646         /* Current amount of credit in the pool */
647         atomic_t        credit;
648
649         /* Maximum allowed credit. put() will check against it. */
650         int             pool_sz;
651
652         /* Allocate a pool table statically.
653          *
654          * Currently the maximum allowed size is MAX_MAC_CREDIT_E2(272)
655          *
656          * The set bit in the table will mean that the entry is available.
657          */
658 #define BNX2X_POOL_VEC_SIZE     (MAX_MAC_CREDIT_E2 / 64)
659         uint64_t                pool_mirror[BNX2X_POOL_VEC_SIZE];
660
661         /* Base pool offset (initialized differently */
662         int             base_pool_offset;
663
664         /**
665          * Get the next free pool entry.
666          *
667          * @return true if there was a free entry in the pool
668          */
669         bool (*get_entry)(struct bnx2x_credit_pool_obj *o, int *entry);
670
671         /**
672          * Return the entry back to the pool.
673          *
674          * @return true if entry is legal and has been successfully
675          *         returned to the pool.
676          */
677         bool (*put_entry)(struct bnx2x_credit_pool_obj *o, int entry);
678
679         /**
680          * Get the requested amount of credit from the pool.
681          *
682          * @param cnt Amount of requested credit
683          * @return true if the operation is successful
684          */
685         bool (*get)(struct bnx2x_credit_pool_obj *o, int cnt);
686
687         /**
688          * Returns the credit to the pool.
689          *
690          * @param cnt Amount of credit to return
691          * @return true if the operation is successful
692          */
693         bool (*put)(struct bnx2x_credit_pool_obj *o, int cnt);
694
695         /**
696          * Reads the current amount of credit.
697          */
698         int (*check)(struct bnx2x_credit_pool_obj *o);
699 };
700
701 /*************************** RSS configuration ********************************/
702 enum {
703         /* RSS_MODE bits are mutually exclusive */
704         BNX2X_RSS_MODE_DISABLED,
705         BNX2X_RSS_MODE_REGULAR,
706
707         BNX2X_RSS_SET_SRCH, /* Setup searcher, E1x specific flag */
708
709         BNX2X_RSS_IPV4,
710         BNX2X_RSS_IPV4_TCP,
711         BNX2X_RSS_IPV4_UDP,
712         BNX2X_RSS_IPV6,
713         BNX2X_RSS_IPV6_TCP,
714         BNX2X_RSS_IPV6_UDP,
715         BNX2X_RSS_GRE_INNER_HDRS,
716 };
717
718 struct bnx2x_config_rss_params {
719         struct bnx2x_rss_config_obj *rss_obj;
720
721         /* may have RAMROD_COMP_WAIT set only */
722         unsigned long   ramrod_flags;
723
724         /* BNX2X_RSS_X bits */
725         unsigned long   rss_flags;
726
727         /* Number hash bits to take into an account */
728         uint8_t         rss_result_mask;
729
730         /* Indirection table */
731         uint8_t         ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
732
733         /* RSS hash values */
734         uint32_t                rss_key[10];
735
736         /* valid only iff BNX2X_RSS_UPDATE_TOE is set */
737         uint16_t                toe_rss_bitmap;
738 };
739
740 struct bnx2x_rss_config_obj {
741         struct bnx2x_raw_obj    raw;
742
743         /* RSS engine to use */
744         uint8_t                 engine_id;
745
746         /* Last configured indirection table */
747         uint8_t                 ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
748
749         /* flags for enabling 4-tupple hash on UDP */
750         uint8_t                 udp_rss_v4;
751         uint8_t                 udp_rss_v6;
752
753         int (*config_rss)(struct bnx2x *bp,
754                           struct bnx2x_config_rss_params *p);
755 };
756
757 /*********************** Queue state update ***********************************/
758
759 /* UPDATE command options */
760 enum {
761         BNX2X_Q_UPDATE_IN_VLAN_REM,
762         BNX2X_Q_UPDATE_IN_VLAN_REM_CHNG,
763         BNX2X_Q_UPDATE_OUT_VLAN_REM,
764         BNX2X_Q_UPDATE_OUT_VLAN_REM_CHNG,
765         BNX2X_Q_UPDATE_ANTI_SPOOF,
766         BNX2X_Q_UPDATE_ANTI_SPOOF_CHNG,
767         BNX2X_Q_UPDATE_ACTIVATE,
768         BNX2X_Q_UPDATE_ACTIVATE_CHNG,
769         BNX2X_Q_UPDATE_DEF_VLAN_EN,
770         BNX2X_Q_UPDATE_DEF_VLAN_EN_CHNG,
771         BNX2X_Q_UPDATE_SILENT_VLAN_REM_CHNG,
772         BNX2X_Q_UPDATE_SILENT_VLAN_REM,
773         BNX2X_Q_UPDATE_TX_SWITCHING_CHNG,
774         BNX2X_Q_UPDATE_TX_SWITCHING,
775         BNX2X_Q_UPDATE_PTP_PKTS_CHNG,
776         BNX2X_Q_UPDATE_PTP_PKTS,
777 };
778
779 /* Allowed Queue states */
780 enum bnx2x_q_state {
781         BNX2X_Q_STATE_RESET,
782         BNX2X_Q_STATE_INITIALIZED,
783         BNX2X_Q_STATE_ACTIVE,
784         BNX2X_Q_STATE_MULTI_COS,
785         BNX2X_Q_STATE_MCOS_TERMINATED,
786         BNX2X_Q_STATE_INACTIVE,
787         BNX2X_Q_STATE_STOPPED,
788         BNX2X_Q_STATE_TERMINATED,
789         BNX2X_Q_STATE_FLRED,
790         BNX2X_Q_STATE_MAX,
791 };
792
793 /* Allowed Queue states */
794 enum bnx2x_q_logical_state {
795         BNX2X_Q_LOGICAL_STATE_ACTIVE,
796         BNX2X_Q_LOGICAL_STATE_STOPPED,
797 };
798
799 /* Allowed commands */
800 enum bnx2x_queue_cmd {
801         BNX2X_Q_CMD_INIT,
802         BNX2X_Q_CMD_SETUP,
803         BNX2X_Q_CMD_SETUP_TX_ONLY,
804         BNX2X_Q_CMD_DEACTIVATE,
805         BNX2X_Q_CMD_ACTIVATE,
806         BNX2X_Q_CMD_UPDATE,
807         BNX2X_Q_CMD_UPDATE_TPA,
808         BNX2X_Q_CMD_HALT,
809         BNX2X_Q_CMD_CFC_DEL,
810         BNX2X_Q_CMD_TERMINATE,
811         BNX2X_Q_CMD_EMPTY,
812         BNX2X_Q_CMD_MAX,
813 };
814
815 /* queue SETUP + INIT flags */
816 enum {
817         BNX2X_Q_FLG_TPA,
818         BNX2X_Q_FLG_TPA_IPV6,
819         BNX2X_Q_FLG_TPA_GRO,
820         BNX2X_Q_FLG_STATS,
821         BNX2X_Q_FLG_ZERO_STATS,
822         BNX2X_Q_FLG_ACTIVE,
823         BNX2X_Q_FLG_OV,
824         BNX2X_Q_FLG_VLAN,
825         BNX2X_Q_FLG_COS,
826         BNX2X_Q_FLG_HC,
827         BNX2X_Q_FLG_HC_EN,
828         BNX2X_Q_FLG_DHC,
829         BNX2X_Q_FLG_FCOE,
830         BNX2X_Q_FLG_LEADING_RSS,
831         BNX2X_Q_FLG_MCAST,
832         BNX2X_Q_FLG_DEF_VLAN,
833         BNX2X_Q_FLG_TX_SWITCH,
834         BNX2X_Q_FLG_TX_SEC,
835         BNX2X_Q_FLG_ANTI_SPOOF,
836         BNX2X_Q_FLG_SILENT_VLAN_REM,
837         BNX2X_Q_FLG_FORCE_DEFAULT_PRI,
838         BNX2X_Q_FLG_REFUSE_OUTBAND_VLAN,
839         BNX2X_Q_FLG_PCSUM_ON_PKT,
840         BNX2X_Q_FLG_TUN_INC_INNER_IP_ID
841 };
842
843 /* Queue type options: queue type may be a combination of below. */
844 enum bnx2x_q_type {
845         /** TODO: Consider moving both these flags into the init()
846          *        ramrod params.
847          */
848         BNX2X_Q_TYPE_HAS_RX,
849         BNX2X_Q_TYPE_HAS_TX,
850 };
851
852 #define BNX2X_PRIMARY_CID_INDEX                 0
853 #define BNX2X_MULTI_TX_COS_E1X                  3 /* QM only */
854 #define BNX2X_MULTI_TX_COS_E2_E3A0              2
855 #define BNX2X_MULTI_TX_COS_E3B0                 3
856 #define BNX2X_MULTI_TX_COS                      3 /* Maximum possible */
857
858 #define MAC_PAD (ALIGN(Eaddrlen, sizeof(uint32_t)) - Eaddrlen)
859 /* DMAE channel to be used by FW for timesync workaroun. A driver that sends
860  * timesync-related ramrods must not use this DMAE command ID.
861  */
862 #define FW_DMAE_CMD_ID 6
863
864 struct bnx2x_queue_init_params {
865         struct {
866                 unsigned long   flags;
867                 uint16_t                hc_rate;
868                 uint8_t         fw_sb_id;
869                 uint8_t         sb_cq_index;
870         } tx;
871
872         struct {
873                 unsigned long   flags;
874                 uint16_t                hc_rate;
875                 uint8_t         fw_sb_id;
876                 uint8_t         sb_cq_index;
877         } rx;
878
879         /* CID context in the host memory */
880         struct eth_context *cxts[BNX2X_MULTI_TX_COS];
881
882         /* maximum number of cos supported by hardware */
883         uint8_t max_cos;
884 };
885
886 struct bnx2x_queue_terminate_params {
887         /* index within the tx_only cids of this queue object */
888         uint8_t cid_index;
889 };
890
891 struct bnx2x_queue_cfc_del_params {
892         /* index within the tx_only cids of this queue object */
893         uint8_t cid_index;
894 };
895
896 struct bnx2x_queue_update_params {
897         unsigned long   update_flags; /* BNX2X_Q_UPDATE_XX bits */
898         uint16_t                def_vlan;
899         uint16_t                silent_removal_value;
900         uint16_t                silent_removal_mask;
901 /* index within the tx_only cids of this queue object */
902         uint8_t         cid_index;
903 };
904
905 struct bnx2x_queue_update_tpa_params {
906         dma_addr_t sge_map;
907         uint8_t update_ipv4;
908         uint8_t update_ipv6;
909         uint8_t max_tpa_queues;
910         uint8_t max_sges_pkt;
911         uint8_t complete_on_both_clients;
912         uint8_t dont_verify_thr;
913         uint8_t tpa_mode;
914         uint8_t _pad;
915
916         uint16_t sge_buff_sz;
917         uint16_t max_agg_sz;
918
919         uint16_t sge_pause_thr_low;
920         uint16_t sge_pause_thr_high;
921 };
922
923 struct rxq_pause_params {
924         uint16_t                bd_th_lo;
925         uint16_t                bd_th_hi;
926         uint16_t                rcq_th_lo;
927         uint16_t                rcq_th_hi;
928         uint16_t                sge_th_lo; /* valid iff BNX2X_Q_FLG_TPA */
929         uint16_t                sge_th_hi; /* valid iff BNX2X_Q_FLG_TPA */
930         uint16_t                pri_map;
931 };
932
933 /* general */
934 struct bnx2x_general_setup_params {
935         /* valid iff BNX2X_Q_FLG_STATS */
936         uint8_t         stat_id;
937
938         uint8_t         spcl_id;
939         uint16_t                mtu;
940         uint8_t         cos;
941
942         uint8_t         fp_hsi;
943 };
944
945 struct bnx2x_rxq_setup_params {
946         /* dma */
947         dma_addr_t      dscr_map;
948         dma_addr_t      sge_map;
949         dma_addr_t      rcq_map;
950         dma_addr_t      rcq_np_map;
951
952         uint16_t                drop_flags;
953         uint16_t                buf_sz;
954         uint8_t         fw_sb_id;
955         uint8_t         cl_qzone_id;
956
957         /* valid iff BNX2X_Q_FLG_TPA */
958         uint16_t                tpa_agg_sz;
959         uint16_t                sge_buf_sz;
960         uint8_t         max_sges_pkt;
961         uint8_t         max_tpa_queues;
962         uint8_t         rss_engine_id;
963
964         /* valid iff BNX2X_Q_FLG_MCAST */
965         uint8_t         mcast_engine_id;
966
967         uint8_t         cache_line_log;
968
969         uint8_t         sb_cq_index;
970
971         /* valid iff BXN2X_Q_FLG_SILENT_VLAN_REM */
972         uint16_t silent_removal_value;
973         uint16_t silent_removal_mask;
974 };
975
976 struct bnx2x_txq_setup_params {
977         /* dma */
978         dma_addr_t      dscr_map;
979
980         uint8_t         fw_sb_id;
981         uint8_t         sb_cq_index;
982         uint8_t         cos;            /* valid iff BNX2X_Q_FLG_COS */
983         uint16_t                traffic_type;
984         /* equals to the leading rss client id, used for TX classification*/
985         uint8_t         tss_leading_cl_id;
986
987         /* valid iff BNX2X_Q_FLG_DEF_VLAN */
988         uint16_t                default_vlan;
989 };
990
991 struct bnx2x_queue_setup_params {
992         struct bnx2x_general_setup_params gen_params;
993         struct bnx2x_txq_setup_params txq_params;
994         struct bnx2x_rxq_setup_params rxq_params;
995         struct rxq_pause_params pause_params;
996         unsigned long flags;
997 };
998
999 struct bnx2x_queue_setup_tx_only_params {
1000         struct bnx2x_general_setup_params       gen_params;
1001         struct bnx2x_txq_setup_params           txq_params;
1002         unsigned long                           flags;
1003         /* index within the tx_only cids of this queue object */
1004         uint8_t                                 cid_index;
1005 };
1006
1007 struct bnx2x_queue_state_params {
1008         struct bnx2x_queue_sp_obj *q_obj;
1009
1010         /* Current command */
1011         enum bnx2x_queue_cmd cmd;
1012
1013         /* may have RAMROD_COMP_WAIT set only */
1014         unsigned long ramrod_flags;
1015
1016         /* Params according to the current command */
1017         union {
1018                 struct bnx2x_queue_update_params        update;
1019                 struct bnx2x_queue_update_tpa_params    update_tpa;
1020                 struct bnx2x_queue_setup_params         setup;
1021                 struct bnx2x_queue_init_params          init;
1022                 struct bnx2x_queue_setup_tx_only_params tx_only;
1023                 struct bnx2x_queue_terminate_params     terminate;
1024                 struct bnx2x_queue_cfc_del_params       cfc_del;
1025         } params;
1026 };
1027
1028 struct bnx2x_viflist_params {
1029         uint8_t echo_res;
1030         uint8_t func_bit_map_res;
1031 };
1032
1033 struct bnx2x_queue_sp_obj {
1034         uint32_t                cids[BNX2X_MULTI_TX_COS];
1035         uint8_t         cl_id;
1036         uint8_t         func_id;
1037
1038         /* number of traffic classes supported by queue.
1039          * The primary connection of the queue supports the first traffic
1040          * class. Any further traffic class is supported by a tx-only
1041          * connection.
1042          *
1043          * Therefore max_cos is also a number of valid entries in the cids
1044          * array.
1045          */
1046         uint8_t max_cos;
1047         uint8_t num_tx_only, next_tx_only;
1048
1049         enum bnx2x_q_state state, next_state;
1050
1051         /* bits from enum bnx2x_q_type */
1052         unsigned long   type;
1053
1054         /* BNX2X_Q_CMD_XX bits. This object implements "one
1055          * pending" paradigm but for debug and tracing purposes it's
1056          * more convenient to have different bits for different
1057          * commands.
1058          */
1059         unsigned long   pending;
1060
1061         /* Buffer to use as a ramrod data and its mapping */
1062         void            *rdata;
1063         dma_addr_t      rdata_mapping;
1064
1065         /**
1066          * Performs one state change according to the given parameters.
1067          *
1068          * @return 0 in case of success and negative value otherwise.
1069          */
1070         int (*send_cmd)(struct bnx2x *bp,
1071                         struct bnx2x_queue_state_params *params);
1072
1073         /**
1074          * Sets the pending bit according to the requested transition.
1075          */
1076         int (*set_pending)(struct bnx2x_queue_sp_obj *o,
1077                            struct bnx2x_queue_state_params *params);
1078
1079         /**
1080          * Checks that the requested state transition is legal.
1081          */
1082         int (*check_transition)(struct bnx2x *bp,
1083                                 struct bnx2x_queue_sp_obj *o,
1084                                 struct bnx2x_queue_state_params *params);
1085
1086         /**
1087          * Completes the pending command.
1088          */
1089         int (*complete_cmd)(struct bnx2x *bp,
1090                             struct bnx2x_queue_sp_obj *o,
1091                             enum bnx2x_queue_cmd);
1092
1093         int (*wait_comp)(struct bnx2x *bp,
1094                          struct bnx2x_queue_sp_obj *o,
1095                          enum bnx2x_queue_cmd cmd);
1096 };
1097
1098 /********************** Function state update *********************************/
1099
1100 /* UPDATE command options */
1101 enum {
1102         BNX2X_F_UPDATE_TX_SWITCH_SUSPEND_CHNG,
1103         BNX2X_F_UPDATE_TX_SWITCH_SUSPEND,
1104         BNX2X_F_UPDATE_SD_VLAN_TAG_CHNG,
1105         BNX2X_F_UPDATE_SD_VLAN_ETH_TYPE_CHNG,
1106         BNX2X_F_UPDATE_VLAN_FORCE_PRIO_CHNG,
1107         BNX2X_F_UPDATE_VLAN_FORCE_PRIO_FLAG,
1108         BNX2X_F_UPDATE_TUNNEL_CFG_CHNG,
1109         BNX2X_F_UPDATE_TUNNEL_CLSS_EN,
1110         BNX2X_F_UPDATE_TUNNEL_INNER_GRE_RSS_EN,
1111 };
1112
1113 /* Allowed Function states */
1114 enum bnx2x_func_state {
1115         BNX2X_F_STATE_RESET,
1116         BNX2X_F_STATE_INITIALIZED,
1117         BNX2X_F_STATE_STARTED,
1118         BNX2X_F_STATE_TX_STOPPED,
1119         BNX2X_F_STATE_MAX,
1120 };
1121
1122 /* Allowed Function commands */
1123 enum bnx2x_func_cmd {
1124         BNX2X_F_CMD_HW_INIT,
1125         BNX2X_F_CMD_START,
1126         BNX2X_F_CMD_STOP,
1127         BNX2X_F_CMD_HW_RESET,
1128         BNX2X_F_CMD_AFEX_UPDATE,
1129         BNX2X_F_CMD_AFEX_VIFLISTS,
1130         BNX2X_F_CMD_TX_STOP,
1131         BNX2X_F_CMD_TX_START,
1132         BNX2X_F_CMD_SWITCH_UPDATE,
1133         BNX2X_F_CMD_SET_TIMESYNC,
1134         BNX2X_F_CMD_MAX,
1135 };
1136
1137 struct bnx2x_func_hw_init_params {
1138         /* A load phase returned by MCP.
1139          *
1140          * May be:
1141          *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
1142          *              FW_MSG_CODE_DRV_LOAD_COMMON
1143          *              FW_MSG_CODE_DRV_LOAD_PORT
1144          *              FW_MSG_CODE_DRV_LOAD_FUNCTION
1145          */
1146         uint32_t load_phase;
1147 };
1148
1149 struct bnx2x_func_hw_reset_params {
1150         /* A load phase returned by MCP.
1151          *
1152          * May be:
1153          *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
1154          *              FW_MSG_CODE_DRV_LOAD_COMMON
1155          *              FW_MSG_CODE_DRV_LOAD_PORT
1156          *              FW_MSG_CODE_DRV_LOAD_FUNCTION
1157          */
1158         uint32_t reset_phase;
1159 };
1160
1161 struct bnx2x_func_start_params {
1162         /* Multi Function mode:
1163          *      - Single Function
1164          *      - Switch Dependent
1165          *      - Switch Independent
1166          */
1167         uint16_t mf_mode;
1168
1169         /* Switch Dependent mode outer VLAN tag */
1170         uint16_t sd_vlan_tag;
1171
1172         /* Function cos mode */
1173         uint8_t network_cos_mode;
1174
1175         /* TUNN_MODE_NONE/TUNN_MODE_VXLAN/TUNN_MODE_GRE */
1176         uint8_t tunnel_mode;
1177
1178         /* tunneling classification enablement */
1179         uint8_t tunn_clss_en;
1180
1181         /* NVGRE_TUNNEL/L2GRE_TUNNEL/IPGRE_TUNNEL */
1182         uint8_t gre_tunnel_type;
1183
1184         /* Enables Inner GRE RSS on the function, depends on the client RSS
1185          * capailities
1186          */
1187         uint8_t inner_gre_rss_en;
1188
1189         /* Allows accepting of packets failing MF classification, possibly
1190          * only matching a given ethertype
1191          */
1192         uint8_t class_fail;
1193         uint16_t class_fail_ethtype;
1194
1195         /* Override priority of output packets */
1196         uint8_t sd_vlan_force_pri;
1197         uint8_t sd_vlan_force_pri_val;
1198
1199         /* Replace vlan's ethertype */
1200         uint16_t sd_vlan_eth_type;
1201
1202         /* Prevent inner vlans from being added by FW */
1203         uint8_t no_added_tags;
1204 };
1205
1206 struct bnx2x_func_switch_update_params {
1207         unsigned long changes; /* BNX2X_F_UPDATE_XX bits */
1208         uint16_t vlan;
1209         uint16_t vlan_eth_type;
1210         uint8_t vlan_force_prio;
1211         uint8_t tunnel_mode;
1212         uint8_t gre_tunnel_type;
1213 };
1214
1215 struct bnx2x_func_afex_update_params {
1216         uint16_t vif_id;
1217         uint16_t afex_default_vlan;
1218         uint8_t allowed_priorities;
1219 };
1220
1221 struct bnx2x_func_afex_viflists_params {
1222         uint16_t vif_list_index;
1223         uint8_t func_bit_map;
1224         uint8_t afex_vif_list_command;
1225         uint8_t func_to_clear;
1226 };
1227
1228 struct bnx2x_func_tx_start_params {
1229         struct priority_cos traffic_type_to_priority_cos[MAX_TRAFFIC_TYPES];
1230         uint8_t dcb_enabled;
1231         uint8_t dcb_version;
1232         uint8_t dont_add_pri_0_en;
1233 };
1234
1235 struct bnx2x_func_set_timesync_params {
1236         /* Reset, set or keep the current drift value */
1237         uint8_t drift_adjust_cmd;
1238
1239         /* Dec, inc or keep the current offset */
1240         uint8_t offset_cmd;
1241
1242         /* Drift value direction */
1243         uint8_t add_sub_drift_adjust_value;
1244
1245         /* Drift, period and offset values to be used according to the commands
1246          * above.
1247          */
1248         uint8_t drift_adjust_value;
1249         uint32_t drift_adjust_period;
1250         uint64_t offset_delta;
1251 };
1252
1253 struct bnx2x_func_state_params {
1254         struct bnx2x_func_sp_obj *f_obj;
1255
1256         /* Current command */
1257         enum bnx2x_func_cmd cmd;
1258
1259         /* may have RAMROD_COMP_WAIT set only */
1260         unsigned long   ramrod_flags;
1261
1262         /* Params according to the current command */
1263         union {
1264                 struct bnx2x_func_hw_init_params hw_init;
1265                 struct bnx2x_func_hw_reset_params hw_reset;
1266                 struct bnx2x_func_start_params start;
1267                 struct bnx2x_func_switch_update_params switch_update;
1268                 struct bnx2x_func_afex_update_params afex_update;
1269                 struct bnx2x_func_afex_viflists_params afex_viflists;
1270                 struct bnx2x_func_tx_start_params tx_start;
1271                 struct bnx2x_func_set_timesync_params set_timesync;
1272         } params;
1273 };
1274
1275 struct bnx2x_func_sp_drv_ops {
1276         /* Init tool + runtime initialization:
1277          *      - Common Chip
1278          *      - Common (per Path)
1279          *      - Port
1280          *      - Function phases
1281          */
1282         int (*init_hw_cmn_chip)(struct bnx2x *bp);
1283         int (*init_hw_cmn)(struct bnx2x *bp);
1284         int (*init_hw_port)(struct bnx2x *bp);
1285         int (*init_hw_func)(struct bnx2x *bp);
1286
1287         /* Reset Function HW: Common, Port, Function phases. */
1288         void (*reset_hw_cmn)(struct bnx2x *bp);
1289         void (*reset_hw_port)(struct bnx2x *bp);
1290         void (*reset_hw_func)(struct bnx2x *bp);
1291
1292         /* Init/Free GUNZIP resources */
1293         int (*gunzip_init)(struct bnx2x *bp);
1294         void (*gunzip_end)(struct bnx2x *bp);
1295
1296         /* Prepare/Release FW resources */
1297         int (*init_fw)(struct bnx2x *bp);
1298         void (*release_fw)(struct bnx2x *bp);
1299 };
1300
1301 struct bnx2x_func_sp_obj {
1302         enum bnx2x_func_state   state, next_state;
1303
1304         /* BNX2X_FUNC_CMD_XX bits. This object implements "one
1305          * pending" paradigm but for debug and tracing purposes it's
1306          * more convenient to have different bits for different
1307          * commands.
1308          */
1309         unsigned long           pending;
1310
1311         /* Buffer to use as a ramrod data and its mapping */
1312         void                    *rdata;
1313         dma_addr_t              rdata_mapping;
1314
1315         /* Buffer to use as a afex ramrod data and its mapping.
1316          * This can't be same rdata as above because afex ramrod requests
1317          * can arrive to the object in parallel to other ramrod requests.
1318          */
1319         void                    *afex_rdata;
1320         dma_addr_t              afex_rdata_mapping;
1321
1322         /* this mutex validates that when pending flag is taken, the next
1323          * ramrod to be sent will be the one set the pending bit
1324          */
1325         qlock_t         one_pending_mutex;
1326
1327         /* Driver interface */
1328         struct bnx2x_func_sp_drv_ops    *drv;
1329
1330         /**
1331          * Performs one state change according to the given parameters.
1332          *
1333          * @return 0 in case of success and negative value otherwise.
1334          */
1335         int (*send_cmd)(struct bnx2x *bp,
1336                         struct bnx2x_func_state_params *params);
1337
1338         /**
1339          * Checks that the requested state transition is legal.
1340          */
1341         int (*check_transition)(struct bnx2x *bp,
1342                                 struct bnx2x_func_sp_obj *o,
1343                                 struct bnx2x_func_state_params *params);
1344
1345         /**
1346          * Completes the pending command.
1347          */
1348         int (*complete_cmd)(struct bnx2x *bp,
1349                             struct bnx2x_func_sp_obj *o,
1350                             enum bnx2x_func_cmd cmd);
1351
1352         int (*wait_comp)(struct bnx2x *bp, struct bnx2x_func_sp_obj *o,
1353                          enum bnx2x_func_cmd cmd);
1354 };
1355
1356 /********************** Interfaces ********************************************/
1357 /* Queueable objects set */
1358 union bnx2x_qable_obj {
1359         struct bnx2x_vlan_mac_obj vlan_mac;
1360 };
1361 /************** Function state update *********/
1362 void bnx2x_init_func_obj(struct bnx2x *bp,
1363                          struct bnx2x_func_sp_obj *obj,
1364                          void *rdata, dma_addr_t rdata_mapping,
1365                          void *afex_rdata, dma_addr_t afex_rdata_mapping,
1366                          struct bnx2x_func_sp_drv_ops *drv_iface);
1367
1368 int bnx2x_func_state_change(struct bnx2x *bp,
1369                             struct bnx2x_func_state_params *params);
1370
1371 enum bnx2x_func_state bnx2x_func_get_state(struct bnx2x *bp,
1372                                            struct bnx2x_func_sp_obj *o);
1373 /******************* Queue State **************/
1374 void bnx2x_init_queue_obj(struct bnx2x *bp,
1375                           struct bnx2x_queue_sp_obj *obj, uint8_t cl_id,
1376                           uint32_t *cids,
1377                           uint8_t cid_cnt, uint8_t func_id, void *rdata,
1378                           dma_addr_t rdata_mapping, unsigned long type);
1379
1380 int bnx2x_queue_state_change(struct bnx2x *bp,
1381                              struct bnx2x_queue_state_params *params);
1382
1383 int bnx2x_get_q_logical_state(struct bnx2x *bp,
1384                                struct bnx2x_queue_sp_obj *obj);
1385
1386 /********************* VLAN-MAC ****************/
1387 void bnx2x_init_mac_obj(struct bnx2x *bp,
1388                         struct bnx2x_vlan_mac_obj *mac_obj,
1389                         uint8_t cl_id, uint32_t cid, uint8_t func_id,
1390                         void *rdata,
1391                         dma_addr_t rdata_mapping, int state,
1392                         unsigned long *pstate, bnx2x_obj_type type,
1393                         struct bnx2x_credit_pool_obj *macs_pool);
1394
1395 void bnx2x_init_vlan_obj(struct bnx2x *bp,
1396                          struct bnx2x_vlan_mac_obj *vlan_obj,
1397                          uint8_t cl_id, uint32_t cid, uint8_t func_id,
1398                          void *rdata,
1399                          dma_addr_t rdata_mapping, int state,
1400                          unsigned long *pstate, bnx2x_obj_type type,
1401                          struct bnx2x_credit_pool_obj *vlans_pool);
1402
1403 int bnx2x_vlan_mac_h_read_lock(struct bnx2x *bp,
1404                                         struct bnx2x_vlan_mac_obj *o);
1405 void bnx2x_vlan_mac_h_read_unlock(struct bnx2x *bp,
1406                                   struct bnx2x_vlan_mac_obj *o);
1407 int bnx2x_vlan_mac_h_write_lock(struct bnx2x *bp,
1408                                 struct bnx2x_vlan_mac_obj *o);
1409 int bnx2x_config_vlan_mac(struct bnx2x *bp,
1410                            struct bnx2x_vlan_mac_ramrod_params *p);
1411
1412 int bnx2x_vlan_mac_move(struct bnx2x *bp,
1413                         struct bnx2x_vlan_mac_ramrod_params *p,
1414                         struct bnx2x_vlan_mac_obj *dest_o);
1415
1416 /********************* RX MODE ****************/
1417
1418 void bnx2x_init_rx_mode_obj(struct bnx2x *bp,
1419                             struct bnx2x_rx_mode_obj *o);
1420
1421 /**
1422  * bnx2x_config_rx_mode - Send and RX_MODE ramrod according to the provided parameters.
1423  *
1424  * @p: Command parameters
1425  *
1426  * Return: 0 - if operation was successful and there is no pending completions,
1427  *         positive number - if there are pending completions,
1428  *         negative - if there were errors
1429  */
1430 int bnx2x_config_rx_mode(struct bnx2x *bp,
1431                          struct bnx2x_rx_mode_ramrod_params *p);
1432
1433 /****************** MULTICASTS ****************/
1434
1435 void bnx2x_init_mcast_obj(struct bnx2x *bp,
1436                           struct bnx2x_mcast_obj *mcast_obj,
1437                           uint8_t mcast_cl_id, uint32_t mcast_cid,
1438                           uint8_t func_id,
1439                           uint8_t engine_id, void *rdata,
1440                           dma_addr_t rdata_mapping,
1441                           int state, unsigned long *pstate,
1442                           bnx2x_obj_type type);
1443
1444 /**
1445  * bnx2x_config_mcast - Configure multicast MACs list.
1446  *
1447  * @cmd: command to execute: BNX2X_MCAST_CMD_X
1448  *
1449  * May configure a new list
1450  * provided in p->mcast_list (BNX2X_MCAST_CMD_ADD), clean up
1451  * (BNX2X_MCAST_CMD_DEL) or restore (BNX2X_MCAST_CMD_RESTORE) a current
1452  * configuration, continue to execute the pending commands
1453  * (BNX2X_MCAST_CMD_CONT).
1454  *
1455  * If previous command is still pending or if number of MACs to
1456  * configure is more that maximum number of MACs in one command,
1457  * the current command will be enqueued to the tail of the
1458  * pending commands list.
1459  *
1460  * Return: 0 is operation was successful and there are no pending completions,
1461  *         negative if there were errors, positive if there are pending
1462  *         completions.
1463  */
1464 int bnx2x_config_mcast(struct bnx2x *bp,
1465                        struct bnx2x_mcast_ramrod_params *p,
1466                        enum bnx2x_mcast_cmd cmd);
1467
1468 /****************** CREDIT POOL ****************/
1469 void bnx2x_init_mac_credit_pool(struct bnx2x *bp,
1470                                 struct bnx2x_credit_pool_obj *p,
1471                                 uint8_t func_id,
1472                                 uint8_t func_num);
1473 void bnx2x_init_vlan_credit_pool(struct bnx2x *bp,
1474                                  struct bnx2x_credit_pool_obj *p,
1475                                  uint8_t func_id,
1476                                  uint8_t func_num);
1477
1478 /****************** RSS CONFIGURATION ****************/
1479 void bnx2x_init_rss_config_obj(struct bnx2x *bp,
1480                                struct bnx2x_rss_config_obj *rss_obj,
1481                                uint8_t cl_id, uint32_t cid, uint8_t func_id,
1482                                uint8_t engine_id,
1483                                void *rdata, dma_addr_t rdata_mapping,
1484                                int state, unsigned long *pstate,
1485                                bnx2x_obj_type type);
1486
1487 /**
1488  * bnx2x_config_rss - Updates RSS configuration according to provided parameters
1489  *
1490  * Return: 0 in case of success
1491  */
1492 int bnx2x_config_rss(struct bnx2x *bp,
1493                      struct bnx2x_config_rss_params *p);
1494
1495 /**
1496  * bnx2x_get_rss_ind_table - Return the current ind_table configuration.
1497  *
1498  * @ind_table: buffer to fill with the current indirection
1499  *                  table content. Should be at least
1500  *                  T_ETH_INDIRECTION_TABLE_SIZE bytes long.
1501  */
1502 void bnx2x_get_rss_ind_table(struct bnx2x_rss_config_obj *rss_obj,
1503                              uint8_t *ind_table);
1504
1505 #endif /* BNX2X_SP_VERBS */