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