1 /***********************license start*************** 2 * Author: Cavium Networks 3 * 4 * Contact: support@caviumnetworks.com 5 * This file is part of the OCTEON SDK 6 * 7 * Copyright (c) 2003-2008 Cavium Networks 8 * 9 * This file is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License, Version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This file is distributed in the hope that it will be useful, but 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 16 * NONINFRINGEMENT. See the GNU General Public License for more 17 * details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this file; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * or visit http://www.gnu.org/licenses/. 23 * 24 * This file may also be available under a different license from Cavium. 25 * Contact Cavium Networks for more information 26 ***********************license end**************************************/ 27 28 /* 29 * Small helper utilities. 30 */ 31 #include <linux/kernel.h> 32 33 #include <asm/octeon/octeon.h> 34 35 #include <asm/octeon/cvmx-config.h> 36 37 #include <asm/octeon/cvmx-fpa.h> 38 #include <asm/octeon/cvmx-pip.h> 39 #include <asm/octeon/cvmx-pko.h> 40 #include <asm/octeon/cvmx-ipd.h> 41 #include <asm/octeon/cvmx-spi.h> 42 43 #include <asm/octeon/cvmx-helper.h> 44 #include <asm/octeon/cvmx-helper-util.h> 45 46 #include <asm/octeon/cvmx-ipd-defs.h> 47 48 /** 49 * Convert a interface mode into a human readable string 50 * 51 * @mode: Mode to convert 52 * 53 * Returns String 54 */ 55 const char *cvmx_helper_interface_mode_to_string(cvmx_helper_interface_mode_t 56 mode) 57 { 58 switch (mode) { 59 case CVMX_HELPER_INTERFACE_MODE_DISABLED: 60 return "DISABLED"; 61 case CVMX_HELPER_INTERFACE_MODE_RGMII: 62 return "RGMII"; 63 case CVMX_HELPER_INTERFACE_MODE_GMII: 64 return "GMII"; 65 case CVMX_HELPER_INTERFACE_MODE_SPI: 66 return "SPI"; 67 case CVMX_HELPER_INTERFACE_MODE_PCIE: 68 return "PCIE"; 69 case CVMX_HELPER_INTERFACE_MODE_XAUI: 70 return "XAUI"; 71 case CVMX_HELPER_INTERFACE_MODE_SGMII: 72 return "SGMII"; 73 case CVMX_HELPER_INTERFACE_MODE_PICMG: 74 return "PICMG"; 75 case CVMX_HELPER_INTERFACE_MODE_NPI: 76 return "NPI"; 77 case CVMX_HELPER_INTERFACE_MODE_LOOP: 78 return "LOOP"; 79 } 80 return "UNKNOWN"; 81 } 82 83 /** 84 * Setup Random Early Drop on a specific input queue 85 * 86 * @queue: Input queue to setup RED on (0-7) 87 * @pass_thresh: 88 * Packets will begin slowly dropping when there are less than 89 * this many packet buffers free in FPA 0. 90 * @drop_thresh: 91 * All incoming packets will be dropped when there are less 92 * than this many free packet buffers in FPA 0. 93 * Returns Zero on success. Negative on failure 94 */ 95 static int cvmx_helper_setup_red_queue(int queue, int pass_thresh, 96 int drop_thresh) 97 { 98 union cvmx_ipd_qosx_red_marks red_marks; 99 union cvmx_ipd_red_quex_param red_param; 100 101 /* Set RED to begin dropping packets when there are pass_thresh buffers 102 left. It will linearly drop more packets until reaching drop_thresh 103 buffers */ 104 red_marks.u64 = 0; 105 red_marks.s.drop = drop_thresh; 106 red_marks.s.pass = pass_thresh; 107 cvmx_write_csr(CVMX_IPD_QOSX_RED_MARKS(queue), red_marks.u64); 108 109 /* Use the actual queue 0 counter, not the average */ 110 red_param.u64 = 0; 111 red_param.s.prb_con = 112 (255ul << 24) / (red_marks.s.pass - red_marks.s.drop); 113 red_param.s.avg_con = 1; 114 red_param.s.new_con = 255; 115 red_param.s.use_pcnt = 1; 116 cvmx_write_csr(CVMX_IPD_RED_QUEX_PARAM(queue), red_param.u64); 117 return 0; 118 } 119 120 /** 121 * Setup Random Early Drop to automatically begin dropping packets. 122 * 123 * @pass_thresh: 124 * Packets will begin slowly dropping when there are less than 125 * this many packet buffers free in FPA 0. 126 * @drop_thresh: 127 * All incoming packets will be dropped when there are less 128 * than this many free packet buffers in FPA 0. 129 * Returns Zero on success. Negative on failure 130 */ 131 int cvmx_helper_setup_red(int pass_thresh, int drop_thresh) 132 { 133 union cvmx_ipd_portx_bp_page_cnt page_cnt; 134 union cvmx_ipd_bp_prt_red_end ipd_bp_prt_red_end; 135 union cvmx_ipd_red_port_enable red_port_enable; 136 int queue; 137 int interface; 138 int port; 139 140 /* Disable backpressure based on queued buffers. It needs SW support */ 141 page_cnt.u64 = 0; 142 page_cnt.s.bp_enb = 0; 143 page_cnt.s.page_cnt = 100; 144 for (interface = 0; interface < 2; interface++) { 145 for (port = cvmx_helper_get_first_ipd_port(interface); 146 port < cvmx_helper_get_last_ipd_port(interface); port++) 147 cvmx_write_csr(CVMX_IPD_PORTX_BP_PAGE_CNT(port), 148 page_cnt.u64); 149 } 150 151 for (queue = 0; queue < 8; queue++) 152 cvmx_helper_setup_red_queue(queue, pass_thresh, drop_thresh); 153 154 /* Shutoff the dropping based on the per port page count. SW isn't 155 decrementing it right now */ 156 ipd_bp_prt_red_end.u64 = 0; 157 ipd_bp_prt_red_end.s.prt_enb = 0; 158 cvmx_write_csr(CVMX_IPD_BP_PRT_RED_END, ipd_bp_prt_red_end.u64); 159 160 red_port_enable.u64 = 0; 161 red_port_enable.s.prt_enb = 0xfffffffffull; 162 red_port_enable.s.avg_dly = 10000; 163 red_port_enable.s.prb_dly = 10000; 164 cvmx_write_csr(CVMX_IPD_RED_PORT_ENABLE, red_port_enable.u64); 165 166 return 0; 167 } 168 EXPORT_SYMBOL_GPL(cvmx_helper_setup_red); 169 170 /** 171 * Setup the common GMX settings that determine the number of 172 * ports. These setting apply to almost all configurations of all 173 * chips. 174 * 175 * @interface: Interface to configure 176 * @num_ports: Number of ports on the interface 177 * 178 * Returns Zero on success, negative on failure 179 */ 180 int __cvmx_helper_setup_gmx(int interface, int num_ports) 181 { 182 union cvmx_gmxx_tx_prts gmx_tx_prts; 183 union cvmx_gmxx_rx_prts gmx_rx_prts; 184 union cvmx_pko_reg_gmx_port_mode pko_mode; 185 union cvmx_gmxx_txx_thresh gmx_tx_thresh; 186 int index; 187 188 /* Tell GMX the number of TX ports on this interface */ 189 gmx_tx_prts.u64 = cvmx_read_csr(CVMX_GMXX_TX_PRTS(interface)); 190 gmx_tx_prts.s.prts = num_ports; 191 cvmx_write_csr(CVMX_GMXX_TX_PRTS(interface), gmx_tx_prts.u64); 192 193 /* Tell GMX the number of RX ports on this interface. This only 194 ** applies to *GMII and XAUI ports */ 195 if (cvmx_helper_interface_get_mode(interface) == 196 CVMX_HELPER_INTERFACE_MODE_RGMII 197 || cvmx_helper_interface_get_mode(interface) == 198 CVMX_HELPER_INTERFACE_MODE_SGMII 199 || cvmx_helper_interface_get_mode(interface) == 200 CVMX_HELPER_INTERFACE_MODE_GMII 201 || cvmx_helper_interface_get_mode(interface) == 202 CVMX_HELPER_INTERFACE_MODE_XAUI) { 203 if (num_ports > 4) { 204 cvmx_dprintf("__cvmx_helper_setup_gmx: Illegal " 205 "num_ports\n"); 206 return -1; 207 } 208 209 gmx_rx_prts.u64 = cvmx_read_csr(CVMX_GMXX_RX_PRTS(interface)); 210 gmx_rx_prts.s.prts = num_ports; 211 cvmx_write_csr(CVMX_GMXX_RX_PRTS(interface), gmx_rx_prts.u64); 212 } 213 214 /* Skip setting CVMX_PKO_REG_GMX_PORT_MODE on 30XX, 31XX, and 50XX */ 215 if (!OCTEON_IS_MODEL(OCTEON_CN30XX) && !OCTEON_IS_MODEL(OCTEON_CN31XX) 216 && !OCTEON_IS_MODEL(OCTEON_CN50XX)) { 217 /* Tell PKO the number of ports on this interface */ 218 pko_mode.u64 = cvmx_read_csr(CVMX_PKO_REG_GMX_PORT_MODE); 219 if (interface == 0) { 220 if (num_ports == 1) 221 pko_mode.s.mode0 = 4; 222 else if (num_ports == 2) 223 pko_mode.s.mode0 = 3; 224 else if (num_ports <= 4) 225 pko_mode.s.mode0 = 2; 226 else if (num_ports <= 8) 227 pko_mode.s.mode0 = 1; 228 else 229 pko_mode.s.mode0 = 0; 230 } else { 231 if (num_ports == 1) 232 pko_mode.s.mode1 = 4; 233 else if (num_ports == 2) 234 pko_mode.s.mode1 = 3; 235 else if (num_ports <= 4) 236 pko_mode.s.mode1 = 2; 237 else if (num_ports <= 8) 238 pko_mode.s.mode1 = 1; 239 else 240 pko_mode.s.mode1 = 0; 241 } 242 cvmx_write_csr(CVMX_PKO_REG_GMX_PORT_MODE, pko_mode.u64); 243 } 244 245 /* 246 * Set GMX to buffer as much data as possible before starting 247 * transmit. This reduces the chances that we have a TX under 248 * run due to memory contention. Any packet that fits entirely 249 * in the GMX FIFO can never have an under run regardless of 250 * memory load. 251 */ 252 gmx_tx_thresh.u64 = cvmx_read_csr(CVMX_GMXX_TXX_THRESH(0, interface)); 253 if (OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX) 254 || OCTEON_IS_MODEL(OCTEON_CN50XX)) { 255 /* These chips have a fixed max threshold of 0x40 */ 256 gmx_tx_thresh.s.cnt = 0x40; 257 } else { 258 /* Choose the max value for the number of ports */ 259 if (num_ports <= 1) 260 gmx_tx_thresh.s.cnt = 0x100 / 1; 261 else if (num_ports == 2) 262 gmx_tx_thresh.s.cnt = 0x100 / 2; 263 else 264 gmx_tx_thresh.s.cnt = 0x100 / 4; 265 } 266 /* 267 * SPI and XAUI can have lots of ports but the GMX hardware 268 * only ever has a max of 4. 269 */ 270 if (num_ports > 4) 271 num_ports = 4; 272 for (index = 0; index < num_ports; index++) 273 cvmx_write_csr(CVMX_GMXX_TXX_THRESH(index, interface), 274 gmx_tx_thresh.u64); 275 276 return 0; 277 } 278 279 /** 280 * Returns the IPD/PKO port number for a port on the given 281 * interface. 282 * 283 * @interface: Interface to use 284 * @port: Port on the interface 285 * 286 * Returns IPD/PKO port number 287 */ 288 int cvmx_helper_get_ipd_port(int interface, int port) 289 { 290 switch (interface) { 291 case 0: 292 return port; 293 case 1: 294 return port + 16; 295 case 2: 296 return port + 32; 297 case 3: 298 return port + 36; 299 case 4: 300 return port + 40; 301 case 5: 302 return port + 44; 303 } 304 return -1; 305 } 306 EXPORT_SYMBOL_GPL(cvmx_helper_get_ipd_port); 307 308 /** 309 * Returns the interface number for an IPD/PKO port number. 310 * 311 * @ipd_port: IPD/PKO port number 312 * 313 * Returns Interface number 314 */ 315 int cvmx_helper_get_interface_num(int ipd_port) 316 { 317 if (ipd_port < 16) 318 return 0; 319 else if (ipd_port < 32) 320 return 1; 321 else if (ipd_port < 36) 322 return 2; 323 else if (ipd_port < 40) 324 return 3; 325 else if (ipd_port < 44) 326 return 4; 327 else if (ipd_port < 48) 328 return 5; 329 else 330 cvmx_dprintf("cvmx_helper_get_interface_num: Illegal IPD " 331 "port number\n"); 332 333 return -1; 334 } 335 EXPORT_SYMBOL_GPL(cvmx_helper_get_interface_num); 336 337 /** 338 * Returns the interface index number for an IPD/PKO port 339 * number. 340 * 341 * @ipd_port: IPD/PKO port number 342 * 343 * Returns Interface index number 344 */ 345 int cvmx_helper_get_interface_index_num(int ipd_port) 346 { 347 if (ipd_port < 32) 348 return ipd_port & 15; 349 else if (ipd_port < 36) 350 return ipd_port & 3; 351 else if (ipd_port < 40) 352 return ipd_port & 3; 353 else if (ipd_port < 44) 354 return ipd_port & 3; 355 else if (ipd_port < 48) 356 return ipd_port & 3; 357 else 358 cvmx_dprintf("cvmx_helper_get_interface_index_num: " 359 "Illegal IPD port number\n"); 360 361 return -1; 362 } 363 EXPORT_SYMBOL_GPL(cvmx_helper_get_interface_index_num); 364