Deleted Added
sdiff udiff text old ( 314093 ) new ( 315881 )
full compact
bxe.c (314093) bxe.c (315881)
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

--- 11 unchanged lines hidden (view full) ---

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>
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

--- 11 unchanged lines hidden (view full) ---

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: stable/11/sys/dev/bxe/bxe.c 314093 2017-02-22 08:49:52Z royger $");
28__FBSDID("$FreeBSD: stable/11/sys/dev/bxe/bxe.c 315881 2017-03-24 02:58:20Z davidcs $");
29
29
30#define BXE_DRIVER_VERSION "1.78.89"
30#define BXE_DRIVER_VERSION "1.78.90"
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"

--- 452 unchanged lines hidden (view full) ---

491 { STATS_OFFSET32(mbuf_alloc_rx),
492 4, STATS_FLAGS_FUNC, "mbuf_alloc_rx"},
493 { STATS_OFFSET32(mbuf_alloc_sge),
494 4, STATS_FLAGS_FUNC, "mbuf_alloc_sge"},
495 { STATS_OFFSET32(mbuf_alloc_tpa),
496 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"},
497 { STATS_OFFSET32(tx_queue_full_return),
498 4, STATS_FLAGS_FUNC, "tx_queue_full_return"},
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"

--- 452 unchanged lines hidden (view full) ---

491 { STATS_OFFSET32(mbuf_alloc_rx),
492 4, STATS_FLAGS_FUNC, "mbuf_alloc_rx"},
493 { STATS_OFFSET32(mbuf_alloc_sge),
494 4, STATS_FLAGS_FUNC, "mbuf_alloc_sge"},
495 { STATS_OFFSET32(mbuf_alloc_tpa),
496 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"},
497 { STATS_OFFSET32(tx_queue_full_return),
498 4, STATS_FLAGS_FUNC, "tx_queue_full_return"},
499 { STATS_OFFSET32(bxe_tx_mq_sc_state_failures),
500 4, STATS_FLAGS_FUNC, "bxe_tx_mq_sc_state_failures"},
499 { STATS_OFFSET32(tx_request_link_down_failures),
500 4, STATS_FLAGS_FUNC, "tx_request_link_down_failures"},
501 { STATS_OFFSET32(bd_avail_too_less_failures),
502 4, STATS_FLAGS_FUNC, "bd_avail_too_less_failures"},
503 { STATS_OFFSET32(tx_mq_not_empty),
501 { STATS_OFFSET32(tx_request_link_down_failures),
502 4, STATS_FLAGS_FUNC, "tx_request_link_down_failures"},
503 { STATS_OFFSET32(bd_avail_too_less_failures),
504 4, STATS_FLAGS_FUNC, "bd_avail_too_less_failures"},
505 { STATS_OFFSET32(tx_mq_not_empty),
504 4, STATS_FLAGS_FUNC, "tx_mq_not_empty"}
506 4, STATS_FLAGS_FUNC, "tx_mq_not_empty"},
507 { STATS_OFFSET32(nsegs_path1_errors),
508 4, STATS_FLAGS_FUNC, "nsegs_path1_errors"},
509 { STATS_OFFSET32(nsegs_path2_errors),
510 4, STATS_FLAGS_FUNC, "nsegs_path2_errors"}
505
511
512
506};
507
508static const struct {
509 uint32_t offset;
510 uint32_t size;
511 char string[STAT_NAME_LEN];
512} bxe_eth_q_stats_arr[] = {
513 { Q_STATS_OFFSET32(total_bytes_received_hi),

--- 97 unchanged lines hidden (view full) ---

611 { Q_STATS_OFFSET32(mbuf_alloc_rx),
612 4, "mbuf_alloc_rx"},
613 { Q_STATS_OFFSET32(mbuf_alloc_sge),
614 4, "mbuf_alloc_sge"},
615 { Q_STATS_OFFSET32(mbuf_alloc_tpa),
616 4, "mbuf_alloc_tpa"},
617 { Q_STATS_OFFSET32(tx_queue_full_return),
618 4, "tx_queue_full_return"},
513};
514
515static const struct {
516 uint32_t offset;
517 uint32_t size;
518 char string[STAT_NAME_LEN];
519} bxe_eth_q_stats_arr[] = {
520 { Q_STATS_OFFSET32(total_bytes_received_hi),

--- 97 unchanged lines hidden (view full) ---

618 { Q_STATS_OFFSET32(mbuf_alloc_rx),
619 4, "mbuf_alloc_rx"},
620 { Q_STATS_OFFSET32(mbuf_alloc_sge),
621 4, "mbuf_alloc_sge"},
622 { Q_STATS_OFFSET32(mbuf_alloc_tpa),
623 4, "mbuf_alloc_tpa"},
624 { Q_STATS_OFFSET32(tx_queue_full_return),
625 4, "tx_queue_full_return"},
626 { Q_STATS_OFFSET32(bxe_tx_mq_sc_state_failures),
627 4, "bxe_tx_mq_sc_state_failures"},
619 { Q_STATS_OFFSET32(tx_request_link_down_failures),
620 4, "tx_request_link_down_failures"},
621 { Q_STATS_OFFSET32(bd_avail_too_less_failures),
622 4, "bd_avail_too_less_failures"},
623 { Q_STATS_OFFSET32(tx_mq_not_empty),
628 { Q_STATS_OFFSET32(tx_request_link_down_failures),
629 4, "tx_request_link_down_failures"},
630 { Q_STATS_OFFSET32(bd_avail_too_less_failures),
631 4, "bd_avail_too_less_failures"},
632 { Q_STATS_OFFSET32(tx_mq_not_empty),
624 4, "tx_mq_not_empty"}
633 4, "tx_mq_not_empty"},
634 { Q_STATS_OFFSET32(nsegs_path1_errors),
635 4, "nsegs_path1_errors"},
636 { Q_STATS_OFFSET32(nsegs_path2_errors),
637 4, "nsegs_path2_errors"}
625
638
639
626};
627
628#define BXE_NUM_ETH_STATS ARRAY_SIZE(bxe_eth_stats_arr)
629#define BXE_NUM_ETH_Q_STATS ARRAY_SIZE(bxe_eth_q_stats_arr)
630
631
632static void bxe_cmng_fns_init(struct bxe_softc *sc,
633 uint8_t read_cfg,

--- 53 unchanged lines hidden (view full) ---

687 uint32_t unload_mode,
688 uint8_t keep_link);
689
690static void bxe_handle_sp_tq(void *context, int pending);
691static void bxe_handle_fp_tq(void *context, int pending);
692
693static int bxe_add_cdev(struct bxe_softc *sc);
694static void bxe_del_cdev(struct bxe_softc *sc);
640};
641
642#define BXE_NUM_ETH_STATS ARRAY_SIZE(bxe_eth_stats_arr)
643#define BXE_NUM_ETH_Q_STATS ARRAY_SIZE(bxe_eth_q_stats_arr)
644
645
646static void bxe_cmng_fns_init(struct bxe_softc *sc,
647 uint8_t read_cfg,

--- 53 unchanged lines hidden (view full) ---

701 uint32_t unload_mode,
702 uint8_t keep_link);
703
704static void bxe_handle_sp_tq(void *context, int pending);
705static void bxe_handle_fp_tq(void *context, int pending);
706
707static int bxe_add_cdev(struct bxe_softc *sc);
708static void bxe_del_cdev(struct bxe_softc *sc);
709int bxe_grc_dump(struct bxe_softc *sc);
695static int bxe_alloc_buf_rings(struct bxe_softc *sc);
696static void bxe_free_buf_rings(struct bxe_softc *sc);
697
698/* calculate crc32 on a buffer (NOTE: crc32_length MUST be aligned to 8) */
699uint32_t
700calc_crc32(uint8_t *crc32_packet,
701 uint32_t crc32_length,
702 uint32_t crc32_seed,

--- 4523 unchanged lines hidden (view full) ---

5226 *m_head = m0;
5227 error = bus_dmamap_load_mbuf_sg(fp->tx_mbuf_tag,
5228 tx_buf->m_map, m0,
5229 segs, &nsegs, BUS_DMA_NOWAIT);
5230 if (error) {
5231 fp->eth_q_stats.tx_dma_mapping_failure++;
5232 /* No sense in trying to defrag/copy chain, drop it. :( */
5233 rc = error;
710static int bxe_alloc_buf_rings(struct bxe_softc *sc);
711static void bxe_free_buf_rings(struct bxe_softc *sc);
712
713/* calculate crc32 on a buffer (NOTE: crc32_length MUST be aligned to 8) */
714uint32_t
715calc_crc32(uint8_t *crc32_packet,
716 uint32_t crc32_length,
717 uint32_t crc32_seed,

--- 4523 unchanged lines hidden (view full) ---

5241 *m_head = m0;
5242 error = bus_dmamap_load_mbuf_sg(fp->tx_mbuf_tag,
5243 tx_buf->m_map, m0,
5244 segs, &nsegs, BUS_DMA_NOWAIT);
5245 if (error) {
5246 fp->eth_q_stats.tx_dma_mapping_failure++;
5247 /* No sense in trying to defrag/copy chain, drop it. :( */
5248 rc = error;
5234 }
5235 else {
5236 /* if the chain is still too long then drop it */
5237 if (__predict_false(nsegs > BXE_MAX_SEGMENTS)) {
5238 bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5239 rc = ENODEV;
5249 } else {
5250 /* if the chain is still too long then drop it */
5251 if(m0->m_pkthdr.csum_flags & CSUM_TSO) {
5252 /*
5253 * in case TSO is enabled nsegs should be checked against
5254 * BXE_TSO_MAX_SEGMENTS
5255 */
5256 if (__predict_false(nsegs > BXE_TSO_MAX_SEGMENTS)) {
5257 bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5258 fp->eth_q_stats.nsegs_path1_errors++;
5259 rc = ENODEV;
5260 }
5261 } else {
5262 if (__predict_false(nsegs > BXE_MAX_SEGMENTS)) {
5263 bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5264 fp->eth_q_stats.nsegs_path2_errors++;
5265 rc = ENODEV;
5266 }
5240 }
5241 }
5242 }
5243 }
5244
5245bxe_tx_encap_continue:
5246
5247 /* Check for errors */

--- 383 unchanged lines hidden (view full) ---

5631 struct mbuf *next;
5632 int depth, rc, tx_count;
5633 uint16_t tx_bd_avail;
5634
5635 rc = tx_count = 0;
5636
5637 BXE_FP_TX_LOCK_ASSERT(fp);
5638
5267 }
5268 }
5269 }
5270 }
5271
5272bxe_tx_encap_continue:
5273
5274 /* Check for errors */

