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