mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 lines
10 KiB
363 lines
10 KiB
/***********************license start*************** |
|
* Author: Cavium Networks |
|
* |
|
* Contact: [email protected] |
|
* This file is part of the OCTEON SDK |
|
* |
|
* Copyright (c) 2003-2008 Cavium Networks |
|
* |
|
* This file is free software; you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License, Version 2, as |
|
* published by the Free Software Foundation. |
|
* |
|
* This file is distributed in the hope that it will be useful, but |
|
* AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty |
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or |
|
* NONINFRINGEMENT. See the GNU General Public License for more |
|
* details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with this file; if not, write to the Free Software |
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
|
* or visit http://www.gnu.org/licenses/. |
|
* |
|
* This file may also be available under a different license from Cavium. |
|
* Contact Cavium Networks for more information |
|
***********************license end**************************************/ |
|
|
|
/* |
|
* Small helper utilities. |
|
*/ |
|
#include <linux/kernel.h> |
|
|
|
#include <asm/octeon/octeon.h> |
|
|
|
#include <asm/octeon/cvmx-config.h> |
|
|
|
#include <asm/octeon/cvmx-fpa.h> |
|
#include <asm/octeon/cvmx-pip.h> |
|
#include <asm/octeon/cvmx-pko.h> |
|
#include <asm/octeon/cvmx-ipd.h> |
|
#include <asm/octeon/cvmx-spi.h> |
|
|
|
#include <asm/octeon/cvmx-helper.h> |
|
#include <asm/octeon/cvmx-helper-util.h> |
|
|
|
#include <asm/octeon/cvmx-ipd-defs.h> |
|
|
|
/** |
|
* Convert a interface mode into a human readable string |
|
* |
|
* @mode: Mode to convert |
|
* |
|
* Returns String |
|
*/ |
|
const char *cvmx_helper_interface_mode_to_string(cvmx_helper_interface_mode_t |
|
mode) |
|
{ |
|
switch (mode) { |
|
case CVMX_HELPER_INTERFACE_MODE_DISABLED: |
|
return "DISABLED"; |
|
case CVMX_HELPER_INTERFACE_MODE_RGMII: |
|
return "RGMII"; |
|
case CVMX_HELPER_INTERFACE_MODE_GMII: |
|
return "GMII"; |
|
case CVMX_HELPER_INTERFACE_MODE_SPI: |
|
return "SPI"; |
|
case CVMX_HELPER_INTERFACE_MODE_PCIE: |
|
return "PCIE"; |
|
case CVMX_HELPER_INTERFACE_MODE_XAUI: |
|
return "XAUI"; |
|
case CVMX_HELPER_INTERFACE_MODE_SGMII: |
|
return "SGMII"; |
|
case CVMX_HELPER_INTERFACE_MODE_PICMG: |
|
return "PICMG"; |
|
case CVMX_HELPER_INTERFACE_MODE_NPI: |
|
return "NPI"; |
|
case CVMX_HELPER_INTERFACE_MODE_LOOP: |
|
return "LOOP"; |
|
} |
|
return "UNKNOWN"; |
|
} |
|
|
|
/** |
|
* Setup Random Early Drop on a specific input queue |
|
* |
|
* @queue: Input queue to setup RED on (0-7) |
|
* @pass_thresh: |
|
* Packets will begin slowly dropping when there are less than |
|
* this many packet buffers free in FPA 0. |
|
* @drop_thresh: |
|
* All incoming packets will be dropped when there are less |
|
* than this many free packet buffers in FPA 0. |
|
* Returns Zero on success. Negative on failure |
|
*/ |
|
static int cvmx_helper_setup_red_queue(int queue, int pass_thresh, |
|
int drop_thresh) |
|
{ |
|
union cvmx_ipd_qosx_red_marks red_marks; |
|
union cvmx_ipd_red_quex_param red_param; |
|
|
|
/* Set RED to begin dropping packets when there are pass_thresh buffers |
|
left. It will linearly drop more packets until reaching drop_thresh |
|
buffers */ |
|
red_marks.u64 = 0; |
|
red_marks.s.drop = drop_thresh; |
|
red_marks.s.pass = pass_thresh; |
|
cvmx_write_csr(CVMX_IPD_QOSX_RED_MARKS(queue), red_marks.u64); |
|
|
|
/* Use the actual queue 0 counter, not the average */ |
|
red_param.u64 = 0; |
|
red_param.s.prb_con = |
|
(255ul << 24) / (red_marks.s.pass - red_marks.s.drop); |
|
red_param.s.avg_con = 1; |
|
red_param.s.new_con = 255; |
|
red_param.s.use_pcnt = 1; |
|
cvmx_write_csr(CVMX_IPD_RED_QUEX_PARAM(queue), red_param.u64); |
|
return 0; |
|
} |
|
|
|
/** |
|
* Setup Random Early Drop to automatically begin dropping packets. |
|
* |
|
* @pass_thresh: |
|
* Packets will begin slowly dropping when there are less than |
|
* this many packet buffers free in FPA 0. |
|
* @drop_thresh: |
|
* All incoming packets will be dropped when there are less |
|
* than this many free packet buffers in FPA 0. |
|
* Returns Zero on success. Negative on failure |
|
*/ |
|
int cvmx_helper_setup_red(int pass_thresh, int drop_thresh) |
|
{ |
|
union cvmx_ipd_portx_bp_page_cnt page_cnt; |
|
union cvmx_ipd_bp_prt_red_end ipd_bp_prt_red_end; |
|
union cvmx_ipd_red_port_enable red_port_enable; |
|
int queue; |
|
int interface; |
|
int port; |
|
|
|
/* Disable backpressure based on queued buffers. It needs SW support */ |
|
page_cnt.u64 = 0; |
|
page_cnt.s.bp_enb = 0; |
|
page_cnt.s.page_cnt = 100; |
|
for (interface = 0; interface < 2; interface++) { |
|
for (port = cvmx_helper_get_first_ipd_port(interface); |
|
port < cvmx_helper_get_last_ipd_port(interface); port++) |
|
cvmx_write_csr(CVMX_IPD_PORTX_BP_PAGE_CNT(port), |
|
page_cnt.u64); |
|
} |
|
|
|
for (queue = 0; queue < 8; queue++) |
|
cvmx_helper_setup_red_queue(queue, pass_thresh, drop_thresh); |
|
|
|
/* Shutoff the dropping based on the per port page count. SW isn't |
|
decrementing it right now */ |
|
ipd_bp_prt_red_end.u64 = 0; |
|
ipd_bp_prt_red_end.s.prt_enb = 0; |
|
cvmx_write_csr(CVMX_IPD_BP_PRT_RED_END, ipd_bp_prt_red_end.u64); |
|
|
|
red_port_enable.u64 = 0; |
|
red_port_enable.s.prt_enb = 0xfffffffffull; |
|
red_port_enable.s.avg_dly = 10000; |
|
red_port_enable.s.prb_dly = 10000; |
|
cvmx_write_csr(CVMX_IPD_RED_PORT_ENABLE, red_port_enable.u64); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(cvmx_helper_setup_red); |
|
|
|
/** |
|
* Setup the common GMX settings that determine the number of |
|
* ports. These setting apply to almost all configurations of all |
|
* chips. |
|
* |
|
* @interface: Interface to configure |
|
* @num_ports: Number of ports on the interface |
|
* |
|
* Returns Zero on success, negative on failure |
|
*/ |
|
int __cvmx_helper_setup_gmx(int interface, int num_ports) |
|
{ |
|
union cvmx_gmxx_tx_prts gmx_tx_prts; |
|
union cvmx_gmxx_rx_prts gmx_rx_prts; |
|
union cvmx_pko_reg_gmx_port_mode pko_mode; |
|
union cvmx_gmxx_txx_thresh gmx_tx_thresh; |
|
int index; |
|
|
|
/* Tell GMX the number of TX ports on this interface */ |
|
gmx_tx_prts.u64 = cvmx_read_csr(CVMX_GMXX_TX_PRTS(interface)); |
|
gmx_tx_prts.s.prts = num_ports; |
|
cvmx_write_csr(CVMX_GMXX_TX_PRTS(interface), gmx_tx_prts.u64); |
|
|
|
/* Tell GMX the number of RX ports on this interface. This only |
|
** applies to *GMII and XAUI ports */ |
|
if (cvmx_helper_interface_get_mode(interface) == |
|
CVMX_HELPER_INTERFACE_MODE_RGMII |
|
|| cvmx_helper_interface_get_mode(interface) == |
|
CVMX_HELPER_INTERFACE_MODE_SGMII |
|
|| cvmx_helper_interface_get_mode(interface) == |
|
CVMX_HELPER_INTERFACE_MODE_GMII |
|
|| cvmx_helper_interface_get_mode(interface) == |
|
CVMX_HELPER_INTERFACE_MODE_XAUI) { |
|
if (num_ports > 4) { |
|
cvmx_dprintf("__cvmx_helper_setup_gmx: Illegal " |
|
"num_ports\n"); |
|
return -1; |
|
} |
|
|
|
gmx_rx_prts.u64 = cvmx_read_csr(CVMX_GMXX_RX_PRTS(interface)); |
|
gmx_rx_prts.s.prts = num_ports; |
|
cvmx_write_csr(CVMX_GMXX_RX_PRTS(interface), gmx_rx_prts.u64); |
|
} |
|
|
|
/* Skip setting CVMX_PKO_REG_GMX_PORT_MODE on 30XX, 31XX, and 50XX */ |
|
if (!OCTEON_IS_MODEL(OCTEON_CN30XX) && !OCTEON_IS_MODEL(OCTEON_CN31XX) |
|
&& !OCTEON_IS_MODEL(OCTEON_CN50XX)) { |
|
/* Tell PKO the number of ports on this interface */ |
|
pko_mode.u64 = cvmx_read_csr(CVMX_PKO_REG_GMX_PORT_MODE); |
|
if (interface == 0) { |
|
if (num_ports == 1) |
|
pko_mode.s.mode0 = 4; |
|
else if (num_ports == 2) |
|
pko_mode.s.mode0 = 3; |
|
else if (num_ports <= 4) |
|
pko_mode.s.mode0 = 2; |
|
else if (num_ports <= 8) |
|
pko_mode.s.mode0 = 1; |
|
else |
|
pko_mode.s.mode0 = 0; |
|
} else { |
|
if (num_ports == 1) |
|
pko_mode.s.mode1 = 4; |
|
else if (num_ports == 2) |
|
pko_mode.s.mode1 = 3; |
|
else if (num_ports <= 4) |
|
pko_mode.s.mode1 = 2; |
|
else if (num_ports <= 8) |
|
pko_mode.s.mode1 = 1; |
|
else |
|
pko_mode.s.mode1 = 0; |
|
} |
|
cvmx_write_csr(CVMX_PKO_REG_GMX_PORT_MODE, pko_mode.u64); |
|
} |
|
|
|
/* |
|
* Set GMX to buffer as much data as possible before starting |
|
* transmit. This reduces the chances that we have a TX under |
|
* run due to memory contention. Any packet that fits entirely |
|
* in the GMX FIFO can never have an under run regardless of |
|
* memory load. |
|
*/ |
|
gmx_tx_thresh.u64 = cvmx_read_csr(CVMX_GMXX_TXX_THRESH(0, interface)); |
|
if (OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX) |
|
|| OCTEON_IS_MODEL(OCTEON_CN50XX)) { |
|
/* These chips have a fixed max threshold of 0x40 */ |
|
gmx_tx_thresh.s.cnt = 0x40; |
|
} else { |
|
/* Choose the max value for the number of ports */ |
|
if (num_ports <= 1) |
|
gmx_tx_thresh.s.cnt = 0x100 / 1; |
|
else if (num_ports == 2) |
|
gmx_tx_thresh.s.cnt = 0x100 / 2; |
|
else |
|
gmx_tx_thresh.s.cnt = 0x100 / 4; |
|
} |
|
/* |
|
* SPI and XAUI can have lots of ports but the GMX hardware |
|
* only ever has a max of 4. |
|
*/ |
|
if (num_ports > 4) |
|
num_ports = 4; |
|
for (index = 0; index < num_ports; index++) |
|
cvmx_write_csr(CVMX_GMXX_TXX_THRESH(index, interface), |
|
gmx_tx_thresh.u64); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* Returns the IPD/PKO port number for a port on the given |
|
* interface. |
|
* |
|
* @interface: Interface to use |
|
* @port: Port on the interface |
|
* |
|
* Returns IPD/PKO port number |
|
*/ |
|
int cvmx_helper_get_ipd_port(int interface, int port) |
|
{ |
|
switch (interface) { |
|
case 0: |
|
return port; |
|
case 1: |
|
return port + 16; |
|
case 2: |
|
return port + 32; |
|
case 3: |
|
return port + 36; |
|
case 4: |
|
return port + 40; |
|
case 5: |
|
return port + 44; |
|
} |
|
return -1; |
|
} |
|
EXPORT_SYMBOL_GPL(cvmx_helper_get_ipd_port); |
|
|
|
/** |
|
* Returns the interface number for an IPD/PKO port number. |
|
* |
|
* @ipd_port: IPD/PKO port number |
|
* |
|
* Returns Interface number |
|
*/ |
|
int cvmx_helper_get_interface_num(int ipd_port) |
|
{ |
|
if (ipd_port < 16) |
|
return 0; |
|
else if (ipd_port < 32) |
|
return 1; |
|
else if (ipd_port < 36) |
|
return 2; |
|
else if (ipd_port < 40) |
|
return 3; |
|
else if (ipd_port < 44) |
|
return 4; |
|
else if (ipd_port < 48) |
|
return 5; |
|
else |
|
cvmx_dprintf("cvmx_helper_get_interface_num: Illegal IPD " |
|
"port number\n"); |
|
|
|
return -1; |
|
} |
|
EXPORT_SYMBOL_GPL(cvmx_helper_get_interface_num); |
|
|
|
/** |
|
* Returns the interface index number for an IPD/PKO port |
|
* number. |
|
* |
|
* @ipd_port: IPD/PKO port number |
|
* |
|
* Returns Interface index number |
|
*/ |
|
int cvmx_helper_get_interface_index_num(int ipd_port) |
|
{ |
|
if (ipd_port < 32) |
|
return ipd_port & 15; |
|
else if (ipd_port < 36) |
|
return ipd_port & 3; |
|
else if (ipd_port < 40) |
|
return ipd_port & 3; |
|
else if (ipd_port < 44) |
|
return ipd_port & 3; |
|
else if (ipd_port < 48) |
|
return ipd_port & 3; |
|
else |
|
cvmx_dprintf("cvmx_helper_get_interface_index_num: " |
|
"Illegal IPD port number\n"); |
|
|
|
return -1; |
|
} |
|
EXPORT_SYMBOL_GPL(cvmx_helper_get_interface_index_num);
|
|
|