--- 383 unchanged lines hidden (view full) ---

5658 struct mbuf *next;
5659 int depth, rc, tx_count;
5660 uint16_t tx_bd_avail;
5661
5662 rc = tx_count = 0;
5663
5664 BXE_FP_TX_LOCK_ASSERT(fp);
5665
5666 if (sc->state != BXE_STATE_OPEN) {
5667 fp->eth_q_stats.bxe_tx_mq_sc_state_failures++;
5668 return ENETDOWN;
5669 }
5670
5639 if (!tx_br) {
5640 BLOGE(sc, "Multiqueue TX and no buf_ring!\n");
5641 return (EINVAL);
5642 }
5643
5644 if (m != NULL) {
5645 rc = drbr_enqueue(ifp, tx_br, m);
5646 if (rc != 0) {

--- 105 unchanged lines hidden (view full) ---

5752
5753 /* check if flowid is set */
5754
5755 if (BXE_VALID_FLOWID(m))
5756 fp_index = (m->m_pkthdr.flowid % sc->num_queues);
5757
5758 fp = &sc->fp[fp_index];
5759
5671 if (!tx_br) {
5672 BLOGE(sc, "Multiqueue TX and no buf_ring!\n");
5673 return (EINVAL);
5674 }
5675
5676 if (m != NULL) {
5677 rc = drbr_enqueue(ifp, tx_br, m);
5678 if (rc != 0) {

--- 105 unchanged lines hidden (view full) ---

5784
5785 /* check if flowid is set */
5786
5787 if (BXE_VALID_FLOWID(m))
5788 fp_index = (m->m_pkthdr.flowid % sc->num_queues);
5789
5790 fp = &sc->fp[fp_index];
5791
5792 if (sc->state != BXE_STATE_OPEN) {
5793 fp->eth_q_stats.bxe_tx_mq_sc_state_failures++;
5794 return ENETDOWN;
5795 }
5796
5760 if (BXE_FP_TX_TRYLOCK(fp)) {
5761 rc = bxe_tx_mq_start_locked(sc, ifp, fp, m);
5762 BXE_FP_TX_UNLOCK(fp);
5763 } else {
5764 rc = drbr_enqueue(ifp, fp->tx_br, m);
5765 taskqueue_enqueue(fp->tq, &fp->tx_task);
5766 }
5767

--- 6 unchanged lines hidden (view full) ---

5774 struct bxe_softc *sc = if_getsoftc(ifp);
5775 struct bxe_fastpath *fp;
5776 struct mbuf *m;
5777 int i;
5778
5779 for (i = 0; i < sc->num_queues; i++) {
5780 fp = &sc->fp[i];
5781
5797 if (BXE_FP_TX_TRYLOCK(fp)) {
5798 rc = bxe_tx_mq_start_locked(sc, ifp, fp, m);
5799 BXE_FP_TX_UNLOCK(fp);
5800 } else {
5801 rc = drbr_enqueue(ifp, fp->tx_br, m);
5802 taskqueue_enqueue(fp->tq, &fp->tx_task);
5803 }
5804

--- 6 unchanged lines hidden (view full) ---

5811 struct bxe_softc *sc = if_getsoftc(ifp);
5812 struct bxe_fastpath *fp;
5813 struct mbuf *m;
5814 int i;
5815
5816 for (i = 0; i < sc->num_queues; i++) {
5817 fp = &sc->fp[i];
5818
5782 if (fp->state != BXE_FP_STATE_OPEN) {
5819 if (fp->state != BXE_FP_STATE_IRQ) {
5783 BLOGD(sc, DBG_LOAD, "Not clearing fp[%02d] buf_ring (state=%d)\n",
5784 fp->index, fp->state);
5785 continue;
5786 }
5787
5788 if (fp->tx_br != NULL) {
5789 BLOGD(sc, DBG_LOAD, "Clearing fp[%02d] buf_ring\n", fp->index);
5790 BXE_FP_TX_LOCK(fp);

--- 200 unchanged lines hidden (view full) ---

5991
5992 bxe_free_ilt_lines_mem(sc);
5993
5994}
5995
5996static int
5997bxe_alloc_mem(struct bxe_softc *sc)
5998{
5820 BLOGD(sc, DBG_LOAD, "Not clearing fp[%02d] buf_ring (state=%d)\n",
5821 fp->index, fp->state);
5822 continue;
5823 }
5824
5825 if (fp->tx_br != NULL) {
5826 BLOGD(sc, DBG_LOAD, "Clearing fp[%02d] buf_ring\n", fp->index);
5827 BXE_FP_TX_LOCK(fp);

--- 200 unchanged lines hidden (view full) ---

6028
6029 bxe_free_ilt_lines_mem(sc);
6030
6031}
6032
6033static int
6034bxe_alloc_mem(struct bxe_softc *sc)
6035{
6036
5999 int context_size;
6000 int allocated;
6001 int i;
6002
6003 /*
6004 * Allocate memory for CDU context:
6005 * This memory is allocated separately and not in the generic ILT
6006 * functions because CDU differs in few aspects:

--- 978 unchanged lines hidden (view full) ---

6985 uint32_t pause_enabled = 0;
6986 struct host_port_stats *pstats;
6987 int cmng_fns;
6988 struct bxe_fastpath *fp;
6989 int i;
6990
6991 /* Make sure that we are synced with the current statistics */
6992 bxe_stats_handle(sc, STATS_EVENT_STOP);
6037 int context_size;
6038 int allocated;
6039 int i;
6040
6041 /*
6042 * Allocate memory for CDU context:
6043 * This memory is allocated separately and not in the generic ILT
6044 * functions because CDU differs in few aspects:

--- 978 unchanged lines hidden (view full) ---

7023 uint32_t pause_enabled = 0;
7024 struct host_port_stats *pstats;
7025 int cmng_fns;
7026 struct bxe_fastpath *fp;
7027 int i;
7028
7029 /* Make sure that we are synced with the current statistics */
7030 bxe_stats_handle(sc, STATS_EVENT_STOP);
6993
7031 BLOGI(sc, "link_vars phy_flags : %x\n", sc->link_vars.phy_flags);
6994 elink_link_update(&sc->link_params, &sc->link_vars);
6995
6996 if (sc->link_vars.link_up) {
6997
6998 /* dropless flow control */
6999 if (!CHIP_IS_E1(sc) && sc->dropless_fc) {
7000 pause_enabled = 0;
7001

--- 4188 unchanged lines hidden (view full) ---

11190 unsigned long flags = 0;
11191
11192 if (IS_MF_SD(sc)) {
11193 bxe_set_bit(ECORE_Q_FLG_OV, &flags);
11194 }
11195
11196 if (if_getcapenable(sc->ifp) & IFCAP_LRO) {
11197 bxe_set_bit(ECORE_Q_FLG_TPA, &flags);
7032 elink_link_update(&sc->link_params, &sc->link_vars);
7033
7034 if (sc->link_vars.link_up) {
7035
7036 /* dropless flow control */
7037 if (!CHIP_IS_E1(sc) && sc->dropless_fc) {
7038 pause_enabled = 0;
7039

--- 4188 unchanged lines hidden (view full) ---

11228 unsigned long flags = 0;
11229
11230 if (IS_MF_SD(sc)) {
11231 bxe_set_bit(ECORE_Q_FLG_OV, &flags);
11232 }
11233
11234 if (if_getcapenable(sc->ifp) & IFCAP_LRO) {
11235 bxe_set_bit(ECORE_Q_FLG_TPA, &flags);
11236#if __FreeBSD_version >= 800000
11198 bxe_set_bit(ECORE_Q_FLG_TPA_IPV6, &flags);
11237 bxe_set_bit(ECORE_Q_FLG_TPA_IPV6, &flags);
11238#endif
11199 }
11200
11201 if (leading) {
11202 bxe_set_bit(ECORE_Q_FLG_LEADING_RSS, &flags);
11203 bxe_set_bit(ECORE_Q_FLG_MCAST, &flags);
11204 }
11205
11206 bxe_set_bit(ECORE_Q_FLG_VLAN, &flags);

--- 420 unchanged lines hidden (view full) ---

11627 sc->link_params.req_fc_auto_adv = ELINK_FLOW_CTRL_BOTH;
11628 }
11629}
11630
11631static void
11632bxe_calc_fc_adv(struct bxe_softc *sc)
11633{
11634 uint8_t cfg_idx = bxe_get_link_cfg_idx(sc);
11239 }
11240
11241 if (leading) {
11242 bxe_set_bit(ECORE_Q_FLG_LEADING_RSS, &flags);
11243 bxe_set_bit(ECORE_Q_FLG_MCAST, &flags);
11244 }
11245
11246 bxe_set_bit(ECORE_Q_FLG_VLAN, &flags);

--- 420 unchanged lines hidden (view full) ---

11667 sc->link_params.req_fc_auto_adv = ELINK_FLOW_CTRL_BOTH;
11668 }
11669}
11670
11671static void
11672bxe_calc_fc_adv(struct bxe_softc *sc)
11673{
11674 uint8_t cfg_idx = bxe_get_link_cfg_idx(sc);
11675
11676
11677 sc->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
11678 ADVERTISED_Pause);
11679
11635 switch (sc->link_vars.ieee_fc &
11636 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
11680 switch (sc->link_vars.ieee_fc &
11681 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
11637 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
11638 default:
11639 sc->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
11640 ADVERTISED_Pause);
11641 break;
11642
11643 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
11644 sc->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
11645 ADVERTISED_Pause);
11646 break;
11647
11648 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
11649 sc->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
11650 break;
11682
11683 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
11684 sc->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
11685 ADVERTISED_Pause);
11686 break;
11687
11688 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
11689 sc->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
11690 break;
11691
11692 default:
11693 break;
11694
11651 }
11652}
11653
11654static uint16_t
11655bxe_get_mf_speed(struct bxe_softc *sc)
11656{
11657 uint16_t line_speed = sc->link_vars.line_speed;
11658 if (IS_MF(sc)) {

--- 65 unchanged lines hidden (view full) ---

11724 if (!memcmp(&cur_data, &sc->last_reported_link, sizeof(cur_data)) ||
11725 (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11726 &sc->last_reported_link.link_report_flags) &&
11727 bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11728 &cur_data.link_report_flags))) {
11729 return;
11730 }
11731
11695 }
11696}
11697
11698static uint16_t
11699bxe_get_mf_speed(struct bxe_softc *sc)
11700{
11701 uint16_t line_speed = sc->link_vars.line_speed;
11702 if (IS_MF(sc)) {

--- 65 unchanged lines hidden (view full) ---

11768 if (!memcmp(&cur_data, &sc->last_reported_link, sizeof(cur_data)) ||
11769 (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11770 &sc->last_reported_link.link_report_flags) &&
11771 bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11772 &cur_data.link_report_flags))) {
11773 return;
11774 }
11775
11776 ELINK_DEBUG_P2(sc, "Change in link status : cur_data = %x, last_reported_link = %x\n",
11777 cur_data.link_report_flags, sc->last_reported_link.link_report_flags);
11732 sc->link_cnt++;
11733
11778 sc->link_cnt++;
11779
11780 ELINK_DEBUG_P1(sc, "link status change count = %x\n", sc->link_cnt);
11734 /* report new link params and remember the state for the next time */
11735 memcpy(&sc->last_reported_link, &cur_data, sizeof(cur_data));
11736
11737 if (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11738 &cur_data.link_report_flags)) {
11739 if_link_state_change(sc->ifp, LINK_STATE_DOWN);
11781 /* report new link params and remember the state for the next time */
11782 memcpy(&sc->last_reported_link, &cur_data, sizeof(cur_data));
11783
11784 if (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11785 &cur_data.link_report_flags)) {
11786 if_link_state_change(sc->ifp, LINK_STATE_DOWN);
11740 BLOGI(sc, "NIC Link is Down\n");
11741 } else {
11742 const char *duplex;
11743 const char *flow;
11744
11745 if (bxe_test_and_clear_bit(BXE_LINK_REPORT_FULL_DUPLEX,
11746 &cur_data.link_report_flags)) {
11747 duplex = "full";
11787 } else {
11788 const char *duplex;
11789 const char *flow;
11790
11791 if (bxe_test_and_clear_bit(BXE_LINK_REPORT_FULL_DUPLEX,
11792 &cur_data.link_report_flags)) {
11793 duplex = "full";
11794 ELINK_DEBUG_P0(sc, "link set to full duplex\n");
11748 } else {
11749 duplex = "half";
11795 } else {
11796 duplex = "half";
11797 ELINK_DEBUG_P0(sc, "link set to half duplex\n");
11750 }
11751
11752 /*
11753 * Handle the FC at the end so that only these flags would be
11754 * possibly set. This way we may easily check if there is no FC
11755 * enabled.
11756 */
11757 if (cur_data.link_report_flags) {

--- 884 unchanged lines hidden (view full) ---

12642 bxe_ifmedia_status);
12643
12644 /* set the default interface values */
12645 ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_FDX | sc->media), 0, NULL);
12646 ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_AUTO), 0, NULL);
12647 ifmedia_set(&sc->ifmedia, (IFM_ETHER | IFM_AUTO));
12648
12649 sc->ifmedia.ifm_media = sc->ifmedia.ifm_cur->ifm_media; /* XXX ? */
11798 }
11799
11800 /*
11801 * Handle the FC at the end so that only these flags would be
11802 * possibly set. This way we may easily check if there is no FC
11803 * enabled.
11804 */
11805 if (cur_data.link_report_flags) {

--- 884 unchanged lines hidden (view full) ---

12690 bxe_ifmedia_status);
12691
12692 /* set the default interface values */
12693 ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_FDX | sc->media), 0, NULL);
12694 ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_AUTO), 0, NULL);
12695 ifmedia_set(&sc->ifmedia, (IFM_ETHER | IFM_AUTO));
12696
12697 sc->ifmedia.ifm_media = sc->ifmedia.ifm_cur->ifm_media; /* XXX ? */
12698 BLOGI(sc, "IFMEDIA flags : %x\n", sc->ifmedia.ifm_media);
12650
12651 /* allocate the ifnet structure */
12652 if ((ifp = if_gethandle(IFT_ETHER)) == NULL) {
12653 BLOGE(sc, "Interface allocation failed!\n");
12654 return (ENXIO);
12655 }
12656
12657 if_setsoftc(ifp, sc);

