Bit ops
[akaros.git] / kern / drivers / net / bxe / bxe.c
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 //__FBSDID("$FreeBSD: head/sys/dev/bxe/bxe.c 275358 2014-12-01 11:45:24Z hselasky $");
28
29 #define BXE_DRIVER_VERSION "1.78.78"
30
31 #include "bxe.h"
32 #include "ecore_sp.h"
33 #include "ecore_init.h"
34 #include "ecore_init_ops.h"
35
36 #include "57710_int_offsets.h"
37 #include "57711_int_offsets.h"
38 #include "57712_int_offsets.h"
39
40 /*
41  * CTLTYPE_U64 and sysctl_handle_64 were added in r217616. Define these
42  * explicitly here for older kernels that don't include this changeset.
43  */
44 #ifndef CTLTYPE_U64
45 #define CTLTYPE_U64      CTLTYPE_QUAD
46 #define sysctl_handle_64 sysctl_handle_quad
47 #endif
48
49 /*
50  * CSUM_TCP_IPV6 and CSUM_UDP_IPV6 were added in r236170. Define these
51  * here as zero(0) for older kernels that don't include this changeset
52  * thereby masking the functionality.
53  */
54 #ifndef CSUM_TCP_IPV6
55 #define CSUM_TCP_IPV6 0
56 #define CSUM_UDP_IPV6 0
57 #endif
58
59 #define BXE_DEF_SB_ATT_IDX 0x0001
60 #define BXE_DEF_SB_IDX     0x0002
61
62 /*
63  * FLR Support - bxe_pf_flr_clnup() is called during nic_load in the per
64  * function HW initialization.
65  */
66 #define FLR_WAIT_USEC     10000 /* 10 msecs */
67 #define FLR_WAIT_INTERVAL 50    /* usecs */
68 #define FLR_POLL_CNT      (FLR_WAIT_USEC / FLR_WAIT_INTERVAL) /* 200 */
69
70 struct pbf_pN_buf_regs {
71     int pN;
72     uint32_t init_crd;
73     uint32_t crd;
74     uint32_t crd_freed;
75 };
76
77 struct pbf_pN_cmd_regs {
78     int pN;
79     uint32_t lines_occup;
80     uint32_t lines_freed;
81 };
82
83 /*
84  * PCI Device ID Table used by bxe_probe().
85  */
86 #define BXE_DEVDESC_MAX 64
87 static struct bxe_device_type bxe_devs[] = {
88     {
89         BRCM_VENDORID,
90         CHIP_NUM_57710,
91         PCI_ANY_ID, PCI_ANY_ID,
92         "QLogic NetXtreme II BCM57710 10GbE"
93     },
94     {
95         BRCM_VENDORID,
96         CHIP_NUM_57711,
97         PCI_ANY_ID, PCI_ANY_ID,
98         "QLogic NetXtreme II BCM57711 10GbE"
99     },
100     {
101         BRCM_VENDORID,
102         CHIP_NUM_57711E,
103         PCI_ANY_ID, PCI_ANY_ID,
104         "QLogic NetXtreme II BCM57711E 10GbE"
105     },
106     {
107         BRCM_VENDORID,
108         CHIP_NUM_57712,
109         PCI_ANY_ID, PCI_ANY_ID,
110         "QLogic NetXtreme II BCM57712 10GbE"
111     },
112     {
113         BRCM_VENDORID,
114         CHIP_NUM_57712_MF,
115         PCI_ANY_ID, PCI_ANY_ID,
116         "QLogic NetXtreme II BCM57712 MF 10GbE"
117     },
118 #if 0
119     {
120         BRCM_VENDORID,
121         CHIP_NUM_57712_VF,
122         PCI_ANY_ID, PCI_ANY_ID,
123         "QLogic NetXtreme II BCM57712 VF 10GbE"
124     },
125 #endif
126     {
127         BRCM_VENDORID,
128         CHIP_NUM_57800,
129         PCI_ANY_ID, PCI_ANY_ID,
130         "QLogic NetXtreme II BCM57800 10GbE"
131     },
132     {
133         BRCM_VENDORID,
134         CHIP_NUM_57800_MF,
135         PCI_ANY_ID, PCI_ANY_ID,
136         "QLogic NetXtreme II BCM57800 MF 10GbE"
137     },
138 #if 0
139     {
140         BRCM_VENDORID,
141         CHIP_NUM_57800_VF,
142         PCI_ANY_ID, PCI_ANY_ID,
143         "QLogic NetXtreme II BCM57800 VF 10GbE"
144     },
145 #endif
146     {
147         BRCM_VENDORID,
148         CHIP_NUM_57810,
149         PCI_ANY_ID, PCI_ANY_ID,
150         "QLogic NetXtreme II BCM57810 10GbE"
151     },
152     {
153         BRCM_VENDORID,
154         CHIP_NUM_57810_MF,
155         PCI_ANY_ID, PCI_ANY_ID,
156         "QLogic NetXtreme II BCM57810 MF 10GbE"
157     },
158 #if 0
159     {
160         BRCM_VENDORID,
161         CHIP_NUM_57810_VF,
162         PCI_ANY_ID, PCI_ANY_ID,
163         "QLogic NetXtreme II BCM57810 VF 10GbE"
164     },
165 #endif
166     {
167         BRCM_VENDORID,
168         CHIP_NUM_57811,
169         PCI_ANY_ID, PCI_ANY_ID,
170         "QLogic NetXtreme II BCM57811 10GbE"
171     },
172     {
173         BRCM_VENDORID,
174         CHIP_NUM_57811_MF,
175         PCI_ANY_ID, PCI_ANY_ID,
176         "QLogic NetXtreme II BCM57811 MF 10GbE"
177     },
178 #if 0
179     {
180         BRCM_VENDORID,
181         CHIP_NUM_57811_VF,
182         PCI_ANY_ID, PCI_ANY_ID,
183         "QLogic NetXtreme II BCM57811 VF 10GbE"
184     },
185 #endif
186     {
187         BRCM_VENDORID,
188         CHIP_NUM_57840_4_10,
189         PCI_ANY_ID, PCI_ANY_ID,
190         "QLogic NetXtreme II BCM57840 4x10GbE"
191     },
192 #if 0
193     {
194         BRCM_VENDORID,
195         CHIP_NUM_57840_2_20,
196         PCI_ANY_ID, PCI_ANY_ID,
197         "QLogic NetXtreme II BCM57840 2x20GbE"
198     },
199 #endif
200     {
201         BRCM_VENDORID,
202         CHIP_NUM_57840_MF,
203         PCI_ANY_ID, PCI_ANY_ID,
204         "QLogic NetXtreme II BCM57840 MF 10GbE"
205     },
206 #if 0
207     {
208         BRCM_VENDORID,
209         CHIP_NUM_57840_VF,
210         PCI_ANY_ID, PCI_ANY_ID,
211         "QLogic NetXtreme II BCM57840 VF 10GbE"
212     },
213 #endif
214     {
215         0, 0, 0, 0, NULL
216     }
217 };
218
219 #warning "MALLOC_DECLARE?"
220 //MALLOC_DECLARE(M_BXE_ILT);
221 //MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
222
223 #if 0
224 /*
225  * FreeBSD device entry points.
226  */
227 static int bxe_probe(device_t);
228 static int bxe_attach(device_t);
229 static int bxe_detach(device_t);
230 static int bxe_shutdown(device_t);
231
232 /*
233  * FreeBSD KLD module/device interface event handler method.
234  */
235 static device_method_t bxe_methods[] = {
236     /* Device interface (device_if.h) */
237     DEVMETHOD(device_probe,     bxe_probe),
238     DEVMETHOD(device_attach,    bxe_attach),
239     DEVMETHOD(device_detach,    bxe_detach),
240     DEVMETHOD(device_shutdown,  bxe_shutdown),
241 #if 0
242     DEVMETHOD(device_suspend,   bxe_suspend),
243     DEVMETHOD(device_resume,    bxe_resume),
244 #endif
245     /* Bus interface (bus_if.h) */
246     DEVMETHOD(bus_print_child,  bus_generic_print_child),
247     DEVMETHOD(bus_driver_added, bus_generic_driver_added),
248     KOBJMETHOD_END
249 };
250
251 #endif
252 //MTX_SYSINIT(bxe_prev_mtx, &bxe_prev_mtx, "bxe_prev_lock", MTX_DEF);
253 struct bxe_prev_list_node {
254     LIST_ENTRY(bxe_prev_list_node) node;
255     uint8_t bus;
256     uint8_t slot;
257     uint8_t path;
258     uint8_t aer; /* XXX automatic error recovery */
259     uint8_t undi;
260 };
261 //static LIST_HEAD(, bxe_prev_list_node) bxe_prev_list = LIST_HEAD_INITIALIZER(bxe_prev_list);
262
263 /* Tunable device values... */
264
265 //SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD, 0, "bxe driver parameters");
266
267 /* Debug */
268 unsigned long bxe_debug = 0;
269 //SYSCTL_ULONG(_hw_bxe, OID_AUTO, debug, CTLFLAG_RDTUN,
270 //             &bxe_debug, 0, "Debug logging mode");
271
272 /* Interrupt Mode: 0 (IRQ), 1 (MSI/IRQ), and 2 (MSI-X/MSI/IRQ) */
273 static int bxe_interrupt_mode = INTR_MODE_MSIX;
274 //SYSCTL_INT(_hw_bxe, OID_AUTO, interrupt_mode, CTLFLAG_RDTUN,
275 //           &bxe_interrupt_mode, 0, "Interrupt (MSI-X/MSI/INTx) mode");
276
277 /* Number of Queues: 0 (Auto) or 1 to 16 (fixed queue number) */
278 static int bxe_queue_count = 4;
279 //SYSCTL_INT(_hw_bxe, OID_AUTO, queue_count, CTLFLAG_RDTUN,
280 //           &bxe_queue_count, 0, "Multi-Queue queue count");
281
282 /* max number of buffers per queue (default RX_BD_USABLE) */
283 static int bxe_max_rx_bufs = 0;
284 //SYSCTL_INT(_hw_bxe, OID_AUTO, max_rx_bufs, CTLFLAG_RDTUN,
285 //           &bxe_max_rx_bufs, 0, "Maximum Number of Rx Buffers Per Queue");
286
287 /* Host interrupt coalescing RX tick timer (usecs) */
288 static int bxe_hc_rx_ticks = 25;
289 //SYSCTL_INT(_hw_bxe, OID_AUTO, hc_rx_ticks, CTLFLAG_RDTUN,
290 //           &bxe_hc_rx_ticks, 0, "Host Coalescing Rx ticks");
291
292 /* Host interrupt coalescing TX tick timer (usecs) */
293 static int bxe_hc_tx_ticks = 50;
294 //SYSCTL_INT(_hw_bxe, OID_AUTO, hc_tx_ticks, CTLFLAG_RDTUN,
295 //           &bxe_hc_tx_ticks, 0, "Host Coalescing Tx ticks");
296
297 /* Maximum number of Rx packets to process at a time */
298 static int bxe_rx_budget = 0xffffffff;
299 //SYSCTL_INT(_hw_bxe, OID_AUTO, rx_budget, CTLFLAG_TUN,
300 //           &bxe_rx_budget, 0, "Rx processing budget");
301
302 /* Maximum LRO aggregation size */
303 static int bxe_max_aggregation_size = 0;
304 //SYSCTL_INT(_hw_bxe, OID_AUTO, max_aggregation_size, CTLFLAG_TUN,
305 //           &bxe_max_aggregation_size, 0, "max aggregation size");
306
307 /* PCI MRRS: -1 (Auto), 0 (128B), 1 (256B), 2 (512B), 3 (1KB) */
308 static int bxe_mrrs = -1;
309 //SYSCTL_INT(_hw_bxe, OID_AUTO, mrrs, CTLFLAG_RDTUN,
310 //           &bxe_mrrs, 0, "PCIe maximum read request size");
311
312 /* AutoGrEEEn: 0 (hardware default), 1 (force on), 2 (force off) */
313 static int bxe_autogreeen = 0;
314 //SYSCTL_INT(_hw_bxe, OID_AUTO, autogreeen, CTLFLAG_RDTUN,
315 //           &bxe_autogreeen, 0, "AutoGrEEEn support");
316
317 /* 4-tuple RSS support for UDP: 0 (disabled), 1 (enabled) */
318 static int bxe_udp_rss = 0;
319 //SYSCTL_INT(_hw_bxe, OID_AUTO, udp_rss, CTLFLAG_RDTUN,
320 //           &bxe_udp_rss, 0, "UDP RSS support");
321
322 #define STAT_NAME_LEN 32 /* no stat names below can be longer than this */
323
324 #define STATS_OFFSET32(stat_name)                   \
325     (offsetof(struct bxe_eth_stats, stat_name) / 4)
326
327 #define Q_STATS_OFFSET32(stat_name)                   \
328     (offsetof(struct bxe_eth_q_stats, stat_name) / 4)
329
330 static const struct {
331     uint32_t offset;
332     uint32_t size;
333     uint32_t flags;
334 #define STATS_FLAGS_PORT  1
335 #define STATS_FLAGS_FUNC  2 /* MF only cares about function stats */
336 #define STATS_FLAGS_BOTH  (STATS_FLAGS_FUNC | STATS_FLAGS_PORT)
337     char string[STAT_NAME_LEN];
338 } bxe_eth_stats_arr[] = {
339     { STATS_OFFSET32(total_bytes_received_hi),
340                 8, STATS_FLAGS_BOTH, "rx_bytes" },
341     { STATS_OFFSET32(error_bytes_received_hi),
342                 8, STATS_FLAGS_BOTH, "rx_error_bytes" },
343     { STATS_OFFSET32(total_unicast_packets_received_hi),
344                 8, STATS_FLAGS_BOTH, "rx_ucast_packets" },
345     { STATS_OFFSET32(total_multicast_packets_received_hi),
346                 8, STATS_FLAGS_BOTH, "rx_mcast_packets" },
347     { STATS_OFFSET32(total_broadcast_packets_received_hi),
348                 8, STATS_FLAGS_BOTH, "rx_bcast_packets" },
349     { STATS_OFFSET32(rx_stat_dot3statsfcserrors_hi),
350                 8, STATS_FLAGS_PORT, "rx_crc_errors" },
351     { STATS_OFFSET32(rx_stat_dot3statsalignmenterrors_hi),
352                 8, STATS_FLAGS_PORT, "rx_align_errors" },
353     { STATS_OFFSET32(rx_stat_etherstatsundersizepkts_hi),
354                 8, STATS_FLAGS_PORT, "rx_undersize_packets" },
355     { STATS_OFFSET32(etherstatsoverrsizepkts_hi),
356                 8, STATS_FLAGS_PORT, "rx_oversize_packets" },
357     { STATS_OFFSET32(rx_stat_etherstatsfragments_hi),
358                 8, STATS_FLAGS_PORT, "rx_fragments" },
359     { STATS_OFFSET32(rx_stat_etherstatsjabbers_hi),
360                 8, STATS_FLAGS_PORT, "rx_jabbers" },
361     { STATS_OFFSET32(no_buff_discard_hi),
362                 8, STATS_FLAGS_BOTH, "rx_discards" },
363     { STATS_OFFSET32(mac_filter_discard),
364                 4, STATS_FLAGS_PORT, "rx_filtered_packets" },
365     { STATS_OFFSET32(mf_tag_discard),
366                 4, STATS_FLAGS_PORT, "rx_mf_tag_discard" },
367     { STATS_OFFSET32(pfc_frames_received_hi),
368                 8, STATS_FLAGS_PORT, "pfc_frames_received" },
369     { STATS_OFFSET32(pfc_frames_sent_hi),
370                 8, STATS_FLAGS_PORT, "pfc_frames_sent" },
371     { STATS_OFFSET32(brb_drop_hi),
372                 8, STATS_FLAGS_PORT, "rx_brb_discard" },
373     { STATS_OFFSET32(brb_truncate_hi),
374                 8, STATS_FLAGS_PORT, "rx_brb_truncate" },
375     { STATS_OFFSET32(pause_frames_received_hi),
376                 8, STATS_FLAGS_PORT, "rx_pause_frames" },
377     { STATS_OFFSET32(rx_stat_maccontrolframesreceived_hi),
378                 8, STATS_FLAGS_PORT, "rx_mac_ctrl_frames" },
379     { STATS_OFFSET32(nig_timer_max),
380                 4, STATS_FLAGS_PORT, "rx_constant_pause_events" },
381     { STATS_OFFSET32(total_bytes_transmitted_hi),
382                 8, STATS_FLAGS_BOTH, "tx_bytes" },
383     { STATS_OFFSET32(tx_stat_ifhcoutbadoctets_hi),
384                 8, STATS_FLAGS_PORT, "tx_error_bytes" },
385     { STATS_OFFSET32(total_unicast_packets_transmitted_hi),
386                 8, STATS_FLAGS_BOTH, "tx_ucast_packets" },
387     { STATS_OFFSET32(total_multicast_packets_transmitted_hi),
388                 8, STATS_FLAGS_BOTH, "tx_mcast_packets" },
389     { STATS_OFFSET32(total_broadcast_packets_transmitted_hi),
390                 8, STATS_FLAGS_BOTH, "tx_bcast_packets" },
391     { STATS_OFFSET32(tx_stat_dot3statsinternalmactransmiterrors_hi),
392                 8, STATS_FLAGS_PORT, "tx_mac_errors" },
393     { STATS_OFFSET32(rx_stat_dot3statscarriersenseerrors_hi),
394                 8, STATS_FLAGS_PORT, "tx_carrier_errors" },
395     { STATS_OFFSET32(tx_stat_dot3statssinglecollisionframes_hi),
396                 8, STATS_FLAGS_PORT, "tx_single_collisions" },
397     { STATS_OFFSET32(tx_stat_dot3statsmultiplecollisionframes_hi),
398                 8, STATS_FLAGS_PORT, "tx_multi_collisions" },
399     { STATS_OFFSET32(tx_stat_dot3statsdeferredtransmissions_hi),
400                 8, STATS_FLAGS_PORT, "tx_deferred" },
401     { STATS_OFFSET32(tx_stat_dot3statsexcessivecollisions_hi),
402                 8, STATS_FLAGS_PORT, "tx_excess_collisions" },
403     { STATS_OFFSET32(tx_stat_dot3statslatecollisions_hi),
404                 8, STATS_FLAGS_PORT, "tx_late_collisions" },
405     { STATS_OFFSET32(tx_stat_etherstatscollisions_hi),
406                 8, STATS_FLAGS_PORT, "tx_total_collisions" },
407     { STATS_OFFSET32(tx_stat_etherstatspkts64octets_hi),
408                 8, STATS_FLAGS_PORT, "tx_64_byte_packets" },
409     { STATS_OFFSET32(tx_stat_etherstatspkts65octetsto127octets_hi),
410                 8, STATS_FLAGS_PORT, "tx_65_to_127_byte_packets" },
411     { STATS_OFFSET32(tx_stat_etherstatspkts128octetsto255octets_hi),
412                 8, STATS_FLAGS_PORT, "tx_128_to_255_byte_packets" },
413     { STATS_OFFSET32(tx_stat_etherstatspkts256octetsto511octets_hi),
414                 8, STATS_FLAGS_PORT, "tx_256_to_511_byte_packets" },
415     { STATS_OFFSET32(tx_stat_etherstatspkts512octetsto1023octets_hi),
416                 8, STATS_FLAGS_PORT, "tx_512_to_1023_byte_packets" },
417     { STATS_OFFSET32(etherstatspkts1024octetsto1522octets_hi),
418                 8, STATS_FLAGS_PORT, "tx_1024_to_1522_byte_packets" },
419     { STATS_OFFSET32(etherstatspktsover1522octets_hi),
420                 8, STATS_FLAGS_PORT, "tx_1523_to_9022_byte_packets" },
421     { STATS_OFFSET32(pause_frames_sent_hi),
422                 8, STATS_FLAGS_PORT, "tx_pause_frames" },
423     { STATS_OFFSET32(total_tpa_aggregations_hi),
424                 8, STATS_FLAGS_FUNC, "tpa_aggregations" },
425     { STATS_OFFSET32(total_tpa_aggregated_frames_hi),
426                 8, STATS_FLAGS_FUNC, "tpa_aggregated_frames"},
427     { STATS_OFFSET32(total_tpa_bytes_hi),
428                 8, STATS_FLAGS_FUNC, "tpa_bytes"},
429 #if 0
430     { STATS_OFFSET32(recoverable_error),
431                 4, STATS_FLAGS_FUNC, "recoverable_errors" },
432     { STATS_OFFSET32(unrecoverable_error),
433                 4, STATS_FLAGS_FUNC, "unrecoverable_errors" },
434 #endif
435     { STATS_OFFSET32(eee_tx_lpi),
436                 4, STATS_FLAGS_PORT, "eee_tx_lpi"},
437     { STATS_OFFSET32(rx_calls),
438                 4, STATS_FLAGS_FUNC, "rx_calls"},
439     { STATS_OFFSET32(rx_pkts),
440                 4, STATS_FLAGS_FUNC, "rx_pkts"},
441     { STATS_OFFSET32(rx_tpa_pkts),
442                 4, STATS_FLAGS_FUNC, "rx_tpa_pkts"},
443     { STATS_OFFSET32(rx_soft_errors),
444                 4, STATS_FLAGS_FUNC, "rx_soft_errors"},
445     { STATS_OFFSET32(rx_hw_csum_errors),
446                 4, STATS_FLAGS_FUNC, "rx_hw_csum_errors"},
447     { STATS_OFFSET32(rx_ofld_frames_csum_ip),
448                 4, STATS_FLAGS_FUNC, "rx_ofld_frames_csum_ip"},
449     { STATS_OFFSET32(rx_ofld_frames_csum_tcp_udp),
450                 4, STATS_FLAGS_FUNC, "rx_ofld_frames_csum_tcp_udp"},
451     { STATS_OFFSET32(rx_budget_reached),
452                 4, STATS_FLAGS_FUNC, "rx_budget_reached"},
453     { STATS_OFFSET32(tx_pkts),
454                 4, STATS_FLAGS_FUNC, "tx_pkts"},
455     { STATS_OFFSET32(tx_soft_errors),
456                 4, STATS_FLAGS_FUNC, "tx_soft_errors"},
457     { STATS_OFFSET32(tx_ofld_frames_csum_ip),
458                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_ip"},
459     { STATS_OFFSET32(tx_ofld_frames_csum_tcp),
460                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_tcp"},
461     { STATS_OFFSET32(tx_ofld_frames_csum_udp),
462                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_udp"},
463     { STATS_OFFSET32(tx_ofld_frames_lso),
464                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_lso"},
465     { STATS_OFFSET32(tx_ofld_frames_lso_hdr_splits),
466                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_lso_hdr_splits"},
467     { STATS_OFFSET32(tx_encap_failures),
468                 4, STATS_FLAGS_FUNC, "tx_encap_failures"},
469     { STATS_OFFSET32(tx_hw_queue_full),
470                 4, STATS_FLAGS_FUNC, "tx_hw_queue_full"},
471     { STATS_OFFSET32(tx_hw_max_queue_depth),
472                 4, STATS_FLAGS_FUNC, "tx_hw_max_queue_depth"},
473     { STATS_OFFSET32(tx_dma_mapping_failure),
474                 4, STATS_FLAGS_FUNC, "tx_dma_mapping_failure"},
475     { STATS_OFFSET32(tx_max_drbr_queue_depth),
476                 4, STATS_FLAGS_FUNC, "tx_max_drbr_queue_depth"},
477     { STATS_OFFSET32(tx_window_violation_std),
478                 4, STATS_FLAGS_FUNC, "tx_window_violation_std"},
479     { STATS_OFFSET32(tx_window_violation_tso),
480                 4, STATS_FLAGS_FUNC, "tx_window_violation_tso"},
481 #if 0
482     { STATS_OFFSET32(tx_unsupported_tso_request_ipv6),
483                 4, STATS_FLAGS_FUNC, "tx_unsupported_tso_request_ipv6"},
484     { STATS_OFFSET32(tx_unsupported_tso_request_not_tcp),
485                 4, STATS_FLAGS_FUNC, "tx_unsupported_tso_request_not_tcp"},
486 #endif
487     { STATS_OFFSET32(tx_chain_lost_mbuf),
488                 4, STATS_FLAGS_FUNC, "tx_chain_lost_mbuf"},
489     { STATS_OFFSET32(tx_frames_deferred),
490                 4, STATS_FLAGS_FUNC, "tx_frames_deferred"},
491     { STATS_OFFSET32(tx_queue_xoff),
492                 4, STATS_FLAGS_FUNC, "tx_queue_xoff"},
493     { STATS_OFFSET32(mbuf_defrag_attempts),
494                 4, STATS_FLAGS_FUNC, "mbuf_defrag_attempts"},
495     { STATS_OFFSET32(mbuf_defrag_failures),
496                 4, STATS_FLAGS_FUNC, "mbuf_defrag_failures"},
497     { STATS_OFFSET32(mbuf_rx_bd_alloc_failed),
498                 4, STATS_FLAGS_FUNC, "mbuf_rx_bd_alloc_failed"},
499     { STATS_OFFSET32(mbuf_rx_bd_mapping_failed),
500                 4, STATS_FLAGS_FUNC, "mbuf_rx_bd_mapping_failed"},
501     { STATS_OFFSET32(mbuf_rx_tpa_alloc_failed),
502                 4, STATS_FLAGS_FUNC, "mbuf_rx_tpa_alloc_failed"},
503     { STATS_OFFSET32(mbuf_rx_tpa_mapping_failed),
504                 4, STATS_FLAGS_FUNC, "mbuf_rx_tpa_mapping_failed"},
505     { STATS_OFFSET32(mbuf_rx_sge_alloc_failed),
506                 4, STATS_FLAGS_FUNC, "mbuf_rx_sge_alloc_failed"},
507     { STATS_OFFSET32(mbuf_rx_sge_mapping_failed),
508                 4, STATS_FLAGS_FUNC, "mbuf_rx_sge_mapping_failed"},
509     { STATS_OFFSET32(mbuf_alloc_tx),
510                 4, STATS_FLAGS_FUNC, "mbuf_alloc_tx"},
511     { STATS_OFFSET32(mbuf_alloc_rx),
512                 4, STATS_FLAGS_FUNC, "mbuf_alloc_rx"},
513     { STATS_OFFSET32(mbuf_alloc_sge),
514                 4, STATS_FLAGS_FUNC, "mbuf_alloc_sge"},
515     { STATS_OFFSET32(mbuf_alloc_tpa),
516                 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"}
517 };
518
519 static const struct {
520     uint32_t offset;
521     uint32_t size;
522     char string[STAT_NAME_LEN];
523 } bxe_eth_q_stats_arr[] = {
524     { Q_STATS_OFFSET32(total_bytes_received_hi),
525                 8, "rx_bytes" },
526     { Q_STATS_OFFSET32(total_unicast_packets_received_hi),
527                 8, "rx_ucast_packets" },
528     { Q_STATS_OFFSET32(total_multicast_packets_received_hi),
529                 8, "rx_mcast_packets" },
530     { Q_STATS_OFFSET32(total_broadcast_packets_received_hi),
531                 8, "rx_bcast_packets" },
532     { Q_STATS_OFFSET32(no_buff_discard_hi),
533                 8, "rx_discards" },
534     { Q_STATS_OFFSET32(total_bytes_transmitted_hi),
535                 8, "tx_bytes" },
536     { Q_STATS_OFFSET32(total_unicast_packets_transmitted_hi),
537                 8, "tx_ucast_packets" },
538     { Q_STATS_OFFSET32(total_multicast_packets_transmitted_hi),
539                 8, "tx_mcast_packets" },
540     { Q_STATS_OFFSET32(total_broadcast_packets_transmitted_hi),
541                 8, "tx_bcast_packets" },
542     { Q_STATS_OFFSET32(total_tpa_aggregations_hi),
543                 8, "tpa_aggregations" },
544     { Q_STATS_OFFSET32(total_tpa_aggregated_frames_hi),
545                 8, "tpa_aggregated_frames"},
546     { Q_STATS_OFFSET32(total_tpa_bytes_hi),
547                 8, "tpa_bytes"},
548     { Q_STATS_OFFSET32(rx_calls),
549                 4, "rx_calls"},
550     { Q_STATS_OFFSET32(rx_pkts),
551                 4, "rx_pkts"},
552     { Q_STATS_OFFSET32(rx_tpa_pkts),
553                 4, "rx_tpa_pkts"},
554     { Q_STATS_OFFSET32(rx_soft_errors),
555                 4, "rx_soft_errors"},
556     { Q_STATS_OFFSET32(rx_hw_csum_errors),
557                 4, "rx_hw_csum_errors"},
558     { Q_STATS_OFFSET32(rx_ofld_frames_csum_ip),
559                 4, "rx_ofld_frames_csum_ip"},
560     { Q_STATS_OFFSET32(rx_ofld_frames_csum_tcp_udp),
561                 4, "rx_ofld_frames_csum_tcp_udp"},
562     { Q_STATS_OFFSET32(rx_budget_reached),
563                 4, "rx_budget_reached"},
564     { Q_STATS_OFFSET32(tx_pkts),
565                 4, "tx_pkts"},
566     { Q_STATS_OFFSET32(tx_soft_errors),
567                 4, "tx_soft_errors"},
568     { Q_STATS_OFFSET32(tx_ofld_frames_csum_ip),
569                 4, "tx_ofld_frames_csum_ip"},
570     { Q_STATS_OFFSET32(tx_ofld_frames_csum_tcp),
571                 4, "tx_ofld_frames_csum_tcp"},
572     { Q_STATS_OFFSET32(tx_ofld_frames_csum_udp),
573                 4, "tx_ofld_frames_csum_udp"},
574     { Q_STATS_OFFSET32(tx_ofld_frames_lso),
575                 4, "tx_ofld_frames_lso"},
576     { Q_STATS_OFFSET32(tx_ofld_frames_lso_hdr_splits),
577                 4, "tx_ofld_frames_lso_hdr_splits"},
578     { Q_STATS_OFFSET32(tx_encap_failures),
579                 4, "tx_encap_failures"},
580     { Q_STATS_OFFSET32(tx_hw_queue_full),
581                 4, "tx_hw_queue_full"},
582     { Q_STATS_OFFSET32(tx_hw_max_queue_depth),
583                 4, "tx_hw_max_queue_depth"},
584     { Q_STATS_OFFSET32(tx_dma_mapping_failure),
585                 4, "tx_dma_mapping_failure"},
586     { Q_STATS_OFFSET32(tx_max_drbr_queue_depth),
587                 4, "tx_max_drbr_queue_depth"},
588     { Q_STATS_OFFSET32(tx_window_violation_std),
589                 4, "tx_window_violation_std"},
590     { Q_STATS_OFFSET32(tx_window_violation_tso),
591                 4, "tx_window_violation_tso"},
592 #if 0
593     { Q_STATS_OFFSET32(tx_unsupported_tso_request_ipv6),
594                 4, "tx_unsupported_tso_request_ipv6"},
595     { Q_STATS_OFFSET32(tx_unsupported_tso_request_not_tcp),
596                 4, "tx_unsupported_tso_request_not_tcp"},
597 #endif
598     { Q_STATS_OFFSET32(tx_chain_lost_mbuf),
599                 4, "tx_chain_lost_mbuf"},
600     { Q_STATS_OFFSET32(tx_frames_deferred),
601                 4, "tx_frames_deferred"},
602     { Q_STATS_OFFSET32(tx_queue_xoff),
603                 4, "tx_queue_xoff"},
604     { Q_STATS_OFFSET32(mbuf_defrag_attempts),
605                 4, "mbuf_defrag_attempts"},
606     { Q_STATS_OFFSET32(mbuf_defrag_failures),
607                 4, "mbuf_defrag_failures"},
608     { Q_STATS_OFFSET32(mbuf_rx_bd_alloc_failed),
609                 4, "mbuf_rx_bd_alloc_failed"},
610     { Q_STATS_OFFSET32(mbuf_rx_bd_mapping_failed),
611                 4, "mbuf_rx_bd_mapping_failed"},
612     { Q_STATS_OFFSET32(mbuf_rx_tpa_alloc_failed),
613                 4, "mbuf_rx_tpa_alloc_failed"},
614     { Q_STATS_OFFSET32(mbuf_rx_tpa_mapping_failed),
615                 4, "mbuf_rx_tpa_mapping_failed"},
616     { Q_STATS_OFFSET32(mbuf_rx_sge_alloc_failed),
617                 4, "mbuf_rx_sge_alloc_failed"},
618     { Q_STATS_OFFSET32(mbuf_rx_sge_mapping_failed),
619                 4, "mbuf_rx_sge_mapping_failed"},
620     { Q_STATS_OFFSET32(mbuf_alloc_tx),
621                 4, "mbuf_alloc_tx"},
622     { Q_STATS_OFFSET32(mbuf_alloc_rx),
623                 4, "mbuf_alloc_rx"},
624     { Q_STATS_OFFSET32(mbuf_alloc_sge),
625                 4, "mbuf_alloc_sge"},
626     { Q_STATS_OFFSET32(mbuf_alloc_tpa),
627                 4, "mbuf_alloc_tpa"}
628 };
629
630 #define BXE_NUM_ETH_STATS   ARRAY_SIZE(bxe_eth_stats_arr)
631 #define BXE_NUM_ETH_Q_STATS ARRAY_SIZE(bxe_eth_q_stats_arr)
632
633
634 static void    bxe_cmng_fns_init(struct bxe_adapter *sc,
635                                  uint8_t          read_cfg,
636                                  uint8_t          cmng_type);
637 static int     bxe_get_cmng_fns_mode(struct bxe_adapter *sc);
638 static void    storm_memset_cmng(struct bxe_adapter *sc,
639                                  struct cmng_init *cmng,
640                                  uint8_t          port);
641 static void    bxe_set_reset_global(struct bxe_adapter *sc);
642 static void    bxe_set_reset_in_progress(struct bxe_adapter *sc);
643 static uint8_t bxe_reset_is_done(struct bxe_adapter *sc,
644                                  int              engine);
645 static uint8_t bxe_clear_pf_load(struct bxe_adapter *sc);
646 static uint8_t bxe_chk_parity_attn(struct bxe_adapter *sc,
647                                    uint8_t          *global,
648                                    uint8_t          print);
649 static void    bxe_int_disable(struct bxe_adapter *sc);
650 static int     bxe_release_leader_lock(struct bxe_adapter *sc);
651 static void    bxe_pf_disable(struct bxe_adapter *sc);
652 static void    bxe_free_fp_buffers(struct bxe_adapter *sc);
653 static inline void bxe_update_rx_prod(struct bxe_adapter    *sc,
654                                       struct bxe_fastpath *fp,
655                                       uint16_t            rx_bd_prod,
656                                       uint16_t            rx_cq_prod,
657                                       uint16_t            rx_sge_prod);
658 static void    bxe_link_report_locked(struct bxe_adapter *sc);
659 static void    bxe_link_report(struct bxe_adapter *sc);
660 static void    bxe_link_status_update(struct bxe_adapter *sc);
661 static void    bxe_periodic_callout_func(void *xsc);
662 static void    bxe_periodic_start(struct bxe_adapter *sc);
663 static void    bxe_periodic_stop(struct bxe_adapter *sc);
664 static int     bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
665                                     uint16_t prev_index,
666                                     uint16_t index);
667 static int     bxe_alloc_rx_tpa_mbuf(struct bxe_fastpath *fp,
668                                      int                 queue);
669 static int     bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
670                                      uint16_t            index);
671 static uint8_t bxe_txeof(struct bxe_adapter *sc,
672                          struct bxe_fastpath *fp);
673 static void    bxe_task_fp(struct bxe_fastpath *fp);
674 //static __noinline void bxe_dump_mbuf(struct bxe_adapter *sc,
675 //                                     struct mbuf      *m,
676 //                                     uint8_t          contents);
677 static int     bxe_alloc_mem(struct bxe_adapter *sc);
678 static void    bxe_free_mem(struct bxe_adapter *sc);
679 static int     bxe_alloc_fw_stats_mem(struct bxe_adapter *sc);
680 static void    bxe_free_fw_stats_mem(struct bxe_adapter *sc);
681 static int     bxe_interrupt_attach(struct bxe_adapter *sc);
682 static void    bxe_interrupt_detach(struct bxe_adapter *sc);
683 static void    bxe_set_rx_mode(struct bxe_adapter *sc);
684 static int     bxe_init_locked(struct bxe_adapter *sc);
685 static int     bxe_stop_locked(struct bxe_adapter *sc);
686 static __noinline int bxe_nic_load(struct bxe_adapter *sc,
687                                    int              load_mode);
688 static __noinline int bxe_nic_unload(struct bxe_adapter *sc,
689                                      uint32_t         unload_mode,
690                                      uint8_t          keep_link);
691
692 static void bxe_handle_sp_tq(void *context, int pending);
693 static void bxe_handle_rx_mode_tq(void *context, int pending);
694 static void bxe_handle_fp_tq(void *context, int pending);
695
696
697 /* calculate crc32 on a buffer (NOTE: crc32_length MUST be aligned to 8) */
698 uint32_t
699 calc_crc32(uint8_t  *crc32_packet,
700            uint32_t crc32_length,
701            uint32_t crc32_seed,
702            uint8_t  complement)
703 {
704    uint32_t byte         = 0;
705    uint32_t bit          = 0;
706    uint8_t  msb          = 0;
707    uint32_t temp         = 0;
708    uint32_t shft         = 0;
709    uint8_t  current_byte = 0;
710    uint32_t crc32_result = crc32_seed;
711    const uint32_t CRC32_POLY = 0x1edc6f41;
712
713    if ((crc32_packet == NULL) ||
714        (crc32_length == 0) ||
715        ((crc32_length % 8) != 0))
716     {
717         return (crc32_result);
718     }
719
720     for (byte = 0; byte < crc32_length; byte = byte + 1)
721     {
722         current_byte = crc32_packet[byte];
723         for (bit = 0; bit < 8; bit = bit + 1)
724         {
725             /* msb = crc32_result[31]; */
726             msb = (uint8_t)(crc32_result >> 31);
727
728             crc32_result = crc32_result << 1;
729
730             /* it (msb != current_byte[bit]) */
731             if (msb != (0x1 & (current_byte >> bit)))
732             {
733                 crc32_result = crc32_result ^ CRC32_POLY;
734                 /* crc32_result[0] = 1 */
735                 crc32_result |= 1;
736             }
737         }
738     }
739
740     /* Last step is to:
741      * 1. "mirror" every bit
742      * 2. swap the 4 bytes
743      * 3. complement each bit
744      */
745
746     /* Mirror */
747     temp = crc32_result;
748     shft = sizeof(crc32_result) * 8 - 1;
749
750     for (crc32_result >>= 1; crc32_result; crc32_result >>= 1)
751     {
752         temp <<= 1;
753         temp |= crc32_result & 1;
754         shft-- ;
755     }
756
757     /* temp[31-bit] = crc32_result[bit] */
758     temp <<= shft;
759
760     /* Swap */
761     /* crc32_result = {temp[7:0], temp[15:8], temp[23:16], temp[31:24]} */
762     {
763         uint32_t t0, t1, t2, t3;
764         t0 = (0x000000ff & (temp >> 24));
765         t1 = (0x0000ff00 & (temp >> 8));
766         t2 = (0x00ff0000 & (temp << 8));
767         t3 = (0xff000000 & (temp << 24));
768         crc32_result = t0 | t1 | t2 | t3;
769     }
770
771     /* Complement */
772     if (complement)
773     {
774         crc32_result = ~crc32_result;
775     }
776
777     return (crc32_result);
778 }
779
780
781 int
782 bxe_cmpxchg(volatile int *addr,
783             int          old,
784             int          new)
785 {
786     int x;
787     do {
788         x = *addr;
789     } while (atomic_cmpset_acq_int(addr, old, new) == 0);
790     return (x);
791 }
792
793 /*
794  * Get DMA memory from the OS.
795  *
796  * Validates that the OS has provided DMA buffers in response to a
797  * bus_dmamap_load call and saves the physical address of those buffers.
798  * When the callback is used the OS will return 0 for the mapping function
799  * (bus_dmamap_load) so we use the value of map_arg->maxsegs to pass any
800  * failures back to the caller.
801  *
802  * Returns:
803  *   Nothing.
804  */
805 static void
806 bxe_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
807 {
808 #if 0
809     struct bxe_dma *dma = arg;
810
811     if (error) {
812         dma->paddr = 0;
813         dma->nseg  = 0;
814         BLOGE(dma->sc, "Failed DMA alloc '%s' (%d)!\n", dma->msg, error);
815     } else {
816         dma->paddr = segs->ds_addr;
817         dma->nseg  = nseg;
818 #if 0
819         BLOGD(dma->sc, DBG_LOAD,
820               "DMA alloc '%s': vaddr=%p paddr=%p nseg=%d size=%lu\n",
821               dma->msg, dma->vaddr, (void *)dma->paddr,
822               dma->nseg, dma->size);
823 #endif
824     }
825 #endif
826 }
827
828 /*
829  * Allocate a block of memory and map it for DMA. No partial completions
830  * allowed and release any resources acquired if we can't acquire all
831  * resources.
832  *
833  * Returns:
834  *   0 = Success, !0 = Failure
835  */
836 int
837 bxe_dma_alloc(struct bxe_adapter *sc,
838               bus_size_t       size,
839               struct bxe_dma   *dma,
840               const char       *msg)
841 {
842 #if 0
843     int rc;
844
845     if (dma->size > 0) {
846         BLOGE(sc, "dma block '%s' already has size %lu\n", msg,
847               (unsigned long)dma->size);
848         return (1);
849     }
850
851     memset(dma, 0, sizeof(*dma)); /* sanity */
852     dma->sc   = sc;
853     dma->size = size;
854     snprintf(dma->msg, sizeof(dma->msg), "%s", msg);
855
856     rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
857                             BCM_PAGE_SIZE,      /* alignment */
858                             0,                  /* boundary limit */
859                             BUS_SPACE_MAXADDR,  /* restricted low */
860                             BUS_SPACE_MAXADDR,  /* restricted hi */
861                             NULL,               /* addr filter() */
862                             NULL,               /* addr filter() arg */
863                             size,               /* max map size */
864                             1,                  /* num discontinuous */
865                             size,               /* max seg size */
866                             BUS_DMA_ALLOCNOW,   /* flags */
867                             NULL,               /* lock() */
868                             NULL,               /* lock() arg */
869                             &dma->tag);         /* returned dma tag */
870     if (rc != 0) {
871         BLOGE(sc, "Failed to create dma tag for '%s' (%d)\n", msg, rc);
872         memset(dma, 0, sizeof(*dma));
873         return (1);
874     }
875
876     rc = bus_dmamem_alloc(dma->tag,
877                           (void **)&dma->vaddr,
878                           (BUS_DMA_NOWAIT | BUS_DMA_ZERO),
879                           &dma->map);
880     if (rc != 0) {
881         BLOGE(sc, "Failed to alloc dma mem for '%s' (%d)\n", msg, rc);
882         bus_dma_tag_destroy(dma->tag);
883         memset(dma, 0, sizeof(*dma));
884         return (1);
885     }
886
887     rc = bus_dmamap_load(dma->tag,
888                          dma->map,
889                          dma->vaddr,
890                          size,
891                          bxe_dma_map_addr, /* BLOGD in here */
892                          dma,
893                          BUS_DMA_NOWAIT);
894     if (rc != 0) {
895         BLOGE(sc, "Failed to load dma map for '%s' (%d)\n", msg, rc);
896         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
897         bus_dma_tag_destroy(dma->tag);
898         memset(dma, 0, sizeof(*dma));
899         return (1);
900     }
901 #endif
902     return (0);
903 }
904
905 void
906 bxe_dma_free(struct bxe_adapter *sc,
907              struct bxe_dma   *dma)
908 {
909 #if 0
910     if (dma->size > 0) {
911 #if 0
912         BLOGD(sc, DBG_LOAD,
913               "DMA free '%s': vaddr=%p paddr=%p nseg=%d size=%lu\n",
914               dma->msg, dma->vaddr, (void *)dma->paddr,
915               dma->nseg, dma->size);
916 #endif
917
918         DBASSERT(sc, (dma->tag != NULL), ("dma tag is NULL"));
919
920         bus_dmamap_sync(dma->tag, dma->map,
921                         (BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE));
922         bus_dmamap_unload(dma->tag, dma->map);
923         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
924         bus_dma_tag_destroy(dma->tag);
925     }
926 #endif
927     memset(dma, 0, sizeof(*dma));
928 }
929
930 /*
931  * These indirect read and write routines are only during init.
932  * The locking is handled by the MCP.
933  */
934
935 void
936 bxe_reg_wr_ind(struct bxe_adapter *sc,
937                uint32_t         addr,
938                uint32_t         val)
939 {
940     pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, addr);
941     pcidev_write32(sc->pcidev, PCICFG_GRC_DATA, val);
942     pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, 0);
943 }
944
945 uint32_t
946 bxe_reg_rd_ind(struct bxe_adapter *sc,
947                uint32_t         addr)
948 {
949     uint32_t val;
950
951     pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, addr);
952     val = pcidev_read32(sc->pcidev, PCICFG_GRC_DATA);
953     pcidev_write32(sc->pcidev, PCICFG_GRC_ADDRESS, 0);
954
955     return (val);
956 }
957
958 #if 0
959 void bxe_dp_dmae(struct bxe_adapter *sc, struct dmae_command *dmae, int msglvl)
960 {
961     uint32_t src_type = dmae->opcode & DMAE_COMMAND_SRC;
962
963     switch (dmae->opcode & DMAE_COMMAND_DST) {
964     case DMAE_CMD_DST_PCI:
965         if (src_type == DMAE_CMD_SRC_PCI)
966             DP(msglvl, "DMAE: opcode 0x%08x\n"
967                "src [%x:%08x], len [%d*4], dst [%x:%08x]\n"
968                "comp_addr [%x:%08x], comp_val 0x%08x\n",
969                dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
970                dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
971                dmae->comp_addr_hi, dmae->comp_addr_lo,
972                dmae->comp_val);
973         else
974             DP(msglvl, "DMAE: opcode 0x%08x\n"
975                "src [%08x], len [%d*4], dst [%x:%08x]\n"
976                "comp_addr [%x:%08x], comp_val 0x%08x\n",
977                dmae->opcode, dmae->src_addr_lo >> 2,
978                dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
979                dmae->comp_addr_hi, dmae->comp_addr_lo,
980                dmae->comp_val);
981         break;
982     case DMAE_CMD_DST_GRC:
983         if (src_type == DMAE_CMD_SRC_PCI)
984             DP(msglvl, "DMAE: opcode 0x%08x\n"
985                "src [%x:%08x], len [%d*4], dst_addr [%08x]\n"
986                "comp_addr [%x:%08x], comp_val 0x%08x\n",
987                dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
988                dmae->len, dmae->dst_addr_lo >> 2,
989                dmae->comp_addr_hi, dmae->comp_addr_lo,
990                dmae->comp_val);
991         else
992             DP(msglvl, "DMAE: opcode 0x%08x\n"
993                "src [%08x], len [%d*4], dst [%08x]\n"
994                "comp_addr [%x:%08x], comp_val 0x%08x\n",
995                dmae->opcode, dmae->src_addr_lo >> 2,
996                dmae->len, dmae->dst_addr_lo >> 2,
997                dmae->comp_addr_hi, dmae->comp_addr_lo,
998                dmae->comp_val);
999         break;
1000     default:
1001         if (src_type == DMAE_CMD_SRC_PCI)
1002             DP(msglvl, "DMAE: opcode 0x%08x\n"
1003                "src_addr [%x:%08x]  len [%d * 4]  dst_addr [none]\n"
1004                "comp_addr [%x:%08x]  comp_val 0x%08x\n",
1005                dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
1006                dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
1007                dmae->comp_val);
1008         else
1009             DP(msglvl, "DMAE: opcode 0x%08x\n"
1010                "src_addr [%08x]  len [%d * 4]  dst_addr [none]\n"
1011                "comp_addr [%x:%08x]  comp_val 0x%08x\n",
1012                dmae->opcode, dmae->src_addr_lo >> 2,
1013                dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
1014                dmae->comp_val);
1015         break;
1016     }
1017
1018 }
1019 #endif
1020
1021 static int
1022 bxe_acquire_hw_lock(struct bxe_adapter *sc,
1023                     uint32_t         resource)
1024 {
1025     uint32_t lock_status;
1026     uint32_t resource_bit = (1 << resource);
1027     int func = SC_FUNC(sc);
1028     uint32_t hw_lock_control_reg;
1029     int cnt;
1030
1031     /* validate the resource is within range */
1032     if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1033         BLOGE(sc, "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE\n", resource);
1034         return (-1);
1035     }
1036
1037     if (func <= 5) {
1038         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + (func * 8));
1039     } else {
1040         hw_lock_control_reg =
1041                 (MISC_REG_DRIVER_CONTROL_7 + ((func - 6) * 8));
1042     }
1043
1044     /* validate the resource is not already taken */
1045     lock_status = REG_RD(sc, hw_lock_control_reg);
1046     if (lock_status & resource_bit) {
1047         BLOGE(sc, "resource in use (status 0x%x bit 0x%x)\n",
1048               lock_status, resource_bit);
1049         return (-1);
1050     }
1051
1052     /* try every 5ms for 5 seconds */
1053     for (cnt = 0; cnt < 1000; cnt++) {
1054         REG_WR(sc, (hw_lock_control_reg + 4), resource_bit);
1055         lock_status = REG_RD(sc, hw_lock_control_reg);
1056         if (lock_status & resource_bit) {
1057             return (0);
1058         }
1059         udelay(5000);
1060     }
1061
1062     BLOGE(sc, "Resource lock timeout!\n");
1063     return (-1);
1064 }
1065
1066 static int
1067 bxe_release_hw_lock(struct bxe_adapter *sc,
1068                     uint32_t         resource)
1069 {
1070     uint32_t lock_status;
1071     uint32_t resource_bit = (1 << resource);
1072     int func = SC_FUNC(sc);
1073     uint32_t hw_lock_control_reg;
1074
1075     /* validate the resource is within range */
1076     if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1077         BLOGE(sc, "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE\n", resource);
1078         return (-1);
1079     }
1080
1081     if (func <= 5) {
1082         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + (func * 8));
1083     } else {
1084         hw_lock_control_reg =
1085                 (MISC_REG_DRIVER_CONTROL_7 + ((func - 6) * 8));
1086     }
1087
1088     /* validate the resource is currently taken */
1089     lock_status = REG_RD(sc, hw_lock_control_reg);
1090     if (!(lock_status & resource_bit)) {
1091         BLOGE(sc, "resource not in use (status 0x%x bit 0x%x)\n",
1092               lock_status, resource_bit);
1093         return (-1);
1094     }
1095
1096     REG_WR(sc, hw_lock_control_reg, resource_bit);
1097     return (0);
1098 }
1099
1100 /*
1101  * Per pf misc lock must be acquired before the per port mcp lock. Otherwise,
1102  * had we done things the other way around, if two pfs from the same port
1103  * would attempt to access nvram at the same time, we could run into a
1104  * scenario such as:
1105  * pf A takes the port lock.
1106  * pf B succeeds in taking the same lock since they are from the same port.
1107  * pf A takes the per pf misc lock. Performs eeprom access.
1108  * pf A finishes. Unlocks the per pf misc lock.
1109  * Pf B takes the lock and proceeds to perform it's own access.
1110  * pf A unlocks the per port lock, while pf B is still working (!).
1111  * mcp takes the per port lock and corrupts pf B's access (and/or has it's own
1112  * access corrupted by pf B).*
1113  */
1114 static int
1115 bxe_acquire_nvram_lock(struct bxe_adapter *sc)
1116 {
1117     int port = SC_PORT(sc);
1118     int count, i;
1119     uint32_t val = 0;
1120
1121     /* acquire HW lock: protect against other PFs in PF Direct Assignment */
1122     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_NVRAM);
1123
1124     /* adjust timeout for emulation/FPGA */
1125     count = NVRAM_TIMEOUT_COUNT;
1126     if (CHIP_REV_IS_SLOW(sc)) {
1127         count *= 100;
1128     }
1129
1130     /* request access to nvram interface */
1131     REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
1132            (MCPR_NVM_SW_ARB_ARB_REQ_SET1 << port));
1133
1134     for (i = 0; i < count*10; i++) {
1135         val = REG_RD(sc, MCP_REG_MCPR_NVM_SW_ARB);
1136         if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
1137             break;
1138         }
1139
1140         udelay(5);
1141     }
1142
1143     if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
1144         BLOGE(sc, "Cannot get access to nvram interface\n");
1145         return (-1);
1146     }
1147
1148     return (0);
1149 }
1150
1151 static int
1152 bxe_release_nvram_lock(struct bxe_adapter *sc)
1153 {
1154     int port = SC_PORT(sc);
1155     int count, i;
1156     uint32_t val = 0;
1157
1158     /* adjust timeout for emulation/FPGA */
1159     count = NVRAM_TIMEOUT_COUNT;
1160     if (CHIP_REV_IS_SLOW(sc)) {
1161         count *= 100;
1162     }
1163
1164     /* relinquish nvram interface */
1165     REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
1166            (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << port));
1167
1168     for (i = 0; i < count*10; i++) {
1169         val = REG_RD(sc, MCP_REG_MCPR_NVM_SW_ARB);
1170         if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
1171             break;
1172         }
1173
1174         udelay(5);
1175     }
1176
1177     if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
1178         BLOGE(sc, "Cannot free access to nvram interface\n");
1179         return (-1);
1180     }
1181
1182     /* release HW lock: protect against other PFs in PF Direct Assignment */
1183     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_NVRAM);
1184
1185     return (0);
1186 }
1187
1188 static void
1189 bxe_enable_nvram_access(struct bxe_adapter *sc)
1190 {
1191     uint32_t val;
1192
1193     val = REG_RD(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
1194
1195     /* enable both bits, even on read */
1196     REG_WR(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
1197            (val | MCPR_NVM_ACCESS_ENABLE_EN | MCPR_NVM_ACCESS_ENABLE_WR_EN));
1198 }
1199
1200 static void
1201 bxe_disable_nvram_access(struct bxe_adapter *sc)
1202 {
1203     uint32_t val;
1204
1205     val = REG_RD(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
1206
1207     /* disable both bits, even after read */
1208     REG_WR(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
1209            (val & ~(MCPR_NVM_ACCESS_ENABLE_EN |
1210                     MCPR_NVM_ACCESS_ENABLE_WR_EN)));
1211 }
1212
1213 static int
1214 bxe_nvram_read_dword(struct bxe_adapter *sc,
1215                      uint32_t         offset,
1216                      uint32_t         *ret_val,
1217                      uint32_t         cmd_flags)
1218 {
1219     int count, i, rc;
1220     uint32_t val;
1221
1222     /* build the command word */
1223     cmd_flags |= MCPR_NVM_COMMAND_DOIT;
1224
1225     /* need to clear DONE bit separately */
1226     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
1227
1228     /* address of the NVRAM to read from */
1229     REG_WR(sc, MCP_REG_MCPR_NVM_ADDR,
1230            (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
1231
1232     /* issue a read command */
1233     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
1234
1235     /* adjust timeout for emulation/FPGA */
1236     count = NVRAM_TIMEOUT_COUNT;
1237     if (CHIP_REV_IS_SLOW(sc)) {
1238         count *= 100;
1239     }
1240
1241     /* wait for completion */
1242     *ret_val = 0;
1243     rc = -1;
1244     for (i = 0; i < count; i++) {
1245         udelay(5);
1246         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
1247
1248         if (val & MCPR_NVM_COMMAND_DONE) {
1249             val = REG_RD(sc, MCP_REG_MCPR_NVM_READ);
1250             /* we read nvram data in cpu order
1251              * but ethtool sees it as an array of bytes
1252              * converting to big-endian will do the work
1253              */
1254             *ret_val = htobe32(val);
1255             rc = 0;
1256             break;
1257         }
1258     }
1259
1260     if (rc == -1) {
1261         BLOGE(sc, "nvram read timeout expired\n");
1262     }
1263
1264     return (rc);
1265 }
1266
1267 static int
1268 bxe_nvram_read(struct bxe_adapter *sc,
1269                uint32_t         offset,
1270                uint8_t          *ret_buf,
1271                int              buf_size)
1272 {
1273     uint32_t cmd_flags;
1274     uint32_t val;
1275     int rc;
1276
1277     if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
1278         BLOGE(sc, "Invalid parameter, offset 0x%x buf_size 0x%x\n",
1279               offset, buf_size);
1280         return (-1);
1281     }
1282
1283     if ((offset + buf_size) > sc->devinfo.flash_size) {
1284         BLOGE(sc, "Invalid parameter, "
1285                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1286               offset, buf_size, sc->devinfo.flash_size);
1287         return (-1);
1288     }
1289
1290     /* request access to nvram interface */
1291     rc = bxe_acquire_nvram_lock(sc);
1292     if (rc) {
1293         return (rc);
1294     }
1295
1296     /* enable access to nvram interface */
1297     bxe_enable_nvram_access(sc);
1298
1299     /* read the first word(s) */
1300     cmd_flags = MCPR_NVM_COMMAND_FIRST;
1301     while ((buf_size > sizeof(uint32_t)) && (rc == 0)) {
1302         rc = bxe_nvram_read_dword(sc, offset, &val, cmd_flags);
1303         memcpy(ret_buf, &val, 4);
1304
1305         /* advance to the next dword */
1306         offset += sizeof(uint32_t);
1307         ret_buf += sizeof(uint32_t);
1308         buf_size -= sizeof(uint32_t);
1309         cmd_flags = 0;
1310     }
1311
1312     if (rc == 0) {
1313         cmd_flags |= MCPR_NVM_COMMAND_LAST;
1314         rc = bxe_nvram_read_dword(sc, offset, &val, cmd_flags);
1315         memcpy(ret_buf, &val, 4);
1316     }
1317
1318     /* disable access to nvram interface */
1319     bxe_disable_nvram_access(sc);
1320     bxe_release_nvram_lock(sc);
1321
1322     return (rc);
1323 }
1324
1325 static int
1326 bxe_nvram_write_dword(struct bxe_adapter *sc,
1327                       uint32_t         offset,
1328                       uint32_t         val,
1329                       uint32_t         cmd_flags)
1330 {
1331     int count, i, rc;
1332
1333     /* build the command word */
1334     cmd_flags |= (MCPR_NVM_COMMAND_DOIT | MCPR_NVM_COMMAND_WR);
1335
1336     /* need to clear DONE bit separately */
1337     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
1338
1339     /* write the data */
1340     REG_WR(sc, MCP_REG_MCPR_NVM_WRITE, val);
1341
1342     /* address of the NVRAM to write to */
1343     REG_WR(sc, MCP_REG_MCPR_NVM_ADDR,
1344            (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
1345
1346     /* issue the write command */
1347     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
1348
1349     /* adjust timeout for emulation/FPGA */
1350     count = NVRAM_TIMEOUT_COUNT;
1351     if (CHIP_REV_IS_SLOW(sc)) {
1352         count *= 100;
1353     }
1354
1355     /* wait for completion */
1356     rc = -1;
1357     for (i = 0; i < count; i++) {
1358         udelay(5);
1359         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
1360         if (val & MCPR_NVM_COMMAND_DONE) {
1361             rc = 0;
1362             break;
1363         }
1364     }
1365
1366     if (rc == -1) {
1367         BLOGE(sc, "nvram write timeout expired\n");
1368     }
1369
1370     return (rc);
1371 }
1372
1373 #define BYTE_OFFSET(offset) (8 * (offset & 0x03))
1374
1375 static int
1376 bxe_nvram_write1(struct bxe_adapter *sc,
1377                  uint32_t         offset,
1378                  uint8_t          *data_buf,
1379                  int              buf_size)
1380 {
1381     uint32_t cmd_flags;
1382     uint32_t align_offset;
1383     uint32_t val;
1384     int rc;
1385
1386     if ((offset + buf_size) > sc->devinfo.flash_size) {
1387         BLOGE(sc, "Invalid parameter, "
1388                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1389               offset, buf_size, sc->devinfo.flash_size);
1390         return (-1);
1391     }
1392
1393     /* request access to nvram interface */
1394     rc = bxe_acquire_nvram_lock(sc);
1395     if (rc) {
1396         return (rc);
1397     }
1398
1399     /* enable access to nvram interface */
1400     bxe_enable_nvram_access(sc);
1401
1402     cmd_flags = (MCPR_NVM_COMMAND_FIRST | MCPR_NVM_COMMAND_LAST);
1403     align_offset = (offset & ~0x03);
1404     rc = bxe_nvram_read_dword(sc, align_offset, &val, cmd_flags);
1405
1406     if (rc == 0) {
1407         val &= ~(0xff << BYTE_OFFSET(offset));
1408         val |= (*data_buf << BYTE_OFFSET(offset));
1409
1410         /* nvram data is returned as an array of bytes
1411          * convert it back to cpu order
1412          */
1413         val = be32toh(val);
1414
1415         rc = bxe_nvram_write_dword(sc, align_offset, val, cmd_flags);
1416     }
1417
1418     /* disable access to nvram interface */
1419     bxe_disable_nvram_access(sc);
1420     bxe_release_nvram_lock(sc);
1421
1422     return (rc);
1423 }
1424
1425 static int
1426 bxe_nvram_write(struct bxe_adapter *sc,
1427                 uint32_t         offset,
1428                 uint8_t          *data_buf,
1429                 int              buf_size)
1430 {
1431     uint32_t cmd_flags;
1432     uint32_t val;
1433     uint32_t written_so_far;
1434     int rc;
1435
1436     if (buf_size == 1) {
1437         return (bxe_nvram_write1(sc, offset, data_buf, buf_size));
1438     }
1439
1440     if ((offset & 0x03) || (buf_size & 0x03) /* || (buf_size == 0) */) {
1441         BLOGE(sc, "Invalid parameter, offset 0x%x buf_size 0x%x\n",
1442               offset, buf_size);
1443         return (-1);
1444     }
1445
1446     if (buf_size == 0) {
1447         return (0); /* nothing to do */
1448     }
1449
1450     if ((offset + buf_size) > sc->devinfo.flash_size) {
1451         BLOGE(sc, "Invalid parameter, "
1452                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1453               offset, buf_size, sc->devinfo.flash_size);
1454         return (-1);
1455     }
1456
1457     /* request access to nvram interface */
1458     rc = bxe_acquire_nvram_lock(sc);
1459     if (rc) {
1460         return (rc);
1461     }
1462
1463     /* enable access to nvram interface */
1464     bxe_enable_nvram_access(sc);
1465
1466     written_so_far = 0;
1467     cmd_flags = MCPR_NVM_COMMAND_FIRST;
1468     while ((written_so_far < buf_size) && (rc == 0)) {
1469         if (written_so_far == (buf_size - sizeof(uint32_t))) {
1470             cmd_flags |= MCPR_NVM_COMMAND_LAST;
1471         } else if (((offset + 4) % NVRAM_PAGE_SIZE) == 0) {
1472             cmd_flags |= MCPR_NVM_COMMAND_LAST;
1473         } else if ((offset % NVRAM_PAGE_SIZE) == 0) {
1474             cmd_flags |= MCPR_NVM_COMMAND_FIRST;
1475         }
1476
1477         memcpy(&val, data_buf, 4);
1478
1479         rc = bxe_nvram_write_dword(sc, offset, val, cmd_flags);
1480
1481         /* advance to the next dword */
1482         offset += sizeof(uint32_t);
1483         data_buf += sizeof(uint32_t);
1484         written_so_far += sizeof(uint32_t);
1485         cmd_flags = 0;
1486     }
1487
1488     /* disable access to nvram interface */
1489     bxe_disable_nvram_access(sc);
1490     bxe_release_nvram_lock(sc);
1491
1492     return (rc);
1493 }
1494
1495 /* copy command into DMAE command memory and set DMAE command Go */
1496 void
1497 bxe_post_dmae(struct bxe_adapter    *sc,
1498               struct dmae_command *dmae,
1499               int                 idx)
1500 {
1501     uint32_t cmd_offset;
1502     int i;
1503
1504     cmd_offset = (DMAE_REG_CMD_MEM + (sizeof(struct dmae_command) * idx));
1505     for (i = 0; i < ((sizeof(struct dmae_command) / 4)); i++) {
1506         REG_WR(sc, (cmd_offset + (i * 4)), *(((uint32_t *)dmae) + i));
1507     }
1508
1509     REG_WR(sc, dmae_reg_go_c[idx], 1);
1510 }
1511
1512 uint32_t
1513 bxe_dmae_opcode_add_comp(uint32_t opcode,
1514                          uint8_t  comp_type)
1515 {
1516     return (opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
1517                       DMAE_COMMAND_C_TYPE_ENABLE));
1518 }
1519
1520 uint32_t
1521 bxe_dmae_opcode_clr_src_reset(uint32_t opcode)
1522 {
1523     return (opcode & ~DMAE_COMMAND_SRC_RESET);
1524 }
1525
1526 uint32_t
1527 bxe_dmae_opcode(struct bxe_adapter *sc,
1528                 uint8_t          src_type,
1529                 uint8_t          dst_type,
1530                 uint8_t          with_comp,
1531                 uint8_t          comp_type)
1532 {
1533     uint32_t opcode = 0;
1534
1535     opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
1536                (dst_type << DMAE_COMMAND_DST_SHIFT));
1537
1538     opcode |= (DMAE_COMMAND_SRC_RESET | DMAE_COMMAND_DST_RESET);
1539
1540     opcode |= (SC_PORT(sc) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
1541
1542     opcode |= ((SC_VN(sc) << DMAE_COMMAND_E1HVN_SHIFT) |
1543                (SC_VN(sc) << DMAE_COMMAND_DST_VN_SHIFT));
1544
1545     opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
1546
1547 #ifdef __BIG_ENDIAN
1548     opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
1549 #else
1550     opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
1551 #endif
1552
1553     if (with_comp) {
1554         opcode = bxe_dmae_opcode_add_comp(opcode, comp_type);
1555     }
1556
1557     return (opcode);
1558 }
1559
1560 static void
1561 bxe_prep_dmae_with_comp(struct bxe_adapter    *sc,
1562                         struct dmae_command *dmae,
1563                         uint8_t             src_type,
1564                         uint8_t             dst_type)
1565 {
1566     memset(dmae, 0, sizeof(struct dmae_command));
1567
1568     /* set the opcode */
1569     dmae->opcode = bxe_dmae_opcode(sc, src_type, dst_type,
1570                                    TRUE, DMAE_COMP_PCI);
1571
1572     /* fill in the completion parameters */
1573     dmae->comp_addr_lo = U64_LO(BXE_SP_MAPPING(sc, wb_comp));
1574     dmae->comp_addr_hi = U64_HI(BXE_SP_MAPPING(sc, wb_comp));
1575     dmae->comp_val     = DMAE_COMP_VAL;
1576 }
1577
1578 /* issue a DMAE command over the init channel and wait for completion */
1579 static int
1580 bxe_issue_dmae_with_comp(struct bxe_adapter    *sc,
1581                          struct dmae_command *dmae)
1582 {
1583     uint32_t *wb_comp = BXE_SP(sc, wb_comp);
1584     int timeout = CHIP_REV_IS_SLOW(sc) ? 400000 : 4000;
1585
1586     BXE_DMAE_LOCK(sc);
1587
1588     /* reset completion */
1589     *wb_comp = 0;
1590
1591     /* post the command on the channel used for initializations */
1592     bxe_post_dmae(sc, dmae, INIT_DMAE_C(sc));
1593
1594     /* wait for completion */
1595     udelay(5);
1596
1597     while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
1598         if (!timeout ||
1599             (sc->recovery_state != BXE_RECOVERY_DONE &&
1600              sc->recovery_state != BXE_RECOVERY_NIC_LOADING)) {
1601             BLOGE(sc, "DMAE timeout!\n");
1602             BXE_DMAE_UNLOCK(sc);
1603             return (DMAE_TIMEOUT);
1604         }
1605
1606         timeout--;
1607         udelay(50);
1608     }
1609
1610     if (*wb_comp & DMAE_PCI_ERR_FLAG) {
1611         BLOGE(sc, "DMAE PCI error!\n");
1612         BXE_DMAE_UNLOCK(sc);
1613         return (DMAE_PCI_ERROR);
1614     }
1615
1616     BXE_DMAE_UNLOCK(sc);
1617     return (0);
1618 }
1619
1620 void
1621 bxe_read_dmae(struct bxe_adapter *sc,
1622               uint32_t         src_addr,
1623               uint32_t         len32)
1624 {
1625     struct dmae_command dmae;
1626     uint32_t *data;
1627     int i, rc;
1628
1629     DBASSERT(sc, (len32 <= 4), ("DMAE read length is %d", len32));
1630
1631     if (!sc->dmae_ready) {
1632         data = BXE_SP(sc, wb_data[0]);
1633
1634         for (i = 0; i < len32; i++) {
1635             data[i] = (CHIP_IS_E1(sc)) ?
1636                           bxe_reg_rd_ind(sc, (src_addr + (i * 4))) :
1637                           REG_RD(sc, (src_addr + (i * 4)));
1638         }
1639
1640         return;
1641     }
1642
1643     /* set opcode and fixed command fields */
1644     bxe_prep_dmae_with_comp(sc, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
1645
1646     /* fill in addresses and len */
1647     dmae.src_addr_lo = (src_addr >> 2); /* GRC addr has dword resolution */
1648     dmae.src_addr_hi = 0;
1649     dmae.dst_addr_lo = U64_LO(BXE_SP_MAPPING(sc, wb_data));
1650     dmae.dst_addr_hi = U64_HI(BXE_SP_MAPPING(sc, wb_data));
1651     dmae.len         = len32;
1652
1653     /* issue the command and wait for completion */
1654     if ((rc = bxe_issue_dmae_with_comp(sc, &dmae)) != 0) {
1655         bxe_panic(sc, ("DMAE failed (%d)\n", rc));
1656     };
1657 }
1658
1659 void
1660 bxe_write_dmae(struct bxe_adapter *sc,
1661                bus_addr_t       dma_addr,
1662                uint32_t         dst_addr,
1663                uint32_t         len32)
1664 {
1665     struct dmae_command dmae;
1666     int rc;
1667
1668     if (!sc->dmae_ready) {
1669         DBASSERT(sc, (len32 <= 4), ("DMAE not ready and length is %d", len32));
1670
1671         if (CHIP_IS_E1(sc)) {
1672             ecore_init_ind_wr(sc, dst_addr, BXE_SP(sc, wb_data[0]), len32);
1673         } else {
1674             ecore_init_str_wr(sc, dst_addr, BXE_SP(sc, wb_data[0]), len32);
1675         }
1676
1677         return;
1678     }
1679
1680     /* set opcode and fixed command fields */
1681     bxe_prep_dmae_with_comp(sc, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
1682
1683     /* fill in addresses and len */
1684     dmae.src_addr_lo = U64_LO(dma_addr);
1685     dmae.src_addr_hi = U64_HI(dma_addr);
1686     dmae.dst_addr_lo = (dst_addr >> 2); /* GRC addr has dword resolution */
1687     dmae.dst_addr_hi = 0;
1688     dmae.len         = len32;
1689
1690     /* issue the command and wait for completion */
1691     if ((rc = bxe_issue_dmae_with_comp(sc, &dmae)) != 0) {
1692         bxe_panic(sc, ("DMAE failed (%d)\n", rc));
1693     }
1694 }
1695
1696 void
1697 bxe_write_dmae_phys_len(struct bxe_adapter *sc,
1698                         bus_addr_t       phys_addr,
1699                         uint32_t         addr,
1700                         uint32_t         len)
1701 {
1702     int dmae_wr_max = DMAE_LEN32_WR_MAX(sc);
1703     int offset = 0;
1704
1705     while (len > dmae_wr_max) {
1706         bxe_write_dmae(sc,
1707                        (phys_addr + offset), /* src DMA address */
1708                        (addr + offset),      /* dst GRC address */
1709                        dmae_wr_max);
1710         offset += (dmae_wr_max * 4);
1711         len -= dmae_wr_max;
1712     }
1713
1714     bxe_write_dmae(sc,
1715                    (phys_addr + offset), /* src DMA address */
1716                    (addr + offset),      /* dst GRC address */
1717                    len);
1718 }
1719
1720 void
1721 bxe_set_ctx_validation(struct bxe_adapter   *sc,
1722                        struct eth_context *cxt,
1723                        uint32_t           cid)
1724 {
1725     /* ustorm cxt validation */
1726     cxt->ustorm_ag_context.cdu_usage =
1727         CDU_RSRVD_VALUE_TYPE_A(HW_CID(sc, cid),
1728             CDU_REGION_NUMBER_UCM_AG, ETH_CONNECTION_TYPE);
1729     /* xcontext validation */
1730     cxt->xstorm_ag_context.cdu_reserved =
1731         CDU_RSRVD_VALUE_TYPE_A(HW_CID(sc, cid),
1732             CDU_REGION_NUMBER_XCM_AG, ETH_CONNECTION_TYPE);
1733 }
1734
1735 static void
1736 bxe_storm_memset_hc_timeout(struct bxe_adapter *sc,
1737                             uint8_t          port,
1738                             uint8_t          fw_sb_id,
1739                             uint8_t          sb_index,
1740                             uint8_t          ticks)
1741 {
1742     uint32_t addr =
1743         (BAR_CSTRORM_INTMEM +
1744          CSTORM_STATUS_BLOCK_DATA_TIMEOUT_OFFSET(fw_sb_id, sb_index));
1745
1746     REG_WR8(sc, addr, ticks);
1747
1748     BLOGD(sc, DBG_LOAD,
1749           "port %d fw_sb_id %d sb_index %d ticks %d\n",
1750           port, fw_sb_id, sb_index, ticks);
1751 }
1752
1753 static void
1754 bxe_storm_memset_hc_disable(struct bxe_adapter *sc,
1755                             uint8_t          port,
1756                             uint16_t         fw_sb_id,
1757                             uint8_t          sb_index,
1758                             uint8_t          disable)
1759 {
1760     uint32_t enable_flag =
1761         (disable) ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
1762     uint32_t addr =
1763         (BAR_CSTRORM_INTMEM +
1764          CSTORM_STATUS_BLOCK_DATA_FLAGS_OFFSET(fw_sb_id, sb_index));
1765     uint8_t flags;
1766
1767     /* clear and set */
1768     flags = REG_RD8(sc, addr);
1769     flags &= ~HC_INDEX_DATA_HC_ENABLED;
1770     flags |= enable_flag;
1771     REG_WR8(sc, addr, flags);
1772
1773     BLOGD(sc, DBG_LOAD,
1774           "port %d fw_sb_id %d sb_index %d disable %d\n",
1775           port, fw_sb_id, sb_index, disable);
1776 }
1777
1778 void
1779 bxe_update_coalesce_sb_index(struct bxe_adapter *sc,
1780                              uint8_t          fw_sb_id,
1781                              uint8_t          sb_index,
1782                              uint8_t          disable,
1783                              uint16_t         usec)
1784 {
1785     int port = SC_PORT(sc);
1786     uint8_t ticks = (usec / 4); /* XXX ??? */
1787
1788     bxe_storm_memset_hc_timeout(sc, port, fw_sb_id, sb_index, ticks);
1789
1790     disable = (disable) ? 1 : ((usec) ? 0 : 1);
1791     bxe_storm_memset_hc_disable(sc, port, fw_sb_id, sb_index, disable);
1792 }
1793
1794 void
1795 elink_cb_udelay(struct bxe_adapter *sc,
1796                 uint32_t         usecs)
1797 {
1798     udelay(usecs);
1799 }
1800
1801 uint32_t
1802 elink_cb_reg_read(struct bxe_adapter *sc,
1803                   uint32_t         reg_addr)
1804 {
1805     return (REG_RD(sc, reg_addr));
1806 }
1807
1808 void
1809 elink_cb_reg_write(struct bxe_adapter *sc,
1810                    uint32_t         reg_addr,
1811                    uint32_t         val)
1812 {
1813     REG_WR(sc, reg_addr, val);
1814 }
1815
1816 void
1817 elink_cb_reg_wb_write(struct bxe_adapter *sc,
1818                       uint32_t         offset,
1819                       uint32_t         *wb_write,
1820                       uint16_t         len)
1821 {
1822     REG_WR_DMAE(sc, offset, wb_write, len);
1823 }
1824
1825 void
1826 elink_cb_reg_wb_read(struct bxe_adapter *sc,
1827                      uint32_t         offset,
1828                      uint32_t         *wb_write,
1829                      uint16_t         len)
1830 {
1831     REG_RD_DMAE(sc, offset, wb_write, len);
1832 }
1833
1834 uint8_t
1835 elink_cb_path_id(struct bxe_adapter *sc)
1836 {
1837     return (SC_PATH(sc));
1838 }
1839
1840 void
1841 elink_cb_event_log(struct bxe_adapter     *sc,
1842                    const elink_log_id_t elink_log_id,
1843                    ...)
1844 {
1845     /* XXX */
1846 #if 0
1847     //va_list ap;
1848     va_start(ap, elink_log_id);
1849     _XXX_(sc, lm_log_id, ap);
1850     va_end(ap);
1851 #endif
1852     BLOGI(sc, "ELINK EVENT LOG (%d)\n", elink_log_id);
1853 }
1854
1855 static int
1856 bxe_set_spio(struct bxe_adapter *sc,
1857              int              spio,
1858              uint32_t         mode)
1859 {
1860     uint32_t spio_reg;
1861
1862     /* Only 2 SPIOs are configurable */
1863     if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
1864         BLOGE(sc, "Invalid SPIO 0x%x\n", spio);
1865         return (-1);
1866     }
1867
1868     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_SPIO);
1869
1870     /* read SPIO and mask except the float bits */
1871     spio_reg = (REG_RD(sc, MISC_REG_SPIO) & MISC_SPIO_FLOAT);
1872
1873     switch (mode) {
1874     case MISC_SPIO_OUTPUT_LOW:
1875         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> output low\n", spio);
1876         /* clear FLOAT and set CLR */
1877         spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
1878         spio_reg |=  (spio << MISC_SPIO_CLR_POS);
1879         break;
1880
1881     case MISC_SPIO_OUTPUT_HIGH:
1882         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> output high\n", spio);
1883         /* clear FLOAT and set SET */
1884         spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
1885         spio_reg |=  (spio << MISC_SPIO_SET_POS);
1886         break;
1887
1888     case MISC_SPIO_INPUT_HI_Z:
1889         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> input\n", spio);
1890         /* set FLOAT */
1891         spio_reg |= (spio << MISC_SPIO_FLOAT_POS);
1892         break;
1893
1894     default:
1895         break;
1896     }
1897
1898     REG_WR(sc, MISC_REG_SPIO, spio_reg);
1899     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_SPIO);
1900
1901     return (0);
1902 }
1903
1904 static int
1905 bxe_gpio_read(struct bxe_adapter *sc,
1906               int              gpio_num,
1907               uint8_t          port)
1908 {
1909     /* The GPIO should be swapped if swap register is set and active */
1910     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
1911                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
1912     int gpio_shift = (gpio_num +
1913                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
1914     uint32_t gpio_mask = (1 << gpio_shift);
1915     uint32_t gpio_reg;
1916
1917     if (gpio_num > MISC_REGISTERS_GPIO_3) {
1918         BLOGE(sc, "Invalid GPIO %d\n", gpio_num);
1919         return (-1);
1920     }
1921
1922     /* read GPIO value */
1923     gpio_reg = REG_RD(sc, MISC_REG_GPIO);
1924
1925     /* get the requested pin value */
1926     return ((gpio_reg & gpio_mask) == gpio_mask) ? 1 : 0;
1927 }
1928
1929 static int
1930 bxe_gpio_write(struct bxe_adapter *sc,
1931                int              gpio_num,
1932                uint32_t         mode,
1933                uint8_t          port)
1934 {
1935     /* The GPIO should be swapped if swap register is set and active */
1936     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
1937                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
1938     int gpio_shift = (gpio_num +
1939                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
1940     uint32_t gpio_mask = (1 << gpio_shift);
1941     uint32_t gpio_reg;
1942
1943     if (gpio_num > MISC_REGISTERS_GPIO_3) {
1944         BLOGE(sc, "Invalid GPIO %d\n", gpio_num);
1945         return (-1);
1946     }
1947
1948     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
1949
1950     /* read GPIO and mask except the float bits */
1951     gpio_reg = (REG_RD(sc, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1952
1953     switch (mode) {
1954     case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1955         BLOGD(sc, DBG_PHY,
1956               "Set GPIO %d (shift %d) -> output low\n",
1957               gpio_num, gpio_shift);
1958         /* clear FLOAT and set CLR */
1959         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1960         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1961         break;
1962
1963     case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1964         BLOGD(sc, DBG_PHY,
1965               "Set GPIO %d (shift %d) -> output high\n",
1966               gpio_num, gpio_shift);
1967         /* clear FLOAT and set SET */
1968         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1969         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1970         break;
1971
1972     case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1973         BLOGD(sc, DBG_PHY,
1974               "Set GPIO %d (shift %d) -> input\n",
1975               gpio_num, gpio_shift);
1976         /* set FLOAT */
1977         gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1978         break;
1979
1980     default:
1981         break;
1982     }
1983
1984     REG_WR(sc, MISC_REG_GPIO, gpio_reg);
1985     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
1986
1987     return (0);
1988 }
1989
1990 static int
1991 bxe_gpio_mult_write(struct bxe_adapter *sc,
1992                     uint8_t          pins,
1993                     uint32_t         mode)
1994 {
1995     uint32_t gpio_reg;
1996
1997     /* any port swapping should be handled by caller */
1998
1999     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2000
2001     /* read GPIO and mask except the float bits */
2002     gpio_reg = REG_RD(sc, MISC_REG_GPIO);
2003     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2004     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_CLR_POS);
2005     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_SET_POS);
2006
2007     switch (mode) {
2008     case MISC_REGISTERS_GPIO_OUTPUT_LOW:
2009         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> output low\n", pins);
2010         /* set CLR */
2011         gpio_reg |= (pins << MISC_REGISTERS_GPIO_CLR_POS);
2012         break;
2013
2014     case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
2015         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> output high\n", pins);
2016         /* set SET */
2017         gpio_reg |= (pins << MISC_REGISTERS_GPIO_SET_POS);
2018         break;
2019
2020     case MISC_REGISTERS_GPIO_INPUT_HI_Z:
2021         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> input\n", pins);
2022         /* set FLOAT */
2023         gpio_reg |= (pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2024         break;
2025
2026     default:
2027         BLOGE(sc, "Invalid GPIO mode assignment %d\n", mode);
2028         bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2029         return (-1);
2030     }
2031
2032     REG_WR(sc, MISC_REG_GPIO, gpio_reg);
2033     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2034
2035     return (0);
2036 }
2037
2038 static int
2039 bxe_gpio_int_write(struct bxe_adapter *sc,
2040                    int              gpio_num,
2041                    uint32_t         mode,
2042                    uint8_t          port)
2043 {
2044     /* The GPIO should be swapped if swap register is set and active */
2045     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
2046                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
2047     int gpio_shift = (gpio_num +
2048                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
2049     uint32_t gpio_mask = (1 << gpio_shift);
2050     uint32_t gpio_reg;
2051
2052     if (gpio_num > MISC_REGISTERS_GPIO_3) {
2053         BLOGE(sc, "Invalid GPIO %d\n", gpio_num);
2054         return (-1);
2055     }
2056
2057     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2058
2059     /* read GPIO int */
2060     gpio_reg = REG_RD(sc, MISC_REG_GPIO_INT);
2061
2062     switch (mode) {
2063     case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
2064         BLOGD(sc, DBG_PHY,
2065               "Clear GPIO INT %d (shift %d) -> output low\n",
2066               gpio_num, gpio_shift);
2067         /* clear SET and set CLR */
2068         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2069         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2070         break;
2071
2072     case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
2073         BLOGD(sc, DBG_PHY,
2074               "Set GPIO INT %d (shift %d) -> output high\n",
2075               gpio_num, gpio_shift);
2076         /* clear CLR and set SET */
2077         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2078         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2079         break;
2080
2081     default:
2082         break;
2083     }
2084
2085     REG_WR(sc, MISC_REG_GPIO_INT, gpio_reg);
2086     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2087
2088     return (0);
2089 }
2090
2091 uint32_t
2092 elink_cb_gpio_read(struct bxe_adapter *sc,
2093                    uint16_t         gpio_num,
2094                    uint8_t          port)
2095 {
2096     return (bxe_gpio_read(sc, gpio_num, port));
2097 }
2098
2099 uint8_t
2100 elink_cb_gpio_write(struct bxe_adapter *sc,
2101                     uint16_t         gpio_num,
2102                     uint8_t          mode, /* 0=low 1=high */
2103                     uint8_t          port)
2104 {
2105     return (bxe_gpio_write(sc, gpio_num, mode, port));
2106 }
2107
2108 uint8_t
2109 elink_cb_gpio_mult_write(struct bxe_adapter *sc,
2110                          uint8_t          pins,
2111                          uint8_t          mode) /* 0=low 1=high */
2112 {
2113     return (bxe_gpio_mult_write(sc, pins, mode));
2114 }
2115
2116 uint8_t
2117 elink_cb_gpio_int_write(struct bxe_adapter *sc,
2118                         uint16_t         gpio_num,
2119                         uint8_t          mode, /* 0=low 1=high */
2120                         uint8_t          port)
2121 {
2122     return (bxe_gpio_int_write(sc, gpio_num, mode, port));
2123 }
2124
2125 void
2126 elink_cb_notify_link_changed(struct bxe_adapter *sc)
2127 {
2128     REG_WR(sc, (MISC_REG_AEU_GENERAL_ATTN_12 +
2129                 (SC_FUNC(sc) * sizeof(uint32_t))), 1);
2130 }
2131
2132 /* send the MCP a request, block until there is a reply */
2133 uint32_t
2134 elink_cb_fw_command(struct bxe_adapter *sc,
2135                     uint32_t         command,
2136                     uint32_t         param)
2137 {
2138     int mb_idx = SC_FW_MB_IDX(sc);
2139     uint32_t seq;
2140     uint32_t rc = 0;
2141     uint32_t cnt = 1;
2142     uint8_t delay = CHIP_REV_IS_SLOW(sc) ? 100 : 10;
2143
2144     BXE_FWMB_LOCK(sc);
2145
2146     seq = ++sc->fw_seq;
2147     SHMEM_WR(sc, func_mb[mb_idx].drv_mb_param, param);
2148     SHMEM_WR(sc, func_mb[mb_idx].drv_mb_header, (command | seq));
2149
2150     BLOGD(sc, DBG_PHY,
2151           "wrote command 0x%08x to FW MB param 0x%08x\n",
2152           (command | seq), param);
2153
2154     /* Let the FW do it's magic. GIve it up to 5 seconds... */
2155     do {
2156         udelay(delay * 1000);
2157         rc = SHMEM_RD(sc, func_mb[mb_idx].fw_mb_header);
2158     } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2159
2160     BLOGD(sc, DBG_PHY,
2161           "[after %d ms] read 0x%x seq 0x%x from FW MB\n",
2162           cnt*delay, rc, seq);
2163
2164     /* is this a reply to our command? */
2165     if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK)) {
2166         rc &= FW_MSG_CODE_MASK;
2167     } else {
2168         /* Ruh-roh! */
2169         BLOGE(sc, "FW failed to respond!\n");
2170         // XXX bxe_fw_dump(sc);
2171         rc = 0;
2172     }
2173
2174     BXE_FWMB_UNLOCK(sc);
2175     return (rc);
2176 }
2177
2178 static uint32_t
2179 bxe_fw_command(struct bxe_adapter *sc,
2180                uint32_t         command,
2181                uint32_t         param)
2182 {
2183     return (elink_cb_fw_command(sc, command, param));
2184 }
2185
2186 static void
2187 __storm_memset_dma_mapping(struct bxe_adapter *sc,
2188                            uint32_t         addr,
2189                            bus_addr_t       mapping)
2190 {
2191     REG_WR(sc, addr, U64_LO(mapping));
2192     REG_WR(sc, (addr + 4), U64_HI(mapping));
2193 }
2194
2195 static void
2196 storm_memset_spq_addr(struct bxe_adapter *sc,
2197                       bus_addr_t       mapping,
2198                       uint16_t         abs_fid)
2199 {
2200     uint32_t addr = (XSEM_REG_FAST_MEMORY +
2201                      XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid));
2202     __storm_memset_dma_mapping(sc, addr, mapping);
2203 }
2204
2205 static void
2206 storm_memset_vf_to_pf(struct bxe_adapter *sc,
2207                       uint16_t         abs_fid,
2208                       uint16_t         pf_id)
2209 {
2210     REG_WR8(sc, (BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2211     REG_WR8(sc, (BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2212     REG_WR8(sc, (BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2213     REG_WR8(sc, (BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2214 }
2215
2216 static void
2217 storm_memset_func_en(struct bxe_adapter *sc,
2218                      uint16_t         abs_fid,
2219                      uint8_t          enable)
2220 {
2221     REG_WR8(sc, (BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2222     REG_WR8(sc, (BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2223     REG_WR8(sc, (BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2224     REG_WR8(sc, (BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2225 }
2226
2227 static void
2228 storm_memset_eq_data(struct bxe_adapter       *sc,
2229                      struct event_ring_data *eq_data,
2230                      uint16_t               pfid)
2231 {
2232     uint32_t addr;
2233     size_t size;
2234
2235     addr = (BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid));
2236     size = sizeof(struct event_ring_data);
2237     ecore_storm_memset_struct(sc, addr, size, (uint32_t *)eq_data);
2238 }
2239
2240 static void
2241 storm_memset_eq_prod(struct bxe_adapter *sc,
2242                      uint16_t         eq_prod,
2243                      uint16_t         pfid)
2244 {
2245     uint32_t addr = (BAR_CSTRORM_INTMEM +
2246                      CSTORM_EVENT_RING_PROD_OFFSET(pfid));
2247     REG_WR16(sc, addr, eq_prod);
2248 }
2249
2250 /*
2251  * Post a slowpath command.
2252  *
2253  * A slowpath command is used to propogate a configuration change through
2254  * the controller in a controlled manner, allowing each STORM processor and
2255  * other H/W blocks to phase in the change.  The commands sent on the
2256  * slowpath are referred to as ramrods.  Depending on the ramrod used the
2257  * completion of the ramrod will occur in different ways.  Here's a
2258  * breakdown of ramrods and how they complete:
2259  *
2260  * RAMROD_CMD_ID_ETH_PORT_SETUP
2261  *   Used to setup the leading connection on a port.  Completes on the
2262  *   Receive Completion Queue (RCQ) of that port (typically fp[0]).
2263  *
2264  * RAMROD_CMD_ID_ETH_CLIENT_SETUP
2265  *   Used to setup an additional connection on a port.  Completes on the
2266  *   RCQ of the multi-queue/RSS connection being initialized.
2267  *
2268  * RAMROD_CMD_ID_ETH_STAT_QUERY
2269  *   Used to force the storm processors to update the statistics database
2270  *   in host memory.  This ramrod is send on the leading connection CID and
2271  *   completes as an index increment of the CSTORM on the default status
2272  *   block.
2273  *
2274  * RAMROD_CMD_ID_ETH_UPDATE
2275  *   Used to update the state of the leading connection, usually to udpate
2276  *   the RSS indirection table.  Completes on the RCQ of the leading
2277  *   connection. (Not currently used under FreeBSD until OS support becomes
2278  *   available.)
2279  *
2280  * RAMROD_CMD_ID_ETH_HALT
2281  *   Used when tearing down a connection prior to driver unload.  Completes
2282  *   on the RCQ of the multi-queue/RSS connection being torn down.  Don't
2283  *   use this on the leading connection.
2284  *
2285  * RAMROD_CMD_ID_ETH_SET_MAC
2286  *   Sets the Unicast/Broadcast/Multicast used by the port.  Completes on
2287  *   the RCQ of the leading connection.
2288  *
2289  * RAMROD_CMD_ID_ETH_CFC_DEL
2290  *   Used when tearing down a conneciton prior to driver unload.  Completes
2291  *   on the RCQ of the leading connection (since the current connection
2292  *   has been completely removed from controller memory).
2293  *
2294  * RAMROD_CMD_ID_ETH_PORT_DEL
2295  *   Used to tear down the leading connection prior to driver unload,
2296  *   typically fp[0].  Completes as an index increment of the CSTORM on the
2297  *   default status block.
2298  *
2299  * RAMROD_CMD_ID_ETH_FORWARD_SETUP
2300  *   Used for connection offload.  Completes on the RCQ of the multi-queue
2301  *   RSS connection that is being offloaded.  (Not currently used under
2302  *   FreeBSD.)
2303  *
2304  * There can only be one command pending per function.
2305  *
2306  * Returns:
2307  *   0 = Success, !0 = Failure.
2308  */
2309
2310 /* must be called under the spq lock */
2311 static inline
2312 struct eth_spe *bxe_sp_get_next(struct bxe_adapter *sc)
2313 {
2314     struct eth_spe *next_spe = sc->spq_prod_bd;
2315
2316     if (sc->spq_prod_bd == sc->spq_last_bd) {
2317         /* wrap back to the first eth_spq */
2318         sc->spq_prod_bd = sc->spq;
2319         sc->spq_prod_idx = 0;
2320     } else {
2321         sc->spq_prod_bd++;
2322         sc->spq_prod_idx++;
2323     }
2324
2325     return (next_spe);
2326 }
2327
2328 /* must be called under the spq lock */
2329 static inline
2330 void bxe_sp_prod_update(struct bxe_adapter *sc)
2331 {
2332     int func = SC_FUNC(sc);
2333
2334     /*
2335      * Make sure that BD data is updated before writing the producer.
2336      * BD data is written to the memory, the producer is read from the
2337      * memory, thus we need a full memory barrier to ensure the ordering.
2338      */
2339     mb();
2340
2341     REG_WR16(sc, (BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func)),
2342              sc->spq_prod_idx);
2343
2344     //    bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
2345     //                      BUS_SPACE_BARRIER_WRITE);
2346 }
2347
2348 /**
2349  * bxe_is_contextless_ramrod - check if the current command ends on EQ
2350  *
2351  * @cmd:      command to check
2352  * @cmd_type: command type
2353  */
2354 static inline
2355 int bxe_is_contextless_ramrod(int cmd,
2356                               int cmd_type)
2357 {
2358     if ((cmd_type == NONE_CONNECTION_TYPE) ||
2359         (cmd == RAMROD_CMD_ID_ETH_FORWARD_SETUP) ||
2360         (cmd == RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES) ||
2361         (cmd == RAMROD_CMD_ID_ETH_FILTER_RULES) ||
2362         (cmd == RAMROD_CMD_ID_ETH_MULTICAST_RULES) ||
2363         (cmd == RAMROD_CMD_ID_ETH_SET_MAC) ||
2364         (cmd == RAMROD_CMD_ID_ETH_RSS_UPDATE)) {
2365         return (TRUE);
2366     } else {
2367         return (FALSE);
2368     }
2369 }
2370
2371 /**
2372  * bxe_sp_post - place a single command on an SP ring
2373  *
2374  * @sc:         driver handle
2375  * @command:    command to place (e.g. SETUP, FILTER_RULES, etc.)
2376  * @cid:        SW CID the command is related to
2377  * @data_hi:    command private data address (high 32 bits)
2378  * @data_lo:    command private data address (low 32 bits)
2379  * @cmd_type:   command type (e.g. NONE, ETH)
2380  *
2381  * SP data is handled as if it's always an address pair, thus data fields are
2382  * not swapped to little endian in upper functions. Instead this function swaps
2383  * data as if it's two uint32 fields.
2384  */
2385 int
2386 bxe_sp_post(struct bxe_adapter *sc,
2387             int              command,
2388             int              cid,
2389             uint32_t         data_hi,
2390             uint32_t         data_lo,
2391             int              cmd_type)
2392 {
2393     struct eth_spe *spe;
2394     uint16_t type;
2395     int common;
2396
2397     common = bxe_is_contextless_ramrod(command, cmd_type);
2398
2399     BXE_SP_LOCK(sc);
2400
2401     if (common) {
2402         if (!atomic_load_acq_long(&sc->eq_spq_left)) {
2403             BLOGE(sc, "EQ ring is full!\n");
2404             BXE_SP_UNLOCK(sc);
2405             return (-1);
2406         }
2407     } else {
2408         if (!atomic_load_acq_long(&sc->cq_spq_left)) {
2409             BLOGE(sc, "SPQ ring is full!\n");
2410             BXE_SP_UNLOCK(sc);
2411             return (-1);
2412         }
2413     }
2414
2415     spe = bxe_sp_get_next(sc);
2416
2417     /* CID needs port number to be encoded int it */
2418     spe->hdr.conn_and_cmd_data =
2419         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) | HW_CID(sc, cid));
2420
2421     type = (cmd_type << SPE_HDR_CONN_TYPE_SHIFT) & SPE_HDR_CONN_TYPE;
2422
2423     /* TBD: Check if it works for VFs */
2424     type |= ((SC_FUNC(sc) << SPE_HDR_FUNCTION_ID_SHIFT) &
2425              SPE_HDR_FUNCTION_ID);
2426
2427     spe->hdr.type = cpu_to_le16(type);
2428
2429     spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2430     spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2431
2432     /*
2433      * It's ok if the actual decrement is issued towards the memory
2434      * somewhere between the lock and unlock. Thus no more explict
2435      * memory barrier is needed.
2436      */
2437     if (common) {
2438         atomic_subtract_acq_long(&sc->eq_spq_left, 1);
2439     } else {
2440         atomic_subtract_acq_long(&sc->cq_spq_left, 1);
2441     }
2442
2443     BLOGD(sc, DBG_SP, "SPQE -> %#jx\n", (uintmax_t)sc->spq_dma.paddr);
2444     BLOGD(sc, DBG_SP, "FUNC_RDATA -> %p / %#jx\n",
2445           BXE_SP(sc, func_rdata), (uintmax_t)BXE_SP_MAPPING(sc, func_rdata));
2446     BLOGD(sc, DBG_SP,
2447           "SPQE[%x] (%x:%x) (cmd, common?) (%d,%d) hw_cid %x data (%x:%x) type(0x%x) left (CQ, EQ) (%lx,%lx)\n",
2448           sc->spq_prod_idx,
2449           (uint32_t)U64_HI(sc->spq_dma.paddr),
2450           (uint32_t)(U64_LO(sc->spq_dma.paddr) + (uint8_t *)sc->spq_prod_bd - (uint8_t *)sc->spq),
2451           command,
2452           common,
2453           HW_CID(sc, cid),
2454           data_hi,
2455           data_lo,
2456           type,
2457           atomic_load_acq_long(&sc->cq_spq_left),
2458           atomic_load_acq_long(&sc->eq_spq_left));
2459
2460     bxe_sp_prod_update(sc);
2461
2462     BXE_SP_UNLOCK(sc);
2463     return (0);
2464 }
2465
2466 /**
2467  * bxe_debug_print_ind_table - prints the indirection table configuration.
2468  *
2469  * @sc: driver hanlde
2470  * @p:  pointer to rss configuration
2471  */
2472 #if 0
2473 static void
2474 bxe_debug_print_ind_table(struct bxe_adapter               *sc,
2475                           struct ecore_config_rss_params *p)
2476 {
2477     int i;
2478
2479     BLOGD(sc, DBG_LOAD, "Setting indirection table to:\n");
2480     BLOGD(sc, DBG_LOAD, "    0x0000: ");
2481     for (i = 0; i < T_ETH_INDIRECTION_TABLE_SIZE; i++) {
2482         BLOGD(sc, DBG_LOAD, "0x%02x ", p->ind_table[i]);
2483
2484         /* Print 4 bytes in a line */
2485         if ((i + 1 < T_ETH_INDIRECTION_TABLE_SIZE) &&
2486             (((i + 1) & 0x3) == 0)) {
2487             BLOGD(sc, DBG_LOAD, "\n");
2488             BLOGD(sc, DBG_LOAD, "0x%04x: ", i + 1);
2489         }
2490     }
2491
2492     BLOGD(sc, DBG_LOAD, "\n");
2493 }
2494 #endif
2495
2496 /*
2497  * FreeBSD Device probe function.
2498  *
2499  * Compares the device found to the driver's list of supported devices and
2500  * reports back to the bsd loader whether this is the right driver for the device.
2501  * This is the driver entry function called from the "kldload" command.
2502  *
2503  * Returns:
2504  *   BUS_PROBE_DEFAULT on success, positive value on failure.
2505  */
2506 #warning "no probe function"
2507
2508 static int
2509 bxe_probe(device_t dev)
2510 {
2511 #if 0
2512     struct bxe_adapter *sc;
2513     struct bxe_device_type *t;
2514     char *descbuf;
2515     uint16_t did, sdid, svid, vid;
2516
2517     /* Find our device structure */
2518     sc = device_get_softc(dev);
2519     sc->pcidev= dev;
2520     t = bxe_devs;
2521
2522     /* Get the data for the device to be probed. */
2523     vid  = pci_get_vendor(dev);
2524     did  = pci_get_device(dev);
2525     svid = pci_get_subvendor(dev);
2526     sdid = pci_get_subdevice(dev);
2527
2528     BLOGD(sc, DBG_LOAD,
2529           "%s(); VID = 0x%04X, DID = 0x%04X, SVID = 0x%04X, "
2530           "SDID = 0x%04X\n", __FUNCTION__, vid, did, svid, sdid);
2531
2532     /* Look through the list of known devices for a match. */
2533     while (t->bxe_name != NULL) {
2534         if ((vid == t->bxe_vid) && (did == t->bxe_did) &&
2535             ((svid == t->bxe_svid) || (t->bxe_svid == PCI_ANY_ID)) &&
2536             ((sdid == t->bxe_sdid) || (t->bxe_sdid == PCI_ANY_ID))) {
2537             descbuf = malloc(BXE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
2538             if (descbuf == NULL)
2539                 return (ENOMEM);
2540
2541             /* Print out the device identity. */
2542             snprintf(descbuf, BXE_DEVDESC_MAX,
2543                      "%s (%c%d) BXE v:%s\n", t->bxe_name,
2544                      (((pcidev_read32(dev, PCIR_REVID) &
2545                         0xf0) >> 4) + 'A'),
2546                      (pcidev_read32(dev, PCIR_REVID) & 0xf),
2547                      BXE_DRIVER_VERSION);
2548
2549             device_set_desc_copy(dev, descbuf);
2550             free(descbuf, M_TEMP);
2551             return (BUS_PROBE_DEFAULT);
2552         }
2553         t++;
2554     }
2555 #endif
2556     return (ENXIO);
2557 }
2558
2559 static void
2560 bxe_init_mutexes(struct bxe_adapter *sc)
2561 {
2562 #if 0
2563 #ifdef BXE_CORE_LOCK_SX
2564     snprintf(sc->core_sx_name, sizeof(sc->core_sx_name),
2565              "bxe%d_core_lock", sc->unit);
2566     sx_init(&sc->core_sx, sc->core_sx_name);
2567 #else
2568     snprintf(sc->core_mtx_name, sizeof(sc->core_mtx_name),
2569              "bxe%d_core_lock", sc->unit);
2570     mtx_init(&sc->core_mtx, sc->core_mtx_name, NULL, MTX_DEF);
2571
2572     snprintf(sc->sp_mtx_name, sizeof(sc->sp_mtx_name),
2573              "bxe%d_sp_lock", sc->unit);
2574     mtx_init(&sc->sp_mtx, sc->sp_mtx_name, NULL, MTX_DEF);
2575
2576     snprintf(sc->dmae_mtx_name, sizeof(sc->dmae_mtx_name),
2577              "bxe%d_dmae_lock", sc->unit);
2578     mtx_init(&sc->dmae_mtx, sc->dmae_mtx_name, NULL, MTX_DEF);
2579
2580     snprintf(sc->port.phy_mtx_name, sizeof(sc->port.phy_mtx_name),
2581              "bxe%d_phy_lock", sc->unit);
2582     mtx_init(&sc->port.phy_mtx, sc->port.phy_mtx_name, NULL, MTX_DEF);
2583
2584     snprintf(sc->fwmb_mtx_name, sizeof(sc->fwmb_mtx_name),
2585              "bxe%d_fwmb_lock", sc->unit);
2586     mtx_init(&sc->fwmb_mtx, sc->fwmb_mtx_name, NULL, MTX_DEF);
2587
2588     snprintf(sc->print_mtx_name, sizeof(sc->print_mtx_name),
2589              "bxe%d_print_lock", sc->unit);
2590     mtx_init(&(sc->print_mtx), sc->print_mtx_name, NULL, MTX_DEF);
2591
2592     snprintf(sc->stats_mtx_name, sizeof(sc->stats_mtx_name),
2593              "bxe%d_stats_lock", sc->unit);
2594     mtx_init(&(sc->stats_mtx), sc->stats_mtx_name, NULL, MTX_DEF);
2595
2596     snprintf(sc->mcast_mtx_name, sizeof(sc->mcast_mtx_name),
2597              "bxe%d_mcast_lock", sc->unit);
2598     mtx_init(&(sc->mcast_mtx), sc->mcast_mtx_name, NULL, MTX_DEF);
2599 #endif
2600 #endif
2601 }
2602
2603 static void
2604 bxe_release_mutexes(struct bxe_adapter *sc)
2605 {
2606 #if 0
2607 #ifdef BXE_CORE_LOCK_SX
2608     sx_destroy(&sc->core_sx);
2609 #else
2610     if (mtx_initialized(&sc->core_mtx)) {
2611         mtx_destroy(&sc->core_mtx);
2612     }
2613 #endif
2614
2615     if (mtx_initialized(&sc->sp_mtx)) {
2616         mtx_destroy(&sc->sp_mtx);
2617     }
2618
2619     if (mtx_initialized(&sc->dmae_mtx)) {
2620         mtx_destroy(&sc->dmae_mtx);
2621     }
2622
2623     if (mtx_initialized(&sc->port.phy_mtx)) {
2624         mtx_destroy(&sc->port.phy_mtx);
2625     }
2626
2627     if (mtx_initialized(&sc->fwmb_mtx)) {
2628         mtx_destroy(&sc->fwmb_mtx);
2629     }
2630
2631     if (mtx_initialized(&sc->print_mtx)) {
2632         mtx_destroy(&sc->print_mtx);
2633     }
2634
2635     if (mtx_initialized(&sc->stats_mtx)) {
2636         mtx_destroy(&sc->stats_mtx);
2637     }
2638
2639     if (mtx_initialized(&sc->mcast_mtx)) {
2640         mtx_destroy(&sc->mcast_mtx);
2641     }
2642 #endif
2643 }
2644
2645 static void
2646 bxe_tx_disable(struct bxe_adapter* sc)
2647 {
2648     if_t ifp = sc->ifp;
2649
2650     /* tell the stack the driver is stopped and TX queue is full */
2651     if (ifp !=  NULL) {
2652         if_setdrvflags(ifp, 0);
2653     }
2654 }
2655
2656 static void
2657 bxe_drv_pulse(struct bxe_adapter *sc)
2658 {
2659     SHMEM_WR(sc, func_mb[SC_FW_MB_IDX(sc)].drv_pulse_mb,
2660              sc->fw_drv_pulse_wr_seq);
2661 }
2662
2663 static inline uint16_t
2664 bxe_tx_avail(struct bxe_adapter *sc,
2665              struct bxe_fastpath *fp)
2666 {
2667     int16_t  used;
2668     uint16_t prod;
2669     uint16_t cons;
2670
2671     prod = fp->tx_bd_prod;
2672     cons = fp->tx_bd_cons;
2673
2674     used = SUB_S16(prod, cons);
2675
2676 #if 0
2677     KASSERT((used < 0), ("used tx bds < 0"));
2678     KASSERT((used > sc->tx_ring_size), ("used tx bds > tx_ring_size"));
2679     KASSERT(((sc->tx_ring_size - used) > MAX_TX_AVAIL),
2680             ("invalid number of tx bds used"));
2681 #endif
2682
2683     return (int16_t)(sc->tx_ring_size) - used;
2684 }
2685
2686 static inline int
2687 bxe_tx_queue_has_work(struct bxe_fastpath *fp)
2688 {
2689     uint16_t hw_cons;
2690
2691     mb(); /* status block fields can change */
2692     hw_cons = le16toh(*fp->tx_cons_sb);
2693     return (hw_cons != fp->tx_pkt_cons);
2694 }
2695
2696 static inline uint8_t
2697 bxe_has_tx_work(struct bxe_fastpath *fp)
2698 {
2699     /* expand this for multi-cos if ever supported */
2700     return (bxe_tx_queue_has_work(fp)) ? TRUE : FALSE;
2701 }
2702
2703 static inline int
2704 bxe_has_rx_work(struct bxe_fastpath *fp)
2705 {
2706     uint16_t rx_cq_cons_sb;
2707
2708     mb(); /* status block fields can change */
2709     rx_cq_cons_sb = le16toh(*fp->rx_cq_cons_sb);
2710     if ((rx_cq_cons_sb & RCQ_MAX) == RCQ_MAX)
2711         rx_cq_cons_sb++;
2712     return (fp->rx_cq_cons != rx_cq_cons_sb);
2713 }
2714
2715 static void
2716 bxe_sp_event(struct bxe_adapter    *sc,
2717              struct bxe_fastpath *fp,
2718              union eth_rx_cqe    *rr_cqe)
2719 {
2720 #if 0
2721     int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
2722     int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
2723     enum ecore_queue_cmd drv_cmd = ECORE_Q_CMD_MAX;
2724     struct ecore_queue_sp_obj *q_obj = &BXE_SP_OBJ(sc, fp).q_obj;
2725
2726     BLOGD(sc, DBG_SP, "fp=%d cid=%d got ramrod #%d state is %x type is %d\n",
2727           fp->index, cid, command, sc->state, rr_cqe->ramrod_cqe.ramrod_type);
2728
2729 #if 0
2730     /*
2731      * If cid is within VF range, replace the slowpath object with the
2732      * one corresponding to this VF
2733      */
2734     if ((cid >= BXE_FIRST_VF_CID) && (cid < BXE_FIRST_VF_CID + BXE_VF_CIDS)) {
2735         bxe_iov_set_queue_sp_obj(sc, cid, &q_obj);
2736     }
2737 #endif
2738
2739     switch (command) {
2740     case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
2741         BLOGD(sc, DBG_SP, "got UPDATE ramrod. CID %d\n", cid);
2742         drv_cmd = ECORE_Q_CMD_UPDATE;
2743         break;
2744
2745     case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
2746         BLOGD(sc, DBG_SP, "got MULTI[%d] setup ramrod\n", cid);
2747         drv_cmd = ECORE_Q_CMD_SETUP;
2748         break;
2749
2750     case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
2751         BLOGD(sc, DBG_SP, "got MULTI[%d] tx-only setup ramrod\n", cid);
2752         drv_cmd = ECORE_Q_CMD_SETUP_TX_ONLY;
2753         break;
2754
2755     case (RAMROD_CMD_ID_ETH_HALT):
2756         BLOGD(sc, DBG_SP, "got MULTI[%d] halt ramrod\n", cid);
2757         drv_cmd = ECORE_Q_CMD_HALT;
2758         break;
2759
2760     case (RAMROD_CMD_ID_ETH_TERMINATE):
2761         BLOGD(sc, DBG_SP, "got MULTI[%d] teminate ramrod\n", cid);
2762         drv_cmd = ECORE_Q_CMD_TERMINATE;
2763         break;
2764
2765     case (RAMROD_CMD_ID_ETH_EMPTY):
2766         BLOGD(sc, DBG_SP, "got MULTI[%d] empty ramrod\n", cid);
2767         drv_cmd = ECORE_Q_CMD_EMPTY;
2768         break;
2769
2770     default:
2771         BLOGD(sc, DBG_SP, "ERROR: unexpected MC reply (%d) on fp[%d]\n",
2772               command, fp->index);
2773         return;
2774     }
2775
2776     if ((drv_cmd != ECORE_Q_CMD_MAX) &&
2777         q_obj->complete_cmd(sc, q_obj, drv_cmd)) {
2778         /*
2779          * q_obj->complete_cmd() failure means that this was
2780          * an unexpected completion.
2781          *
2782          * In this case we don't want to increase the sc->spq_left
2783          * because apparently we haven't sent this command the first
2784          * place.
2785          */
2786         // bxe_panic(sc, ("Unexpected SP completion\n"));
2787         return;
2788     }
2789
2790 #if 0
2791     /* SRIOV: reschedule any 'in_progress' operations */
2792     bxe_iov_sp_event(sc, cid, TRUE);
2793 #endif
2794
2795     atomic_add_acq_long(&sc->cq_spq_left, 1);
2796
2797     BLOGD(sc, DBG_SP, "sc->cq_spq_left 0x%lx\n",
2798           atomic_load_acq_long(&sc->cq_spq_left));
2799
2800 #if 0
2801     if ((drv_cmd == ECORE_Q_CMD_UPDATE) && (IS_FCOE_FP(fp)) &&
2802         (!!bxe_test_bit(ECORE_AFEX_FCOE_Q_UPDATE_PENDING, &sc->sp_state))) {
2803         /*
2804          * If Queue update ramrod is completed for last Queue in AFEX VIF set
2805          * flow, then ACK MCP at the end. Mark pending ACK to MCP bit to
2806          * prevent case that both bits are cleared. At the end of load/unload
2807          * driver checks that sp_state is cleared and this order prevents
2808          * races.
2809          */
2810         bxe_set_bit(ECORE_AFEX_PENDING_VIFSET_MCP_ACK, &sc->sp_state);
2811         wmb();
2812         bxe_clear_bit(ECORE_AFEX_FCOE_Q_UPDATE_PENDING, &sc->sp_state);
2813
2814         /* schedule the sp task as MCP ack is required */
2815         bxe_schedule_sp_task(sc);
2816     }
2817 #endif
2818 #endif
2819 }
2820
2821 /*
2822  * The current mbuf is part of an aggregation. Move the mbuf into the TPA
2823  * aggregation queue, put an empty mbuf back onto the receive chain, and mark
2824  * the current aggregation queue as in-progress.
2825  */
2826 static void
2827 bxe_tpa_start(struct bxe_adapter            *sc,
2828               struct bxe_fastpath         *fp,
2829               uint16_t                    queue,
2830               uint16_t                    cons,
2831               uint16_t                    prod,
2832               struct eth_fast_path_rx_cqe *cqe)
2833 {
2834 #if 0
2835     struct bxe_sw_rx_bd tmp_bd;
2836     struct bxe_sw_rx_bd *rx_buf;
2837     struct eth_rx_bd *rx_bd;
2838     int max_agg_queues;
2839     struct bxe_sw_tpa_info *tpa_info = &fp->rx_tpa_info[queue];
2840     uint16_t index;
2841
2842     BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA START "
2843                        "cons=%d prod=%d\n",
2844           fp->index, queue, cons, prod);
2845
2846     max_agg_queues = MAX_AGG_QS(sc);
2847
2848     KASSERT((queue < max_agg_queues),
2849             ("fp[%02d] invalid aggr queue (%d >= %d)!",
2850              fp->index, queue, max_agg_queues));
2851
2852     KASSERT((tpa_info->state == BXE_TPA_STATE_STOP),
2853             ("fp[%02d].tpa[%02d] starting aggr on queue not stopped!",
2854              fp->index, queue));
2855
2856     /* copy the existing mbuf and mapping from the TPA pool */
2857     tmp_bd = tpa_info->bd;
2858
2859     if (tmp_bd.m == NULL) {
2860         BLOGE(sc, "fp[%02d].tpa[%02d] mbuf not allocated!\n",
2861               fp->index, queue);
2862         /* XXX Error handling? */
2863         return;
2864     }
2865
2866     /* change the TPA queue to the start state */
2867     tpa_info->state            = BXE_TPA_STATE_START;
2868     tpa_info->placement_offset = cqe->placement_offset;
2869     tpa_info->parsing_flags    = le16toh(cqe->pars_flags.flags);
2870     tpa_info->vlan_tag         = le16toh(cqe->vlan_tag);
2871     tpa_info->len_on_bd        = le16toh(cqe->len_on_bd);
2872
2873     fp->rx_tpa_queue_used |= (1 << queue);
2874
2875     /*
2876      * If all the buffer descriptors are filled with mbufs then fill in
2877      * the current consumer index with a new BD. Else if a maximum Rx
2878      * buffer limit is imposed then fill in the next producer index.
2879      */
2880     index = (sc->max_rx_bufs != RX_BD_USABLE) ?
2881                 prod : cons;
2882
2883     /* move the received mbuf and mapping to TPA pool */
2884     tpa_info->bd = fp->rx_mbuf_chain[cons];
2885
2886     /* release any existing RX BD mbuf mappings */
2887     if (cons != index) {
2888         rx_buf = &fp->rx_mbuf_chain[cons];
2889
2890         if (rx_buf->m_map != NULL) {
2891             bus_dmamap_sync(fp->rx_mbuf_tag, rx_buf->m_map,
2892                             BUS_DMASYNC_POSTREAD);
2893             bus_dmamap_unload(fp->rx_mbuf_tag, rx_buf->m_map);
2894         }
2895
2896         /*
2897          * We get here when the maximum number of rx buffers is less than
2898          * RX_BD_USABLE. The mbuf is already saved above so it's OK to NULL
2899          * it out here without concern of a memory leak.
2900          */
2901         fp->rx_mbuf_chain[cons].m = NULL;
2902     }
2903
2904     /* update the Rx SW BD with the mbuf info from the TPA pool */
2905     fp->rx_mbuf_chain[index] = tmp_bd;
2906
2907     /* update the Rx BD with the empty mbuf phys address from the TPA pool */
2908     rx_bd = &fp->rx_chain[index];
2909     rx_bd->addr_hi = htole32(U64_HI(tpa_info->seg.ds_addr));
2910     rx_bd->addr_lo = htole32(U64_LO(tpa_info->seg.ds_addr));
2911 #endif
2912 }
2913 #if 0
2914 /*
2915  * When a TPA aggregation is completed, loop through the individual mbufs
2916  * of the aggregation, combining them into a single mbuf which will be sent
2917  * up the stack. Refill all freed SGEs with mbufs as we go along.
2918  */
2919 static int
2920 bxe_fill_frag_mbuf(struct bxe_adapter          *sc,
2921                    struct bxe_fastpath       *fp,
2922                    struct bxe_sw_tpa_info    *tpa_info,
2923                    uint16_t                  queue,
2924                    uint16_t                  pages,
2925                    struct mbuf               *m,
2926                                struct eth_end_agg_rx_cqe *cqe,
2927                    uint16_t                  cqe_idx)
2928 {
2929     struct mbuf *m_frag;
2930     uint32_t frag_len, frag_size, i;
2931     uint16_t sge_idx;
2932     int rc = 0;
2933     int j;
2934
2935     frag_size = le16toh(cqe->pkt_len) - tpa_info->len_on_bd;
2936
2937     BLOGD(sc, DBG_LRO,
2938           "fp[%02d].tpa[%02d] TPA fill len_on_bd=%d frag_size=%d pages=%d\n",
2939           fp->index, queue, tpa_info->len_on_bd, frag_size, pages);
2940
2941     /* make sure the aggregated frame is not too big to handle */
2942     if (pages > 8 * PAGES_PER_SGE) {
2943         BLOGE(sc, "fp[%02d].sge[0x%04x] has too many pages (%d)! "
2944                   "pkt_len=%d len_on_bd=%d frag_size=%d\n",
2945               fp->index, cqe_idx, pages, le16toh(cqe->pkt_len),
2946               tpa_info->len_on_bd, frag_size);
2947         bxe_panic(sc, ("sge page count error\n"));
2948         return (EINVAL);
2949     }
2950
2951     /*
2952      * Scan through the scatter gather list pulling individual mbufs into a
2953      * single mbuf for the host stack.
2954      */
2955     for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
2956         sge_idx = RX_SGE(le16toh(cqe->sgl_or_raw_data.sgl[j]));
2957
2958         /*
2959          * Firmware gives the indices of the SGE as if the ring is an array
2960          * (meaning that the "next" element will consume 2 indices).
2961          */
2962         frag_len = min(frag_size, (uint32_t)(SGE_PAGES));
2963
2964         BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA fill i=%d j=%d "
2965                            "sge_idx=%d frag_size=%d frag_len=%d\n",
2966               fp->index, queue, i, j, sge_idx, frag_size, frag_len);
2967
2968         m_frag = fp->rx_sge_mbuf_chain[sge_idx].m;
2969
2970         /* allocate a new mbuf for the SGE */
2971         rc = bxe_alloc_rx_sge_mbuf(fp, sge_idx);
2972         if (rc) {
2973             /* Leave all remaining SGEs in the ring! */
2974             return (rc);
2975         }
2976
2977         /* update the fragment length */
2978         m_frag->m_len = frag_len;
2979
2980         /* concatenate the fragment to the head mbuf */
2981         m_cat(m, m_frag);
2982         fp->eth_q_stats.mbuf_alloc_sge--;
2983
2984         /* update the TPA mbuf size and remaining fragment size */
2985         m->m_pkthdr.len += frag_len;
2986         frag_size -= frag_len;
2987     }
2988
2989     BLOGD(sc, DBG_LRO,
2990           "fp[%02d].tpa[%02d] TPA fill done frag_size=%d\n",
2991           fp->index, queue, frag_size);
2992
2993     return (rc);
2994 }
2995 #endif
2996 static inline void
2997 bxe_clear_sge_mask_next_elems(struct bxe_fastpath *fp)
2998 {
2999     int i, j;
3000
3001     for (i = 1; i <= RX_SGE_NUM_PAGES; i++) {
3002         int idx = RX_SGE_TOTAL_PER_PAGE * i - 1;
3003
3004         for (j = 0; j < 2; j++) {
3005             BIT_VEC64_CLEAR_BIT(fp->sge_mask, idx);
3006             idx--;
3007         }
3008     }
3009 }
3010
3011 static inline void
3012 bxe_init_sge_ring_bit_mask(struct bxe_fastpath *fp)
3013 {
3014     /* set the mask to all 1's, it's faster to compare to 0 than to 0xf's */
3015     memset(fp->sge_mask, 0xff, sizeof(fp->sge_mask));
3016
3017     /*
3018      * Clear the two last indices in the page to 1. These are the indices that
3019      * correspond to the "next" element, hence will never be indicated and
3020      * should be removed from the calculations.
3021      */
3022     bxe_clear_sge_mask_next_elems(fp);
3023 }
3024
3025 static inline void
3026 bxe_update_last_max_sge(struct bxe_fastpath *fp,
3027                         uint16_t            idx)
3028 {
3029     uint16_t last_max = fp->last_max_sge;
3030
3031     if (SUB_S16(idx, last_max) > 0) {
3032         fp->last_max_sge = idx;
3033     }
3034 }
3035
3036 static inline void
3037 bxe_update_sge_prod(struct bxe_adapter          *sc,
3038                     struct bxe_fastpath       *fp,
3039                     uint16_t                  sge_len,
3040                     struct eth_end_agg_rx_cqe *cqe)
3041 {
3042     uint16_t last_max, last_elem, first_elem;
3043     uint16_t delta = 0;
3044     uint16_t i;
3045
3046     if (!sge_len) {
3047         return;
3048     }
3049
3050     /* first mark all used pages */
3051     for (i = 0; i < sge_len; i++) {
3052         BIT_VEC64_CLEAR_BIT(fp->sge_mask,
3053                             RX_SGE(le16toh(cqe->sgl_or_raw_data.sgl[i])));
3054     }
3055
3056     BLOGD(sc, DBG_LRO,
3057           "fp[%02d] fp_cqe->sgl[%d] = %d\n",
3058           fp->index, sge_len - 1,
3059           le16toh(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
3060
3061     /* assume that the last SGE index is the biggest */
3062     bxe_update_last_max_sge(fp,
3063                             le16toh(cqe->sgl_or_raw_data.sgl[sge_len - 1]));
3064
3065     last_max = RX_SGE(fp->last_max_sge);
3066     last_elem = last_max >> BIT_VEC64_ELEM_SHIFT;
3067     first_elem = RX_SGE(fp->rx_sge_prod) >> BIT_VEC64_ELEM_SHIFT;
3068
3069     /* if ring is not full */
3070     if (last_elem + 1 != first_elem) {
3071         last_elem++;
3072     }
3073
3074     /* now update the prod */
3075     for (i = first_elem; i != last_elem; i = RX_SGE_NEXT_MASK_ELEM(i)) {
3076         if (fp->sge_mask[i]) {
3077             break;
3078         }
3079
3080         fp->sge_mask[i] = BIT_VEC64_ELEM_ONE_MASK;
3081         delta += BIT_VEC64_ELEM_SZ;
3082     }
3083
3084     if (delta > 0) {
3085         fp->rx_sge_prod += delta;
3086         /* clear page-end entries */
3087         bxe_clear_sge_mask_next_elems(fp);
3088     }
3089
3090     BLOGD(sc, DBG_LRO,
3091           "fp[%02d] fp->last_max_sge=%d fp->rx_sge_prod=%d\n",
3092           fp->index, fp->last_max_sge, fp->rx_sge_prod);
3093 }
3094
3095 /*
3096  * The aggregation on the current TPA queue has completed. Pull the individual
3097  * mbuf fragments together into a single mbuf, perform all necessary checksum
3098  * calculations, and send the resuting mbuf to the stack.
3099  */
3100 static void
3101 bxe_tpa_stop(struct bxe_adapter          *sc,
3102              struct bxe_fastpath       *fp,
3103              struct bxe_sw_tpa_info    *tpa_info,
3104              uint16_t                  queue,
3105              uint16_t                  pages,
3106                          struct eth_end_agg_rx_cqe *cqe,
3107              uint16_t                  cqe_idx)
3108 {
3109 #if 0
3110     if_t ifp = sc->ifp;
3111     struct mbuf *m;
3112     int rc = 0;
3113
3114     BLOGD(sc, DBG_LRO,
3115           "fp[%02d].tpa[%02d] pad=%d pkt_len=%d pages=%d vlan=%d\n",
3116           fp->index, queue, tpa_info->placement_offset,
3117           le16toh(cqe->pkt_len), pages, tpa_info->vlan_tag);
3118
3119     m = tpa_info->bd.m;
3120
3121     /* allocate a replacement before modifying existing mbuf */
3122     rc = bxe_alloc_rx_tpa_mbuf(fp, queue);
3123     if (rc) {
3124         /* drop the frame and log an error */
3125         fp->eth_q_stats.rx_soft_errors++;
3126         goto bxe_tpa_stop_exit;
3127     }
3128
3129     /* we have a replacement, fixup the current mbuf */
3130     m_adj(m, tpa_info->placement_offset);
3131     m->m_pkthdr.len = m->m_len = tpa_info->len_on_bd;
3132
3133     /* mark the checksums valid (taken care of by the firmware) */
3134     fp->eth_q_stats.rx_ofld_frames_csum_ip++;
3135     fp->eth_q_stats.rx_ofld_frames_csum_tcp_udp++;
3136     m->m_pkthdr.csum_data = 0xffff;
3137     m->m_pkthdr.csum_flags |= (CSUM_IP_CHECKED |
3138                                CSUM_IP_VALID   |
3139                                CSUM_DATA_VALID |
3140                                CSUM_PSEUDO_HDR);
3141
3142     /* aggregate all of the SGEs into a single mbuf */
3143     rc = bxe_fill_frag_mbuf(sc, fp, tpa_info, queue, pages, m, cqe, cqe_idx);
3144     if (rc) {
3145         /* drop the packet and log an error */
3146         fp->eth_q_stats.rx_soft_errors++;
3147         m_freem(m);
3148     } else {
3149         if (tpa_info->parsing_flags & PARSING_FLAGS_VLAN) {
3150             m->m_pkthdr.ether_vtag = tpa_info->vlan_tag;
3151             m->m_flags |= M_VLANTAG;
3152         }
3153
3154         /* assign packet to this interface interface */
3155         if_setrcvif(m, ifp);
3156
3157 #if __FreeBSD_version >= 800000
3158         /* specify what RSS queue was used for this flow */
3159         m->m_pkthdr.flowid = fp->index;
3160         M_HASHTYPE_SET(m, M_HASHTYPE_OPAQUE);
3161 #endif
3162
3163         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
3164         fp->eth_q_stats.rx_tpa_pkts++;
3165
3166         /* pass the frame to the stack */
3167         if_input(ifp, m);
3168     }
3169
3170     /* we passed an mbuf up the stack or dropped the frame */
3171     fp->eth_q_stats.mbuf_alloc_tpa--;
3172
3173 bxe_tpa_stop_exit:
3174
3175     fp->rx_tpa_info[queue].state = BXE_TPA_STATE_STOP;
3176     fp->rx_tpa_queue_used &= ~(1 << queue);
3177 #endif
3178 }
3179
3180 static uint8_t
3181 bxe_rxeof(struct bxe_adapter    *sc,
3182           struct bxe_fastpath *fp)
3183 {
3184 #if 0
3185     if_t ifp = sc->ifp;
3186     uint16_t bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
3187     uint16_t hw_cq_cons, sw_cq_cons, sw_cq_prod;
3188     int rx_pkts = 0;
3189     int rc;
3190
3191     BXE_FP_RX_LOCK(fp);
3192
3193     /* CQ "next element" is of the size of the regular element */
3194     hw_cq_cons = le16toh(*fp->rx_cq_cons_sb);
3195     if ((hw_cq_cons & RCQ_USABLE_PER_PAGE) == RCQ_USABLE_PER_PAGE) {
3196         hw_cq_cons++;
3197     }
3198
3199     bd_cons = fp->rx_bd_cons;
3200     bd_prod = fp->rx_bd_prod;
3201     bd_prod_fw = bd_prod;
3202     sw_cq_cons = fp->rx_cq_cons;
3203     sw_cq_prod = fp->rx_cq_prod;
3204
3205     /*
3206      * Memory barrier necessary as speculative reads of the rx
3207      * buffer can be ahead of the index in the status block
3208      */
3209     rmb();
3210
3211     BLOGD(sc, DBG_RX,
3212           "fp[%02d] Rx START hw_cq_cons=%u sw_cq_cons=%u\n",
3213           fp->index, hw_cq_cons, sw_cq_cons);
3214
3215     while (sw_cq_cons != hw_cq_cons) {
3216         struct bxe_sw_rx_bd *rx_buf = NULL;
3217         union eth_rx_cqe *cqe;
3218         struct eth_fast_path_rx_cqe *cqe_fp;
3219         uint8_t cqe_fp_flags;
3220         enum eth_rx_cqe_type cqe_fp_type;
3221         uint16_t len, pad;
3222         struct mbuf *m = NULL;
3223
3224         comp_ring_cons = RCQ(sw_cq_cons);
3225         bd_prod = RX_BD(bd_prod);
3226         bd_cons = RX_BD(bd_cons);
3227
3228         cqe          = &fp->rcq_chain[comp_ring_cons];
3229         cqe_fp       = &cqe->fast_path_cqe;
3230         cqe_fp_flags = cqe_fp->type_error_flags;
3231         cqe_fp_type  = cqe_fp_flags & ETH_FAST_PATH_RX_CQE_TYPE;
3232
3233         BLOGD(sc, DBG_RX,
3234               "fp[%02d] Rx hw_cq_cons=%d hw_sw_cons=%d "
3235               "BD prod=%d cons=%d CQE type=0x%x err=0x%x "
3236               "status=0x%x rss_hash=0x%x vlan=0x%x len=%u\n",
3237               fp->index,
3238               hw_cq_cons,
3239               sw_cq_cons,
3240               bd_prod,
3241               bd_cons,
3242               CQE_TYPE(cqe_fp_flags),
3243               cqe_fp_flags,
3244               cqe_fp->status_flags,
3245               le32toh(cqe_fp->rss_hash_result),
3246               le16toh(cqe_fp->vlan_tag),
3247               le16toh(cqe_fp->pkt_len_or_gro_seg_len));
3248
3249         /* is this a slowpath msg? */
3250         if (__predict_false(CQE_TYPE_SLOW(cqe_fp_type))) {
3251             bxe_sp_event(sc, fp, cqe);
3252             goto next_cqe;
3253         }
3254
3255         rx_buf = &fp->rx_mbuf_chain[bd_cons];
3256
3257         if (!CQE_TYPE_FAST(cqe_fp_type)) {
3258             struct bxe_sw_tpa_info *tpa_info;
3259             uint16_t frag_size, pages;
3260             uint8_t queue;
3261
3262 #if 0
3263             /* sanity check */
3264             if (!fp->tpa_enable &&
3265                 (CQE_TYPE_START(cqe_fp_type) || CQE_TYPE_STOP(cqe_fp_type))) {
3266                 BLOGE(sc, "START/STOP packet while !tpa_enable type (0x%x)\n",
3267                       CQE_TYPE(cqe_fp_type));
3268             }
3269 #endif
3270
3271             if (CQE_TYPE_START(cqe_fp_type)) {
3272                 bxe_tpa_start(sc, fp, cqe_fp->queue_index,
3273                               bd_cons, bd_prod, cqe_fp);
3274                 m = NULL; /* packet not ready yet */
3275                 goto next_rx;
3276             }
3277
3278             KASSERT(CQE_TYPE_STOP(cqe_fp_type),
3279                     ("CQE type is not STOP! (0x%x)\n", cqe_fp_type));
3280
3281             queue = cqe->end_agg_cqe.queue_index;
3282             tpa_info = &fp->rx_tpa_info[queue];
3283
3284             BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA STOP\n",
3285                   fp->index, queue);
3286
3287             frag_size = (le16toh(cqe->end_agg_cqe.pkt_len) -
3288                          tpa_info->len_on_bd);
3289             pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
3290
3291             bxe_tpa_stop(sc, fp, tpa_info, queue, pages,
3292                          &cqe->end_agg_cqe, comp_ring_cons);
3293
3294             bxe_update_sge_prod(sc, fp, pages, &cqe->end_agg_cqe);
3295
3296             goto next_cqe;
3297         }
3298
3299         /* non TPA */
3300
3301         /* is this an error packet? */
3302         if (__predict_false(cqe_fp_flags &
3303                             ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG)) {
3304             BLOGE(sc, "flags 0x%x rx packet %u\n", cqe_fp_flags, sw_cq_cons);
3305             fp->eth_q_stats.rx_soft_errors++;
3306             goto next_rx;
3307         }
3308
3309         len = le16toh(cqe_fp->pkt_len_or_gro_seg_len);
3310         pad = cqe_fp->placement_offset;
3311
3312         m = rx_buf->m;
3313
3314         if (__predict_false(m == NULL)) {
3315             BLOGE(sc, "No mbuf in rx chain descriptor %d for fp[%02d]\n",
3316                   bd_cons, fp->index);
3317             goto next_rx;
3318         }
3319
3320         /* XXX double copy if packet length under a threshold */
3321
3322         /*
3323          * If all the buffer descriptors are filled with mbufs then fill in
3324          * the current consumer index with a new BD. Else if a maximum Rx
3325          * buffer limit is imposed then fill in the next producer index.
3326          */
3327         rc = bxe_alloc_rx_bd_mbuf(fp, bd_cons,
3328                                   (sc->max_rx_bufs != RX_BD_USABLE) ?
3329                                       bd_prod : bd_cons);
3330         if (rc != 0) {
3331             BLOGE(sc, "mbuf alloc fail for fp[%02d] rx chain (%d)\n",
3332                   fp->index, rc);
3333             fp->eth_q_stats.rx_soft_errors++;
3334
3335             if (sc->max_rx_bufs != RX_BD_USABLE) {
3336                 /* copy this consumer index to the producer index */
3337                 memcpy(&fp->rx_mbuf_chain[bd_prod], rx_buf,
3338                        sizeof(struct bxe_sw_rx_bd));
3339                 memset(rx_buf, 0, sizeof(struct bxe_sw_rx_bd));
3340             }
3341
3342             goto next_rx;
3343         }
3344
3345         /* current mbuf was detached from the bd */
3346         fp->eth_q_stats.mbuf_alloc_rx--;
3347
3348         /* we allocated a replacement mbuf, fixup the current one */
3349         m_adj(m, pad);
3350         m->m_pkthdr.len = m->m_len = len;
3351
3352         /* assign packet to this interface interface */
3353         if_setrcvif(m, ifp);
3354
3355         /* assume no hardware checksum has complated */
3356         m->m_pkthdr.csum_flags = 0;
3357
3358         /* validate checksum if offload enabled */
3359         if (if_getcapenable(ifp) & IFCAP_RXCSUM) {
3360             /* check for a valid IP frame */
3361             if (!(cqe->fast_path_cqe.status_flags &
3362                   ETH_FAST_PATH_RX_CQE_IP_XSUM_NO_VALIDATION_FLG)) {
3363                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
3364                 if (__predict_false(cqe_fp_flags &
3365                                     ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG)) {
3366                     fp->eth_q_stats.rx_hw_csum_errors++;
3367                 } else {
3368                     fp->eth_q_stats.rx_ofld_frames_csum_ip++;
3369                     m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
3370                 }
3371             }
3372
3373             /* check for a valid TCP/UDP frame */
3374             if (!(cqe->fast_path_cqe.status_flags &
3375                   ETH_FAST_PATH_RX_CQE_L4_XSUM_NO_VALIDATION_FLG)) {
3376                 if (__predict_false(cqe_fp_flags &
3377                                     ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG)) {
3378                     fp->eth_q_stats.rx_hw_csum_errors++;
3379                 } else {
3380                     fp->eth_q_stats.rx_ofld_frames_csum_tcp_udp++;
3381                     m->m_pkthdr.csum_data = 0xFFFF;
3382                     m->m_pkthdr.csum_flags |= (CSUM_DATA_VALID |
3383                                                CSUM_PSEUDO_HDR);
3384                 }
3385             }
3386         }
3387
3388         /* if there is a VLAN tag then flag that info */
3389         if (cqe->fast_path_cqe.pars_flags.flags & PARSING_FLAGS_VLAN) {
3390             m->m_pkthdr.ether_vtag = cqe->fast_path_cqe.vlan_tag;
3391             m->m_flags |= M_VLANTAG;
3392         }
3393
3394 #if __FreeBSD_version >= 800000
3395         /* specify what RSS queue was used for this flow */
3396         m->m_pkthdr.flowid = fp->index;
3397         M_HASHTYPE_SET(m, M_HASHTYPE_OPAQUE);
3398 #endif
3399
3400 next_rx:
3401
3402         bd_cons    = RX_BD_NEXT(bd_cons);
3403         bd_prod    = RX_BD_NEXT(bd_prod);
3404         bd_prod_fw = RX_BD_NEXT(bd_prod_fw);
3405
3406         /* pass the frame to the stack */
3407         if (m != NULL) {
3408             if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
3409             rx_pkts++;
3410             if_input(ifp, m);
3411         }
3412
3413 next_cqe:
3414
3415         sw_cq_prod = RCQ_NEXT(sw_cq_prod);
3416         sw_cq_cons = RCQ_NEXT(sw_cq_cons);
3417
3418         /* limit spinning on the queue */
3419         if (rx_pkts == sc->rx_budget) {
3420             fp->eth_q_stats.rx_budget_reached++;
3421             break;
3422         }
3423     } /* while work to do */
3424
3425     fp->rx_bd_cons = bd_cons;
3426     fp->rx_bd_prod = bd_prod_fw;
3427     fp->rx_cq_cons = sw_cq_cons;
3428     fp->rx_cq_prod = sw_cq_prod;
3429
3430     /* Update producers */
3431     bxe_update_rx_prod(sc, fp, bd_prod_fw, sw_cq_prod, fp->rx_sge_prod);
3432
3433     fp->eth_q_stats.rx_pkts += rx_pkts;
3434     fp->eth_q_stats.rx_calls++;
3435
3436     BXE_FP_RX_UNLOCK(fp);
3437
3438     return (sw_cq_cons != hw_cq_cons);
3439 #endif
3440 }
3441
3442 static uint16_t
3443 bxe_free_tx_pkt(struct bxe_adapter    *sc,
3444                 struct bxe_fastpath *fp,
3445                 uint16_t            idx)
3446 {
3447 #if 0
3448     struct bxe_sw_tx_bd *tx_buf = &fp->tx_mbuf_chain[idx];
3449     struct eth_tx_start_bd *tx_start_bd;
3450     uint16_t bd_idx = TX_BD(tx_buf->first_bd);
3451     uint16_t new_cons;
3452     int nbd;
3453
3454     /* unmap the mbuf from non-paged memory */
3455     bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
3456
3457     tx_start_bd = &fp->tx_chain[bd_idx].start_bd;
3458     nbd = le16toh(tx_start_bd->nbd) - 1;
3459     // this #if 0 was already here in fbsd
3460 #if 0
3461     if ((nbd - 1) > (MAX_MBUF_FRAGS + 2)) {
3462         bxe_panic(sc, ("BAD nbd!\n"));
3463     }
3464 #endif
3465
3466     new_cons = (tx_buf->first_bd + nbd);
3467     // this #if 0 was already here in fbsd
3468 #if 0
3469     struct eth_tx_bd *tx_data_bd;
3470
3471     /*
3472      * The following code doesn't do anything but is left here
3473      * for clarity on what the new value of new_cons skipped.
3474      */
3475
3476     /* get the next bd */
3477     bd_idx = TX_BD(TX_BD_NEXT(bd_idx));
3478
3479     /* skip the parse bd */
3480     --nbd;
3481     bd_idx = TX_BD(TX_BD_NEXT(bd_idx));
3482
3483     /* skip the TSO split header bd since they have no mapping */
3484     if (tx_buf->flags & BXE_TSO_SPLIT_BD) {
3485         --nbd;
3486         bd_idx = TX_BD(TX_BD_NEXT(bd_idx));
3487     }
3488
3489     /* now free frags */
3490     while (nbd > 0) {
3491         tx_data_bd = &fp->tx_chain[bd_idx].reg_bd;
3492         if (--nbd) {
3493             bd_idx = TX_BD(TX_BD_NEXT(bd_idx));
3494         }
3495     }
3496 #endif
3497
3498     /* free the mbuf */
3499     if (tx_buf->m != NULL) {
3500         m_freem(tx_buf->m);
3501         fp->eth_q_stats.mbuf_alloc_tx--;
3502     } else {
3503         fp->eth_q_stats.tx_chain_lost_mbuf++;
3504     }
3505
3506     tx_buf->m = NULL;
3507     tx_buf->first_bd = 0;
3508
3509     return (new_cons);
3510 #endif
3511 }
3512
3513 /* transmit timeout watchdog */
3514 static int
3515 bxe_watchdog(struct bxe_adapter    *sc,
3516              struct bxe_fastpath *fp)
3517 {
3518 #if 0
3519     BXE_FP_TX_LOCK(fp);
3520
3521     if ((fp->watchdog_timer == 0) || (--fp->watchdog_timer)) {
3522         BXE_FP_TX_UNLOCK(fp);
3523         return (0);
3524     }
3525
3526     BLOGE(sc, "TX watchdog timeout on fp[%02d], resetting!\n", fp->index);
3527
3528     BXE_FP_TX_UNLOCK(fp);
3529
3530     atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT);
3531     taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
3532 #endif
3533     return (-1);
3534 }
3535
3536 /* processes transmit completions */
3537 static uint8_t
3538 bxe_txeof(struct bxe_adapter    *sc,
3539           struct bxe_fastpath *fp)
3540 {
3541 #if 0
3542     if_t ifp = sc->ifp;
3543     uint16_t bd_cons, hw_cons, sw_cons, pkt_cons;
3544     uint16_t tx_bd_avail;
3545
3546     BXE_FP_TX_LOCK_ASSERT(fp);
3547
3548     bd_cons = fp->tx_bd_cons;
3549     hw_cons = le16toh(*fp->tx_cons_sb);
3550     sw_cons = fp->tx_pkt_cons;
3551
3552     while (sw_cons != hw_cons) {
3553         pkt_cons = TX_BD(sw_cons);
3554
3555         BLOGD(sc, DBG_TX,
3556               "TX: fp[%d]: hw_cons=%u sw_cons=%u pkt_cons=%u\n",
3557               fp->index, hw_cons, sw_cons, pkt_cons);
3558
3559         bd_cons = bxe_free_tx_pkt(sc, fp, pkt_cons);
3560
3561         sw_cons++;
3562     }
3563
3564     fp->tx_pkt_cons = sw_cons;
3565     fp->tx_bd_cons  = bd_cons;
3566
3567     BLOGD(sc, DBG_TX,
3568           "TX done: fp[%d]: hw_cons=%u sw_cons=%u sw_prod=%u\n",
3569           fp->index, hw_cons, fp->tx_pkt_cons, fp->tx_pkt_prod);
3570
3571     mb();
3572
3573     tx_bd_avail = bxe_tx_avail(sc, fp);
3574
3575     if (tx_bd_avail < BXE_TX_CLEANUP_THRESHOLD) {
3576         if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
3577     } else {
3578         if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
3579     }
3580
3581     if (fp->tx_pkt_prod != fp->tx_pkt_cons) {
3582         /* reset the watchdog timer if there are pending transmits */
3583         fp->watchdog_timer = BXE_TX_TIMEOUT;
3584         return (TRUE);
3585     } else {
3586         /* clear watchdog when there are no pending transmits */
3587         fp->watchdog_timer = 0;
3588         return (FALSE);
3589     }
3590 #endif
3591 }
3592
3593 static void
3594 bxe_drain_tx_queues(struct bxe_adapter *sc)
3595 {
3596 #if 0
3597     struct bxe_fastpath *fp;
3598     int i, count;
3599
3600     /* wait until all TX fastpath tasks have completed */
3601     for (i = 0; i < sc->num_queues; i++) {
3602         fp = &sc->fp[i];
3603
3604         count = 1000;
3605
3606         while (bxe_has_tx_work(fp)) {
3607
3608             BXE_FP_TX_LOCK(fp);
3609             bxe_txeof(sc, fp);
3610             BXE_FP_TX_UNLOCK(fp);
3611
3612             if (count == 0) {
3613                 BLOGE(sc, "Timeout waiting for fp[%d] "
3614                           "transmits to complete!\n", i);
3615                 bxe_panic(sc, ("tx drain failure\n"));
3616                 return;
3617             }
3618
3619             count--;
3620             udelay(1000);
3621             rmb();
3622         }
3623     }
3624 #endif
3625     return;
3626 }
3627
3628 static int
3629 bxe_del_all_macs(struct bxe_adapter          *sc,
3630                  struct ecore_vlan_mac_obj *mac_obj,
3631                  int                       mac_type,
3632                  uint8_t                   wait_for_comp)
3633 {
3634 #if 0
3635     unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
3636     int rc;
3637
3638     /* wait for completion of requested */
3639     if (wait_for_comp) {
3640         bxe_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
3641     }
3642
3643     /* Set the mac type of addresses we want to clear */
3644     bxe_set_bit(mac_type, &vlan_mac_flags);
3645
3646     rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
3647     if (rc < 0) {
3648         BLOGE(sc, "Failed to delete MACs (%d)\n", rc);
3649     }
3650
3651     return (rc);
3652 #endif
3653     return -1;
3654 }
3655
3656 static int
3657 bxe_fill_accept_flags(struct bxe_adapter *sc,
3658                       uint32_t         rx_mode,
3659                       unsigned long    *rx_accept_flags,
3660                       unsigned long    *tx_accept_flags)
3661 {
3662 #if 0
3663     /* Clear the flags first */
3664     *rx_accept_flags = 0;
3665     *tx_accept_flags = 0;
3666
3667     switch (rx_mode) {
3668     case BXE_RX_MODE_NONE:
3669         /*
3670          * 'drop all' supersedes any accept flags that may have been
3671          * passed to the function.
3672          */
3673         break;
3674
3675     case BXE_RX_MODE_NORMAL:
3676         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3677         bxe_set_bit(ECORE_ACCEPT_MULTICAST, rx_accept_flags);
3678         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3679
3680         /* internal switching mode */
3681         bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3682         bxe_set_bit(ECORE_ACCEPT_MULTICAST, tx_accept_flags);
3683         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3684
3685         break;
3686
3687     case BXE_RX_MODE_ALLMULTI:
3688         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3689         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, rx_accept_flags);
3690         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3691
3692         /* internal switching mode */
3693         bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3694         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, tx_accept_flags);
3695         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3696
3697         break;
3698
3699     case BXE_RX_MODE_PROMISC:
3700         /*
3701          * According to deffinition of SI mode, iface in promisc mode
3702          * should receive matched and unmatched (in resolution of port)
3703          * unicast packets.
3704          */
3705         bxe_set_bit(ECORE_ACCEPT_UNMATCHED, rx_accept_flags);
3706         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3707         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, rx_accept_flags);
3708         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3709
3710         /* internal switching mode */
3711         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, tx_accept_flags);
3712         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3713
3714         if (IS_MF_SI(sc)) {
3715             bxe_set_bit(ECORE_ACCEPT_ALL_UNICAST, tx_accept_flags);
3716         } else {
3717             bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3718         }
3719
3720         break;
3721
3722     default:
3723         BLOGE(sc, "Unknown rx_mode (%d)\n", rx_mode);
3724         return (-1);
3725     }
3726
3727     /* Set ACCEPT_ANY_VLAN as we do not enable filtering by VLAN */
3728     if (rx_mode != BXE_RX_MODE_NONE) {
3729         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, rx_accept_flags);
3730         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, tx_accept_flags);
3731     }
3732 #endif
3733     return (0);
3734 }
3735
3736 static int
3737 bxe_set_q_rx_mode(struct bxe_adapter *sc,
3738                   uint8_t          cl_id,
3739                   unsigned long    rx_mode_flags,
3740                   unsigned long    rx_accept_flags,
3741                   unsigned long    tx_accept_flags,
3742                   unsigned long    ramrod_flags)
3743 {
3744 #if 0
3745     struct ecore_rx_mode_ramrod_params ramrod_param;
3746     int rc;
3747
3748     memset(&ramrod_param, 0, sizeof(ramrod_param));
3749
3750     /* Prepare ramrod parameters */
3751     ramrod_param.cid = 0;
3752     ramrod_param.cl_id = cl_id;
3753     ramrod_param.rx_mode_obj = &sc->rx_mode_obj;
3754     ramrod_param.func_id = SC_FUNC(sc);
3755
3756     ramrod_param.pstate = &sc->sp_state;
3757     ramrod_param.state = ECORE_FILTER_RX_MODE_PENDING;
3758
3759     ramrod_param.rdata = BXE_SP(sc, rx_mode_rdata);
3760     ramrod_param.rdata_mapping = BXE_SP_MAPPING(sc, rx_mode_rdata);
3761
3762     bxe_set_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state);
3763
3764     ramrod_param.ramrod_flags = ramrod_flags;
3765     ramrod_param.rx_mode_flags = rx_mode_flags;
3766
3767     ramrod_param.rx_accept_flags = rx_accept_flags;
3768     ramrod_param.tx_accept_flags = tx_accept_flags;
3769
3770     rc = ecore_config_rx_mode(sc, &ramrod_param);
3771     if (rc < 0) {
3772         BLOGE(sc, "Set rx_mode %d failed\n", sc->rx_mode);
3773         return (rc);
3774     }
3775 #endif
3776     return (0);
3777 }
3778
3779 static int
3780 bxe_set_storm_rx_mode(struct bxe_adapter *sc)
3781 {
3782 #if 0
3783     unsigned long rx_mode_flags = 0, ramrod_flags = 0;
3784     unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
3785     int rc;
3786
3787     rc = bxe_fill_accept_flags(sc, sc->rx_mode, &rx_accept_flags,
3788                                &tx_accept_flags);
3789     if (rc) {
3790         return (rc);
3791     }
3792
3793     bxe_set_bit(RAMROD_RX, &ramrod_flags);
3794     bxe_set_bit(RAMROD_TX, &ramrod_flags);
3795
3796     /* XXX ensure all fastpath have same cl_id and/or move it to bxe_adapter */
3797     return (bxe_set_q_rx_mode(sc, sc->fp[0].cl_id, rx_mode_flags,
3798                               rx_accept_flags, tx_accept_flags,
3799                               ramrod_flags));
3800 #endif
3801 }
3802
3803 /* returns the "mcp load_code" according to global load_count array */
3804 static int
3805 bxe_nic_load_no_mcp(struct bxe_adapter *sc)
3806 {
3807 #if 0
3808     int path = SC_PATH(sc);
3809     int port = SC_PORT(sc);
3810
3811     BLOGI(sc, "NO MCP - load counts[%d]      %d, %d, %d\n",
3812           path, load_count[path][0], load_count[path][1],
3813           load_count[path][2]);
3814     load_count[path][0]++;
3815     load_count[path][1 + port]++;
3816     BLOGI(sc, "NO MCP - new load counts[%d]  %d, %d, %d\n",
3817           path, load_count[path][0], load_count[path][1],
3818           load_count[path][2]);
3819     if (load_count[path][0] == 1) {
3820         return (FW_MSG_CODE_DRV_LOAD_COMMON);
3821     } else if (load_count[path][1 + port] == 1) {
3822         return (FW_MSG_CODE_DRV_LOAD_PORT);
3823     } else {
3824         return (FW_MSG_CODE_DRV_LOAD_FUNCTION);
3825     }
3826 #endif
3827 }
3828
3829 /* returns the "mcp load_code" according to global load_count array */
3830 static int
3831 bxe_nic_unload_no_mcp(struct bxe_adapter *sc)
3832 {
3833 #if 0
3834     int port = SC_PORT(sc);
3835     int path = SC_PATH(sc);
3836
3837     BLOGI(sc, "NO MCP - load counts[%d]      %d, %d, %d\n",
3838           path, load_count[path][0], load_count[path][1],
3839           load_count[path][2]);
3840     load_count[path][0]--;
3841     load_count[path][1 + port]--;
3842     BLOGI(sc, "NO MCP - new load counts[%d]  %d, %d, %d\n",
3843           path, load_count[path][0], load_count[path][1],
3844           load_count[path][2]);
3845     if (load_count[path][0] == 0) {
3846         return (FW_MSG_CODE_DRV_UNLOAD_COMMON);
3847     } else if (load_count[path][1 + port] == 0) {
3848         return (FW_MSG_CODE_DRV_UNLOAD_PORT);
3849     } else {
3850         return (FW_MSG_CODE_DRV_UNLOAD_FUNCTION);
3851     }
3852 #endif
3853 }
3854
3855 /* request unload mode from the MCP: COMMON, PORT or FUNCTION */
3856 static uint32_t
3857 bxe_send_unload_req(struct bxe_adapter *sc,
3858                     int              unload_mode)
3859 {
3860 #if 0
3861     uint32_t reset_code = 0;
3862     int port = SC_PORT(sc);
3863     int path = SC_PATH(sc);
3864
3865     /* Select the UNLOAD request mode */
3866     if (unload_mode == UNLOAD_NORMAL) {
3867         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
3868     }
3869     else if (sc->flags & BXE_NO_WOL_FLAG) {
3870         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
3871     } else if (sc->wol) {
3872         uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
3873         uint8_t *mac_addr = sc->pcidev->dev_addr;
3874         uint32_t val;
3875         uint16_t pmc;
3876
3877         /*
3878          * The mac address is written to entries 1-4 to
3879          * preserve entry 0 which is used by the PMF
3880          */
3881         uint8_t entry = (SC_VN(sc) + 1)*8;
3882
3883         val = (mac_addr[0] << 8) | mac_addr[1];
3884         EMAC_WR(sc, EMAC_REG_EMAC_MAC_MATCH + entry, val);
3885
3886         val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
3887               (mac_addr[4] << 8) | mac_addr[5];
3888         EMAC_WR(sc, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
3889
3890         /* Enable the PME and clear the status */
3891         pmc = pcidev_read16(sc->pcidev,
3892                               (sc->devinfo.pcie_pm_cap_reg +
3893                                PCIR_POWER_STATUS));
3894         pmc |= PCIM_PSTAT_PMEENABLE | PCIM_PSTAT_PME;
3895         pcidev_write32(sc->pcidev,
3896                        (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS), pmc);
3897
3898         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
3899     }
3900     else {
3901         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
3902     }
3903
3904     /* Send the request to the MCP */
3905     if (!BXE_NOMCP(sc)) {
3906         reset_code = bxe_fw_command(sc, reset_code, 0);
3907     } else {
3908         reset_code = bxe_nic_unload_no_mcp(sc);
3909     }
3910
3911     return (reset_code);
3912 #endif
3913     return 0;
3914 }
3915
3916 /* send UNLOAD_DONE command to the MCP */
3917 static void
3918 bxe_send_unload_done(struct bxe_adapter *sc,
3919                      uint8_t          keep_link)
3920 {
3921     uint32_t reset_param =
3922         keep_link ? DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET : 0;
3923
3924     /* Report UNLOAD_DONE to MCP */
3925     if (!BXE_NOMCP(sc)) {
3926         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE, reset_param);
3927     }
3928 }
3929
3930 static int
3931 bxe_func_wait_started(struct bxe_adapter *sc)
3932 {
3933 #if 0
3934     int tout = 50;
3935
3936     if (!sc->port.pmf) {
3937         return (0);
3938     }
3939
3940     /*
3941      * (assumption: No Attention from MCP at this stage)
3942      * PMF probably in the middle of TX disable/enable transaction
3943      * 1. Sync IRS for default SB
3944      * 2. Sync SP queue - this guarantees us that attention handling started
3945      * 3. Wait, that TX disable/enable transaction completes
3946      *
3947      * 1+2 guarantee that if DCBX attention was scheduled it already changed
3948      * pending bit of transaction from STARTED-->TX_STOPPED, if we already
3949      * received completion for the transaction the state is TX_STOPPED.
3950      * State will return to STARTED after completion of TX_STOPPED-->STARTED
3951      * transaction.
3952      */
3953
3954     /* XXX make sure default SB ISR is done */
3955     /* need a way to synchronize an irq (intr_mtx?) */
3956
3957     /* XXX flush any work queues */
3958
3959     while (ecore_func_get_state(sc, &sc->func_obj) !=
3960            ECORE_F_STATE_STARTED && tout--) {
3961         udelay(20000);
3962     }
3963
3964     if (ecore_func_get_state(sc, &sc->func_obj) != ECORE_F_STATE_STARTED) {
3965         /*
3966          * Failed to complete the transaction in a "good way"
3967          * Force both transactions with CLR bit.
3968          */
3969         struct ecore_func_state_params func_params = { NULL };
3970
3971         BLOGE(sc, "Unexpected function state! "
3972                   "Forcing STARTED-->TX_STOPPED-->STARTED\n");
3973
3974         func_params.f_obj = &sc->func_obj;
3975         bxe_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
3976
3977         /* STARTED-->TX_STOPPED */
3978         func_params.cmd = ECORE_F_CMD_TX_STOP;
3979         ecore_func_state_change(sc, &func_params);
3980
3981         /* TX_STOPPED-->STARTED */
3982         func_params.cmd = ECORE_F_CMD_TX_START;
3983         return (ecore_func_state_change(sc, &func_params));
3984     }
3985 #endif
3986     return (0);
3987 }
3988
3989 static int
3990 bxe_stop_queue(struct bxe_adapter *sc,
3991                int              index)
3992 {
3993 #if 0
3994     struct bxe_fastpath *fp = &sc->fp[index];
3995     struct ecore_queue_state_params q_params = { NULL };
3996     int rc;
3997
3998     BLOGD(sc, DBG_LOAD, "stopping queue %d cid %d\n", index, fp->index);
3999
4000     q_params.q_obj = &sc->sp_objs[fp->index].q_obj;
4001     /* We want to wait for completion in this context */
4002     bxe_set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
4003
4004     /* Stop the primary connection: */
4005
4006     /* ...halt the connection */
4007     q_params.cmd = ECORE_Q_CMD_HALT;
4008     rc = ecore_queue_state_change(sc, &q_params);
4009     if (rc) {
4010         return (rc);
4011     }
4012
4013     /* ...terminate the connection */
4014     q_params.cmd = ECORE_Q_CMD_TERMINATE;
4015     memset(&q_params.params.terminate, 0, sizeof(q_params.params.terminate));
4016     q_params.params.terminate.cid_index = FIRST_TX_COS_INDEX;
4017     rc = ecore_queue_state_change(sc, &q_params);
4018     if (rc) {
4019         return (rc);
4020     }
4021
4022     /* ...delete cfc entry */
4023     q_params.cmd = ECORE_Q_CMD_CFC_DEL;
4024     memset(&q_params.params.cfc_del, 0, sizeof(q_params.params.cfc_del));
4025     q_params.params.cfc_del.cid_index = FIRST_TX_COS_INDEX;
4026     return (ecore_queue_state_change(sc, &q_params));
4027 #endif
4028     return -1;
4029 }
4030
4031 /* wait for the outstanding SP commands */
4032 static inline uint8_t
4033 bxe_wait_sp_comp(struct bxe_adapter *sc,
4034                  unsigned long    mask)
4035 {
4036     unsigned long tmp;
4037     int tout = 5000; /* wait for 5 secs tops */
4038
4039     while (tout--) {
4040         mb();
4041         if (!(atomic_load_acq_long(&sc->sp_state) & mask)) {
4042             return (TRUE);
4043         }
4044
4045         udelay(1000);
4046     }
4047
4048     mb();
4049
4050     tmp = atomic_load_acq_long(&sc->sp_state);
4051     if (tmp & mask) {
4052         BLOGE(sc, "Filtering completion timed out: "
4053                   "sp_state 0x%lx, mask 0x%lx\n",
4054               tmp, mask);
4055         return (FALSE);
4056     }
4057
4058     return (FALSE);
4059 }
4060
4061 static int
4062 bxe_func_stop(struct bxe_adapter *sc)
4063 {
4064 #if 0
4065     struct ecore_func_state_params func_params = { NULL };
4066     int rc;
4067
4068     /* prepare parameters for function state transitions */
4069     bxe_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
4070     func_params.f_obj = &sc->func_obj;
4071     func_params.cmd = ECORE_F_CMD_STOP;
4072
4073     /*
4074      * Try to stop the function the 'good way'. If it fails (in case
4075      * of a parity error during bxe_chip_cleanup()) and we are
4076      * not in a debug mode, perform a state transaction in order to
4077      * enable further HW_RESET transaction.
4078      */
4079     rc = ecore_func_state_change(sc, &func_params);
4080     if (rc) {
4081         BLOGE(sc, "FUNC_STOP ramrod failed. "
4082                   "Running a dry transaction\n");
4083         bxe_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
4084         return (ecore_func_state_change(sc, &func_params));
4085     }
4086 #endif
4087     return (0);
4088 }
4089
4090 static int
4091 bxe_reset_hw(struct bxe_adapter *sc,
4092              uint32_t         load_code)
4093 {
4094 #if 0
4095     struct ecore_func_state_params func_params = { NULL };
4096
4097     /* Prepare parameters for function state transitions */
4098     bxe_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
4099
4100     func_params.f_obj = &sc->func_obj;
4101     func_params.cmd = ECORE_F_CMD_HW_RESET;
4102
4103     func_params.params.hw_init.load_phase = load_code;
4104
4105     return (ecore_func_state_change(sc, &func_params));
4106 #endif
4107     return 0;
4108 }
4109
4110 static void
4111 bxe_int_disable_sync(struct bxe_adapter *sc,
4112                      int              disable_hw)
4113 {
4114     if (disable_hw) {
4115         /* prevent the HW from sending interrupts */
4116         bxe_int_disable(sc);
4117     }
4118
4119     /* XXX need a way to synchronize ALL irqs (intr_mtx?) */
4120     /* make sure all ISRs are done */
4121
4122     /* XXX make sure sp_task is not running */
4123     /* cancel and flush work queues */
4124 }
4125
4126 static void
4127 bxe_chip_cleanup(struct bxe_adapter *sc,
4128                  uint32_t         unload_mode,
4129                  uint8_t          keep_link)
4130 {
4131 #if 0
4132     int port = SC_PORT(sc);
4133     struct ecore_mcast_ramrod_params rparam = { NULL };
4134     uint32_t reset_code;
4135     int i, rc = 0;
4136
4137     bxe_drain_tx_queues(sc);
4138
4139     /* give HW time to discard old tx messages */
4140     udelay(1000);
4141
4142     /* Clean all ETH MACs */
4143     rc = bxe_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_ETH_MAC, FALSE);
4144     if (rc < 0) {
4145         BLOGE(sc, "Failed to delete all ETH MACs (%d)\n", rc);
4146     }
4147
4148     /* Clean up UC list  */
4149     rc = bxe_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_UC_LIST_MAC, TRUE);
4150     if (rc < 0) {
4151         BLOGE(sc, "Failed to delete UC MACs list (%d)\n", rc);
4152     }
4153
4154     /* Disable LLH */
4155     if (!CHIP_IS_E1(sc)) {
4156         REG_WR(sc, NIG_REG_LLH0_FUNC_EN + port*8, 0);
4157     }
4158
4159     /* Set "drop all" to stop Rx */
4160
4161     /*
4162      * We need to take the BXE_MCAST_LOCK() here in order to prevent
4163      * a race between the completion code and this code.
4164      */
4165     BXE_MCAST_LOCK(sc);
4166
4167     if (bxe_test_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state)) {
4168         bxe_set_bit(ECORE_FILTER_RX_MODE_SCHED, &sc->sp_state);
4169     } else {
4170         bxe_set_storm_rx_mode(sc);
4171     }
4172
4173     /* Clean up multicast configuration */
4174     rparam.mcast_obj = &sc->mcast_obj;
4175     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
4176     if (rc < 0) {
4177         BLOGE(sc, "Failed to send DEL MCAST command (%d)\n", rc);
4178     }