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