--- 1331 unchanged lines hidden (view full) ---

13989 if (!(sc->link_params.speed_cap_mask[idx] &
13990 PORT_HW_CFG_SPEED_CAPABILITY_D0_20G)) {
13991 sc->port.supported[idx] &= ~ELINK_SUPPORTED_20000baseKR2_Full;
13992 }
13993 }
13994
13995 BLOGD(sc, DBG_LOAD, "PHY supported 0=0x%08x 1=0x%08x\n",
13996 sc->port.supported[0], sc->port.supported[1]);
12699
12700 /* allocate the ifnet structure */
12701 if ((ifp = if_gethandle(IFT_ETHER)) == NULL) {
12702 BLOGE(sc, "Interface allocation failed!\n");
12703 return (ENXIO);
12704 }
12705
12706 if_setsoftc(ifp, sc);

--- 1331 unchanged lines hidden (view full) ---

14038 if (!(sc->link_params.speed_cap_mask[idx] &
14039 PORT_HW_CFG_SPEED_CAPABILITY_D0_20G)) {
14040 sc->port.supported[idx] &= ~ELINK_SUPPORTED_20000baseKR2_Full;
14041 }
14042 }
14043
14044 BLOGD(sc, DBG_LOAD, "PHY supported 0=0x%08x 1=0x%08x\n",
14045 sc->port.supported[0], sc->port.supported[1]);
14046 ELINK_DEBUG_P2(sc, "PHY supported 0=0x%08x 1=0x%08x\n",
14047 sc->port.supported[0], sc->port.supported[1]);
13997}
13998
13999static void
14000bxe_link_settings_requested(struct bxe_softc *sc)
14001{
14002 uint32_t link_config;
14003 uint32_t idx;
14004 uint32_t cfg_size = 0;

--- 48 unchanged lines hidden (view full) ---

14053 break;
14054
14055 case PORT_FEATURE_LINK_SPEED_10M_HALF:
14056 if (sc->port.supported[idx] & ELINK_SUPPORTED_10baseT_Half) {
14057 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10;
14058 sc->link_params.req_duplex[idx] = DUPLEX_HALF;
14059 sc->port.advertising[idx] |= (ADVERTISED_10baseT_Half |
14060 ADVERTISED_TP);
14048}
14049
14050static void
14051bxe_link_settings_requested(struct bxe_softc *sc)
14052{
14053 uint32_t link_config;
14054 uint32_t idx;
14055 uint32_t cfg_size = 0;

--- 48 unchanged lines hidden (view full) ---

14104 break;
14105
14106 case PORT_FEATURE_LINK_SPEED_10M_HALF:
14107 if (sc->port.supported[idx] & ELINK_SUPPORTED_10baseT_Half) {
14108 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10;
14109 sc->link_params.req_duplex[idx] = DUPLEX_HALF;
14110 sc->port.advertising[idx] |= (ADVERTISED_10baseT_Half |
14111 ADVERTISED_TP);
14112 ELINK_DEBUG_P1(sc, "driver requesting DUPLEX_HALF req_duplex = %x!\n",
14113 sc->link_params.req_duplex[idx]);
14061 } else {
14062 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14063 "speed_cap_mask=0x%08x\n",
14064 link_config, sc->link_params.speed_cap_mask[idx]);
14065 return;
14066 }
14067 break;
14068

--- 88 unchanged lines hidden (view full) ---

14157 }
14158
14159 BLOGD(sc, DBG_LOAD, "req_line_speed=%d req_duplex=%d "
14160 "req_flow_ctrl=0x%x advertising=0x%x\n",
14161 sc->link_params.req_line_speed[idx],
14162 sc->link_params.req_duplex[idx],
14163 sc->link_params.req_flow_ctrl[idx],
14164 sc->port.advertising[idx]);
14114 } else {
14115 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14116 "speed_cap_mask=0x%08x\n",
14117 link_config, sc->link_params.speed_cap_mask[idx]);
14118 return;
14119 }
14120 break;
14121

