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