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