--- 88 unchanged lines hidden (view full) ---

14210 }
14211
14212 BLOGD(sc, DBG_LOAD, "req_line_speed=%d req_duplex=%d "
14213 "req_flow_ctrl=0x%x advertising=0x%x\n",
14214 sc->link_params.req_line_speed[idx],
14215 sc->link_params.req_duplex[idx],
14216 sc->link_params.req_flow_ctrl[idx],
14217 sc->port.advertising[idx]);
14218 ELINK_DEBUG_P3(sc, "req_line_speed=%d req_duplex=%d "
14219 "advertising=0x%x\n",
14220 sc->link_params.req_line_speed[idx],
14221 sc->link_params.req_duplex[idx],
14222 sc->port.advertising[idx]);
14165 }
14166}
14167
14168static void
14169bxe_get_phy_info(struct bxe_softc *sc)
14170{
14171 uint8_t port = SC_PORT(sc);
14172 uint32_t config = sc->port.config;
14173 uint32_t eee_mode;
14174
14175 /* shmem data already read in bxe_get_shmem_info() */
14176
14223 }
14224}
14225
14226static void
14227bxe_get_phy_info(struct bxe_softc *sc)
14228{
14229 uint8_t port = SC_PORT(sc);
14230 uint32_t config = sc->port.config;
14231 uint32_t eee_mode;
14232
14233 /* shmem data already read in bxe_get_shmem_info() */
14234
14177 BLOGD(sc, DBG_LOAD, "lane_config=0x%08x speed_cap_mask0=0x%08x "
14235 ELINK_DEBUG_P3(sc, "lane_config=0x%08x speed_cap_mask0=0x%08x "
14178 "link_config0=0x%08x\n",
14179 sc->link_params.lane_config,
14180 sc->link_params.speed_cap_mask[0],
14181 sc->port.link_config[0]);
14236 "link_config0=0x%08x\n",
14237 sc->link_params.lane_config,
14238 sc->link_params.speed_cap_mask[0],
14239 sc->port.link_config[0]);
14240
14182
14183 bxe_link_settings_supported(sc, sc->link_params.switch_cfg);
14184 bxe_link_settings_requested(sc);
14185
14186 if (sc->autogreeen == AUTO_GREEN_FORCE_ON) {
14187 sc->link_params.feature_config_flags |=
14188 ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED;
14189 } else if (sc->autogreeen == AUTO_GREEN_FORCE_OFF) {

--- 14 unchanged lines hidden (view full) ---

14204 ELINK_EEE_MODE_ENABLE_LPI |
14205 ELINK_EEE_MODE_OUTPUT_TIME);
14206 } else {
14207 sc->link_params.eee_mode = 0;
14208 }
14209
14210 /* get the media type */
14211 bxe_media_detect(sc);
14241
14242 bxe_link_settings_supported(sc, sc->link_params.switch_cfg);
14243 bxe_link_settings_requested(sc);
14244
14245 if (sc->autogreeen == AUTO_GREEN_FORCE_ON) {
14246 sc->link_params.feature_config_flags |=
14247 ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED;
14248 } else if (sc->autogreeen == AUTO_GREEN_FORCE_OFF) {

--- 14 unchanged lines hidden (view full) ---

14263 ELINK_EEE_MODE_ENABLE_LPI |
14264 ELINK_EEE_MODE_OUTPUT_TIME);
14265 } else {
14266 sc->link_params.eee_mode = 0;
14267 }
14268
14269 /* get the media type */
14270 bxe_media_detect(sc);
14271 ELINK_DEBUG_P1(sc, "detected media type\n", sc->media);
14212}
14213
14214static void
14215bxe_get_params(struct bxe_softc *sc)
14216{
14217 /* get user tunable params */
14218 bxe_get_tunable_params(sc);
14219

--- 1339 unchanged lines hidden (view full) ---

15559 BLOGE(sc, "Invalid bxe_eth_q_stats size (index=%d size=%d)\n",
15560 index, bxe_eth_q_stats_arr[index].size);
15561 return (-1);
15562 }
15563
15564 return (sysctl_handle_64(oidp, &value, 0, req));
15565}
15566
14272}
14273
14274static void
14275bxe_get_params(struct bxe_softc *sc)
14276{
14277 /* get user tunable params */
14278 bxe_get_tunable_params(sc);
14279

--- 1339 unchanged lines hidden (view full) ---

15619 BLOGE(sc, "Invalid bxe_eth_q_stats size (index=%d size=%d)\n",
15620 index, bxe_eth_q_stats_arr[index].size);
15621 return (-1);
15622 }
15623
15624 return (sysctl_handle_64(oidp, &value, 0, req));
15625}
15626
15627static void bxe_force_link_reset(struct bxe_softc *sc)
15628{
15629
15630 bxe_acquire_phy_lock(sc);
15631 elink_link_reset(&sc->link_params, &sc->link_vars, 1);
15632 bxe_release_phy_lock(sc);
15633}
15634
15635static int
15636bxe_sysctl_pauseparam(SYSCTL_HANDLER_ARGS)
15637{
15638 struct bxe_softc *sc = (struct bxe_softc *)arg1;;
15639 uint32_t cfg_idx = bxe_get_link_cfg_idx(sc);
15640 int rc = 0;
15641 int error;
15642 int result;
15643
15644
15645 error = sysctl_handle_int(oidp, &sc->bxe_pause_param, 0, req);
15646
15647 if (error || !req->newptr) {
15648 return (error);
15649 }
15650 if ((sc->bxe_pause_param < 0) || (sc->bxe_pause_param > 8)) {
15651 BLOGW(sc, "invalid pause param (%d) - use intergers between 1 & 8\n",sc->bxe_pause_param);
15652 sc->bxe_pause_param = 8;
15653 }
15654
15655 result = (sc->bxe_pause_param << PORT_FEATURE_FLOW_CONTROL_SHIFT);
15656
15657
15658 if((result & 0x400) && !(sc->port.supported[cfg_idx] & ELINK_SUPPORTED_Autoneg)) {
15659 BLOGW(sc, "Does not support Autoneg pause_param %d\n", sc->bxe_pause_param);
15660 return -EINVAL;
15661 }
15662
15663 if(IS_MF(sc))
15664 return 0;
15665 sc->link_params.req_flow_ctrl[cfg_idx] = ELINK_FLOW_CTRL_AUTO;
15666 if(result & ELINK_FLOW_CTRL_RX)
15667 sc->link_params.req_flow_ctrl[cfg_idx] |= ELINK_FLOW_CTRL_RX;
15668
15669 if(result & ELINK_FLOW_CTRL_TX)
15670 sc->link_params.req_flow_ctrl[cfg_idx] |= ELINK_FLOW_CTRL_TX;
15671 if(sc->link_params.req_flow_ctrl[cfg_idx] == ELINK_FLOW_CTRL_AUTO)
15672 sc->link_params.req_flow_ctrl[cfg_idx] = ELINK_FLOW_CTRL_NONE;
15673
15674 if(result & 0x400) {
15675 if (sc->link_params.req_line_speed[cfg_idx] == ELINK_SPEED_AUTO_NEG) {
15676 sc->link_params.req_flow_ctrl[cfg_idx] =
15677 ELINK_FLOW_CTRL_AUTO;
15678 }
15679 sc->link_params.req_fc_auto_adv = 0;
15680 if (result & ELINK_FLOW_CTRL_RX)
15681 sc->link_params.req_fc_auto_adv |= ELINK_FLOW_CTRL_RX;
15682
15683 if (result & ELINK_FLOW_CTRL_TX)
15684 sc->link_params.req_fc_auto_adv |= ELINK_FLOW_CTRL_TX;
15685 if (!sc->link_params.req_fc_auto_adv)
15686 sc->link_params.req_fc_auto_adv |= ELINK_FLOW_CTRL_NONE;
15687 }
15688 if (IS_PF(sc)) {
15689 if (sc->link_vars.link_up) {
15690 bxe_stats_handle(sc, STATS_EVENT_STOP);
15691 }
15692 if (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) {
15693 bxe_force_link_reset(sc);
15694 bxe_acquire_phy_lock(sc);
15695
15696 rc = elink_phy_init(&sc->link_params, &sc->link_vars);
15697
15698 bxe_release_phy_lock(sc);
15699
15700 bxe_calc_fc_adv(sc);
15701 }
15702 }
15703 return rc;
15704}
15705
15706
15567static void
15568bxe_add_sysctls(struct bxe_softc *sc)
15569{
15570 struct sysctl_ctx_list *ctx;
15571 struct sysctl_oid_list *children;
15572 struct sysctl_oid *queue_top, *queue;
15573 struct sysctl_oid_list *queue_top_children, *queue_children;
15574 char queue_num_buf[32];

--- 84 unchanged lines hidden (view full) ---

15659 CTLFLAG_RD, &sc->grcdump_done, 0,
15660 "set by driver when grcdump is done");
15661
15662 sc->rx_budget = bxe_rx_budget;
15663 SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rx_budget",
15664 CTLFLAG_RW, &sc->rx_budget, 0,
15665 "rx processing budget");
15666
15707static void
15708bxe_add_sysctls(struct bxe_softc *sc)
15709{
15710 struct sysctl_ctx_list *ctx;
15711 struct sysctl_oid_list *children;
15712 struct sysctl_oid *queue_top, *queue;
15713 struct sysctl_oid_list *queue_top_children, *queue_children;
15714 char queue_num_buf[32];

--- 84 unchanged lines hidden (view full) ---

15799 CTLFLAG_RD, &sc->grcdump_done, 0,
15800 "set by driver when grcdump is done");
15801
15802 sc->rx_budget = bxe_rx_budget;
15803 SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rx_budget",
15804 CTLFLAG_RW, &sc->rx_budget, 0,
15805 "rx processing budget");
15806
15807 SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_param",
15808 CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
15809 bxe_sysctl_pauseparam, "IU",
15810 "need pause frames- DEF:0/TX:1/RX:2/BOTH:3/AUTO:4/AUTOTX:5/AUTORX:6/AUTORXTX:7/NONE:8");
15811
15812
15667 SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "state",
15668 CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
15669 bxe_sysctl_state, "IU", "dump driver state");
15670
15671 for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
15672 SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
15673 bxe_eth_stats_arr[i].string,
15674 CTLTYPE_U64 | CTLFLAG_RD, sc, i,

