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