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