--- 2318 unchanged lines hidden (view full) ---

17993}
17994
17995static void
17996bxe_reset_port(struct bxe_softc *sc)
17997{
17998 int port = SC_PORT(sc);
17999 uint32_t val;
18000
15813 SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "state",
15814 CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
15815 bxe_sysctl_state, "IU", "dump driver state");
15816
15817 for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
15818 SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
15819 bxe_eth_stats_arr[i].string,
15820 CTLTYPE_U64 | CTLFLAG_RD, sc, i,

--- 2318 unchanged lines hidden (view full) ---

18139}
18140
18141static void
18142bxe_reset_port(struct bxe_softc *sc)
18143{
18144 int port = SC_PORT(sc);
18145 uint32_t val;
18146
18147 ELINK_DEBUG_P0(sc, "bxe_reset_port called\n");
18001 /* reset physical Link */
18002 bxe_link_reset(sc);
18003
18004 REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
18005
18006 /* Do not rcv packets to BRB */
18007 REG_WR(sc, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
18008 /* Do not direct rcv packets that are not for MCP to the BRB */

--- 486 unchanged lines hidden (view full) ---

18495 uint32_t preset_idx;
18496 uint8_t *buf;
18497 uint32_t size;
18498 struct dump_header *d_hdr;
18499 uint32_t i;
18500 uint32_t reg_val;
18501 uint32_t reg_addr;
18502 uint32_t cmd_offset;
18148 /* reset physical Link */
18149 bxe_link_reset(sc);
18150
18151 REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
18152
18153 /* Do not rcv packets to BRB */
18154 REG_WR(sc, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
18155 /* Do not direct rcv packets that are not for MCP to the BRB */

--- 486 unchanged lines hidden (view full) ---

18642 uint32_t preset_idx;
18643 uint8_t *buf;
18644 uint32_t size;
18645 struct dump_header *d_hdr;
18646 uint32_t i;
18647 uint32_t reg_val;
18648 uint32_t reg_addr;
18649 uint32_t cmd_offset;
18503 int context_size;
18504 int allocated;
18505 struct ecore_ilt *ilt = SC_ILT(sc);
18506 struct bxe_fastpath *fp;
18507 struct ilt_client_info *ilt_cli;
18508 int grc_dump_size;
18509
18510
18511 if (sc->grcdump_done || sc->grcdump_started)
18512 return (rval);

--- 78 unchanged lines hidden (view full) ---

18591 bxe_pretend_func(sc, 1);
18592 ecore_clear_blocks_parity(sc);
18593 ecore_enable_blocks_parity(sc);
18594
18595 /* Return to current function */
18596 bxe_pretend_func(sc, SC_ABS_FUNC(sc));
18597
18598
18650 struct ecore_ilt *ilt = SC_ILT(sc);
18651 struct bxe_fastpath *fp;
18652 struct ilt_client_info *ilt_cli;
18653 int grc_dump_size;
18654
18655
18656 if (sc->grcdump_done || sc->grcdump_started)
18657 return (rval);

--- 78 unchanged lines hidden (view full) ---

18736 bxe_pretend_func(sc, 1);
18737 ecore_clear_blocks_parity(sc);
18738 ecore_enable_blocks_parity(sc);
18739
18740 /* Return to current function */
18741 bxe_pretend_func(sc, SC_ABS_FUNC(sc));
18742
18743
18599 context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc));
18600 for (i = 0, allocated = 0; allocated < context_size; i++) {
18601
18744
18602 BLOGI(sc, "cdu_context i %d paddr %#jx vaddr %p size 0x%zx\n", i,
18603 (uintmax_t)sc->context[i].vcxt_dma.paddr,
18604 sc->context[i].vcxt_dma.vaddr,
18605 sc->context[i].size);
18606 allocated += sc->context[i].size;
18607 }
18608 BLOGI(sc, "fw stats start_paddr %#jx end_paddr %#jx vaddr %p size 0x%x\n",
18609 (uintmax_t)sc->fw_stats_req_mapping,
18610 (uintmax_t)sc->fw_stats_data_mapping,
18611 sc->fw_stats_req, (sc->fw_stats_req_size + sc->fw_stats_data_size));
18612 BLOGI(sc, "def_status_block paddr %p vaddr %p size 0x%zx\n",
18613 (void *)sc->def_sb_dma.paddr, sc->def_sb,
18614 sizeof(struct host_sp_status_block));
18615 BLOGI(sc, "event_queue paddr %#jx vaddr %p size 0x%x\n",
18616 (uintmax_t)sc->eq_dma.paddr, sc->eq_dma.vaddr, BCM_PAGE_SIZE);
18617 BLOGI(sc, "slow path paddr %#jx vaddr %p size 0x%zx\n",
18618 (uintmax_t)sc->sp_dma.paddr, sc->sp_dma.vaddr,
18619 sizeof(struct bxe_slowpath));
18620 BLOGI(sc, "slow path queue paddr %#jx vaddr %p size 0x%x\n",
18621 (uintmax_t)sc->spq_dma.paddr, sc->spq_dma.vaddr, BCM_PAGE_SIZE);
18622 BLOGI(sc, "fw_buf paddr %#jx vaddr %p size 0x%x\n",
18623 (uintmax_t)sc->gz_buf_dma.paddr, sc->gz_buf_dma.vaddr,
18624 FW_BUF_SIZE);
18625 for (i = 0; i < sc->num_queues; i++) {
18626 fp = &sc->fp[i];
18627 BLOGI(sc, "FP status block fp %d paddr %#jx vaddr %p size 0x%zx\n", i,
18628 (uintmax_t)fp->sb_dma.paddr, fp->sb_dma.vaddr,
18629 sizeof(union bxe_host_hc_status_block));
18630 BLOGI(sc, "TX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18631 (uintmax_t)fp->tx_dma.paddr, fp->tx_dma.vaddr,
18632 (BCM_PAGE_SIZE * TX_BD_NUM_PAGES));
18633 BLOGI(sc, "RX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18634 (uintmax_t)fp->rx_dma.paddr, fp->rx_dma.vaddr,
18635 (BCM_PAGE_SIZE * RX_BD_NUM_PAGES));
18636 BLOGI(sc, "RX RCQ CHAIN fp %d paddr %#jx vaddr %p size 0x%zx\n", i,
18637 (uintmax_t)fp->rcq_dma.paddr, fp->rcq_dma.vaddr,
18638 (BCM_PAGE_SIZE * RCQ_NUM_PAGES));
18639 BLOGI(sc, "RX SGE CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18640 (uintmax_t)fp->rx_sge_dma.paddr, fp->rx_sge_dma.vaddr,
18641 (BCM_PAGE_SIZE * RX_SGE_NUM_PAGES));
18642 }
18745 if(sc->state == BXE_STATE_OPEN) {
18746 if(sc->fw_stats_req != NULL) {
18747 BLOGI(sc, "fw stats start_paddr %#jx end_paddr %#jx vaddr %p size 0x%x\n",
18748 (uintmax_t)sc->fw_stats_req_mapping,
18749 (uintmax_t)sc->fw_stats_data_mapping,
18750 sc->fw_stats_req, (sc->fw_stats_req_size + sc->fw_stats_data_size));
18751 }
18752 if(sc->def_sb != NULL) {
18753 BLOGI(sc, "def_status_block paddr %p vaddr %p size 0x%zx\n",
18754 (void *)sc->def_sb_dma.paddr, sc->def_sb,
18755 sizeof(struct host_sp_status_block));
18756 }
18757 if(sc->eq_dma.vaddr != NULL) {
18758 BLOGI(sc, "event_queue paddr %#jx vaddr %p size 0x%x\n",
18759 (uintmax_t)sc->eq_dma.paddr, sc->eq_dma.vaddr, BCM_PAGE_SIZE);
18760 }
18761 if(sc->sp_dma.vaddr != NULL) {
18762 BLOGI(sc, "slow path paddr %#jx vaddr %p size 0x%zx\n",
18763 (uintmax_t)sc->sp_dma.paddr, sc->sp_dma.vaddr,
18764 sizeof(struct bxe_slowpath));
18765 }
18766 if(sc->spq_dma.vaddr != NULL) {
18767 BLOGI(sc, "slow path queue paddr %#jx vaddr %p size 0x%x\n",
18768 (uintmax_t)sc->spq_dma.paddr, sc->spq_dma.vaddr, BCM_PAGE_SIZE);
18769 }
18770 if(sc->gz_buf_dma.vaddr != NULL) {
18771 BLOGI(sc, "fw_buf paddr %#jx vaddr %p size 0x%x\n",
18772 (uintmax_t)sc->gz_buf_dma.paddr, sc->gz_buf_dma.vaddr,
18773 FW_BUF_SIZE);
18774 }
18775 for (i = 0; i < sc->num_queues; i++) {
18776 fp = &sc->fp[i];
18777 if(fp->sb_dma.vaddr != NULL && fp->tx_dma.vaddr != NULL &&
18778 fp->rx_dma.vaddr != NULL && fp->rcq_dma.vaddr != NULL &&
18779 fp->rx_sge_dma.vaddr != NULL) {
18643
18780
18644 ilt_cli = &ilt->clients[1];
18645 for (i = ilt_cli->start; i <= ilt_cli->end; i++) {
18646 BLOGI(sc, "ECORE_ILT paddr %#jx vaddr %p size 0x%x\n",
18647 (uintmax_t)(((struct bxe_dma *)((&ilt->lines[i])->page))->paddr),
18648 ((struct bxe_dma *)((&ilt->lines[i])->page))->vaddr, BCM_PAGE_SIZE);
18649 }
18781 BLOGI(sc, "FP status block fp %d paddr %#jx vaddr %p size 0x%zx\n", i,
18782 (uintmax_t)fp->sb_dma.paddr, fp->sb_dma.vaddr,
18783 sizeof(union bxe_host_hc_status_block));
18784 BLOGI(sc, "TX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18785 (uintmax_t)fp->tx_dma.paddr, fp->tx_dma.vaddr,
18786 (BCM_PAGE_SIZE * TX_BD_NUM_PAGES));
18787 BLOGI(sc, "RX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18788 (uintmax_t)fp->rx_dma.paddr, fp->rx_dma.vaddr,
18789 (BCM_PAGE_SIZE * RX_BD_NUM_PAGES));
18790 BLOGI(sc, "RX RCQ CHAIN fp %d paddr %#jx vaddr %p size 0x%zx\n", i,
18791 (uintmax_t)fp->rcq_dma.paddr, fp->rcq_dma.vaddr,
18792 (BCM_PAGE_SIZE * RCQ_NUM_PAGES));
18793 BLOGI(sc, "RX SGE CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i,
18794 (uintmax_t)fp->rx_sge_dma.paddr, fp->rx_sge_dma.vaddr,
18795 (BCM_PAGE_SIZE * RX_SGE_NUM_PAGES));
18796 }
18797 }
18798 if(ilt != NULL ) {
18799 ilt_cli = &ilt->clients[1];
18800 if(ilt->lines != NULL) {
18801 for (i = ilt_cli->start; i <= ilt_cli->end; i++) {
18802 BLOGI(sc, "ECORE_ILT paddr %#jx vaddr %p size 0x%x\n",
18803 (uintmax_t)(((struct bxe_dma *)((&ilt->lines[i])->page))->paddr),
18804 ((struct bxe_dma *)((&ilt->lines[i])->page))->vaddr, BCM_PAGE_SIZE);
18805 }
18806 }
18807 }
18650
18651
18808
18809
18652 cmd_offset = DMAE_REG_CMD_MEM;
18653 for (i = 0; i < 224; i++) {
18654 reg_addr = (cmd_offset +(i * 4));
18655 reg_val = REG_RD(sc, reg_addr);
18656 BLOGI(sc, "DMAE_REG_CMD_MEM i=%d reg_addr 0x%x reg_val 0x%08x\n",i,
18657 reg_addr, reg_val);
18658 }
18810 cmd_offset = DMAE_REG_CMD_MEM;
18811 for (i = 0; i < 224; i++) {
18812 reg_addr = (cmd_offset +(i * 4));
18813 reg_val = REG_RD(sc, reg_addr);
18814 BLOGI(sc, "DMAE_REG_CMD_MEM i=%d reg_addr 0x%x reg_val 0x%08x\n",i,
18815 reg_addr, reg_val);
18816 }
18817 }
18659
18818
18660
18661 BLOGI(sc, "Collection of grcdump done\n");
18662 sc->grcdump_done = 1;
18663 return(rval);
18664}
18665
18666static int
18667bxe_add_cdev(struct bxe_softc *sc)
18668{

--- 330 unchanged lines hidden --- 		18819 BLOGI(sc, "Collection of grcdump done\n");
18820 sc->grcdump_done = 1;
18821 return(rval);
18822}
18823
18824static int
18825bxe_add_cdev(struct bxe_softc *sc)
18826{

--- 330 unchanged lines hidden ---