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