1 /***********************license start***************
2 * Copyright (c) 2003-2010 Cavium Inc. ([email protected]). All rights
3 * reserved.
4 *
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
17
18 * * Neither the name of Cavium Inc. nor the names of
19 * its contributors may be used to endorse or promote products
20 * derived from this software without specific prior written
21 * permission.
22
23 * This Software, including technical data, may be subject to U.S. export control
24 * laws, including the U.S. Export Administration Act and its associated
25 * regulations, and may be subject to export or import regulations in other
26 * countries.
27
28 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
29 * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR
30 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
31 * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR
32 * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM
33 * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE,
34 * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF
35 * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
36 * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR
37 * PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
38 ***********************license end**************************************/
39
40
41
42
43
44
45
46 /**
47 * @file
48 *
49 * Small helper utilities.
50 *
51 * <hr>$Revision: 70030 $<hr>
52 */
53 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
54 #include <linux/module.h>
55 #include <linux/slab.h> \
56
57 #include <asm/octeon/cvmx.h>
58 #include <asm/octeon/cvmx-config.h>
59 #include <asm/octeon/cvmx-pip.h>
60 #include <asm/octeon/cvmx-ipd.h>
61 #include <asm/octeon/cvmx-helper.h>
62 #include <asm/octeon/cvmx-gmxx-defs.h>
63 #include <asm/octeon/cvmx-pko-defs.h>
64 #include <asm/octeon/cvmx-pko.h>
65 #include <asm/octeon/cvmx-sli-defs.h>
66 #include <asm/octeon/cvmx-pexp-defs.h>
67 #include <asm/octeon/cvmx-helper-cfg.h>
68 #else
69 #if !defined(__FreeBSD__) || !defined(_KERNEL)
70 #include "executive-config.h"
71 #include "cvmx-config.h"
72 #endif
73 #include "cvmx.h"
74 #include "cvmx-bootmem.h"
75 #include "cvmx-fpa.h"
76 #include "cvmx-pip.h"
77 #include "cvmx-pko.h"
78 #include "cvmx-ilk.h"
79 #include "cvmx-ipd.h"
80 #include "cvmx-gmx.h"
81 #include "cvmx-spi.h"
82 #include "cvmx-sysinfo.h"
83 #include "cvmx-helper.h"
84 #include "cvmx-helper-util.h"
85 #include "cvmx-version.h"
86 #include "cvmx-helper-ilk.h"
87 #include "cvmx-helper-cfg.h"
88 #endif
89
90 #ifdef CVMX_ENABLE_HELPER_FUNCTIONS
91
92 struct cvmx_iface {
93 int cvif_ipd_nports;
94 int cvif_has_fcs; /* PKO fcs for this interface. */
95 enum cvmx_pko_padding cvif_padding;
96 cvmx_helper_link_info_t *cvif_ipd_port_link_info;
97 };
98
99 /*
100 * This has to be static as u-boot expects to probe an interface and
101 * gets the number of its ports.
102 */
103 static CVMX_SHARED struct cvmx_iface cvmx_interfaces[CVMX_HELPER_MAX_IFACE];
104
105 #ifndef CVMX_BUILD_FOR_LINUX_KERNEL
106 /**
107 * Get the version of the CVMX libraries.
108 *
109 * @return Version string. Note this buffer is allocated statically
110 * and will be shared by all callers.
111 */
cvmx_helper_get_version(void)112 const char *cvmx_helper_get_version(void)
113 {
114 return OCTEON_SDK_VERSION_STRING;
115 }
116 #endif
117
118 /**
119 * Convert a interface mode into a human readable string
120 *
121 * @param mode Mode to convert
122 *
123 * @return String
124 */
cvmx_helper_interface_mode_to_string(cvmx_helper_interface_mode_t mode)125 const char *cvmx_helper_interface_mode_to_string(cvmx_helper_interface_mode_t mode)
126 {
127 switch (mode)
128 {
129 case CVMX_HELPER_INTERFACE_MODE_DISABLED: return "DISABLED";
130 case CVMX_HELPER_INTERFACE_MODE_RGMII: return "RGMII";
131 case CVMX_HELPER_INTERFACE_MODE_GMII: return "GMII";
132 case CVMX_HELPER_INTERFACE_MODE_SPI: return "SPI";
133 case CVMX_HELPER_INTERFACE_MODE_PCIE: return "PCIE";
134 case CVMX_HELPER_INTERFACE_MODE_XAUI: return "XAUI";
135 case CVMX_HELPER_INTERFACE_MODE_RXAUI: return "RXAUI";
136 case CVMX_HELPER_INTERFACE_MODE_SGMII: return "SGMII";
137 case CVMX_HELPER_INTERFACE_MODE_PICMG: return "PICMG";
138 case CVMX_HELPER_INTERFACE_MODE_NPI: return "NPI";
139 case CVMX_HELPER_INTERFACE_MODE_LOOP: return "LOOP";
140 case CVMX_HELPER_INTERFACE_MODE_SRIO: return "SRIO";
141 case CVMX_HELPER_INTERFACE_MODE_ILK: return "ILK";
142 }
143 return "UNKNOWN";
144 }
145
146
147 /**
148 * Debug routine to dump the packet structure to the console
149 *
150 * @param work Work queue entry containing the packet to dump
151 * @return
152 */
cvmx_helper_dump_packet(cvmx_wqe_t * work)153 int cvmx_helper_dump_packet(cvmx_wqe_t *work)
154 {
155 uint64_t count;
156 uint64_t remaining_bytes;
157 cvmx_buf_ptr_t buffer_ptr;
158 uint64_t start_of_buffer;
159 uint8_t * data_address;
160 uint8_t * end_of_data;
161
162 cvmx_dprintf("Packet Length: %u\n", cvmx_wqe_get_len(work));
163 cvmx_dprintf(" Input Port: %u\n", cvmx_wqe_get_port(work));
164 cvmx_dprintf(" QoS: %u\n", cvmx_wqe_get_qos(work));
165 cvmx_dprintf(" Buffers: %u\n", work->word2.s.bufs);
166
167 if (work->word2.s.bufs == 0)
168 {
169 cvmx_ipd_wqe_fpa_queue_t wqe_pool;
170 wqe_pool.u64 = cvmx_read_csr(CVMX_IPD_WQE_FPA_QUEUE);
171 buffer_ptr.u64 = 0;
172 buffer_ptr.s.pool = wqe_pool.s.wqe_pool;
173 buffer_ptr.s.size = 128;
174 buffer_ptr.s.addr = cvmx_ptr_to_phys(work->packet_data);
175 if (cvmx_likely(!work->word2.s.not_IP))
176 {
177 cvmx_pip_ip_offset_t pip_ip_offset;
178 pip_ip_offset.u64 = cvmx_read_csr(CVMX_PIP_IP_OFFSET);
179 buffer_ptr.s.addr += (pip_ip_offset.s.offset<<3) - work->word2.s.ip_offset;
180 buffer_ptr.s.addr += (work->word2.s.is_v6^1)<<2;
181 }
182 else
183 {
184 /* WARNING: This code assume that the packet is not RAW. If it was,
185 we would use PIP_GBL_CFG[RAW_SHF] instead of
186 PIP_GBL_CFG[NIP_SHF] */
187 cvmx_pip_gbl_cfg_t pip_gbl_cfg;
188 pip_gbl_cfg.u64 = cvmx_read_csr(CVMX_PIP_GBL_CFG);
189 buffer_ptr.s.addr += pip_gbl_cfg.s.nip_shf;
190 }
191 }
192 else
193 buffer_ptr = work->packet_ptr;
194 remaining_bytes = cvmx_wqe_get_len(work);
195
196 while (remaining_bytes)
197 {
198 start_of_buffer = ((buffer_ptr.s.addr >> 7) - buffer_ptr.s.back) << 7;
199 cvmx_dprintf(" Buffer Start:%llx\n", (unsigned long long)start_of_buffer);
200 cvmx_dprintf(" Buffer I : %u\n", buffer_ptr.s.i);
201 cvmx_dprintf(" Buffer Back: %u\n", buffer_ptr.s.back);
202 cvmx_dprintf(" Buffer Pool: %u\n", buffer_ptr.s.pool);
203 cvmx_dprintf(" Buffer Data: %llx\n", (unsigned long long)buffer_ptr.s.addr);
204 cvmx_dprintf(" Buffer Size: %u\n", buffer_ptr.s.size);
205
206 cvmx_dprintf("\t\t");
207 data_address = (uint8_t *)cvmx_phys_to_ptr(buffer_ptr.s.addr);
208 end_of_data = data_address + buffer_ptr.s.size;
209 count = 0;
210 while (data_address < end_of_data)
211 {
212 if (remaining_bytes == 0)
213 break;
214 else
215 remaining_bytes--;
216 cvmx_dprintf("%02x", (unsigned int)*data_address);
217 data_address++;
218 if (remaining_bytes && (count == 7))
219 {
220 cvmx_dprintf("\n\t\t");
221 count = 0;
222 }
223 else
224 count++;
225 }
226 cvmx_dprintf("\n");
227
228 if (remaining_bytes)
229 buffer_ptr = *(cvmx_buf_ptr_t*)cvmx_phys_to_ptr(buffer_ptr.s.addr - 8);
230 }
231 return 0;
232 }
233
234
235 /**
236 * Setup Random Early Drop on a specific input queue
237 *
238 * @param queue Input queue to setup RED on (0-7)
239 * @param pass_thresh
240 * Packets will begin slowly dropping when there are less than
241 * this many packet buffers free in FPA 0.
242 * @param drop_thresh
243 * All incomming packets will be dropped when there are less
244 * than this many free packet buffers in FPA 0.
245 * @return Zero on success. Negative on failure
246 */
cvmx_helper_setup_red_queue(int queue,int pass_thresh,int drop_thresh)247 int cvmx_helper_setup_red_queue(int queue, int pass_thresh, int drop_thresh)
248 {
249 cvmx_ipd_qosx_red_marks_t red_marks;
250 cvmx_ipd_red_quex_param_t red_param;
251
252 /* Set RED to begin dropping packets when there are pass_thresh buffers
253 left. It will linearly drop more packets until reaching drop_thresh
254 buffers */
255 red_marks.u64 = 0;
256 red_marks.s.drop = drop_thresh;
257 red_marks.s.pass = pass_thresh;
258 cvmx_write_csr(CVMX_IPD_QOSX_RED_MARKS(queue), red_marks.u64);
259
260 /* Use the actual queue 0 counter, not the average */
261 red_param.u64 = 0;
262 red_param.s.prb_con = (255ul<<24) / (red_marks.s.pass - red_marks.s.drop);
263 red_param.s.avg_con = 1;
264 red_param.s.new_con = 255;
265 red_param.s.use_pcnt = 1;
266 cvmx_write_csr(CVMX_IPD_RED_QUEX_PARAM(queue), red_param.u64);
267 return 0;
268 }
269
270
271 /**
272 * Setup Random Early Drop to automatically begin dropping packets.
273 *
274 * @param pass_thresh
275 * Packets will begin slowly dropping when there are less than
276 * this many packet buffers free in FPA 0.
277 * @param drop_thresh
278 * All incomming packets will be dropped when there are less
279 * than this many free packet buffers in FPA 0.
280 * @return Zero on success. Negative on failure
281 */
cvmx_helper_setup_red(int pass_thresh,int drop_thresh)282 int cvmx_helper_setup_red(int pass_thresh, int drop_thresh)
283 {
284 int queue;
285 int interface;
286 int port;
287
288 /*
289 * Disable backpressure based on queued buffers. It needs SW support
290 */
291 if (octeon_has_feature(OCTEON_FEATURE_PKND))
292 {
293 int bpid;
294 for (interface = 0; interface < CVMX_HELPER_MAX_GMX; interface++)
295 {
296 int num_ports;
297
298 num_ports = cvmx_helper_ports_on_interface(interface);
299 for (port = 0; port < num_ports; port++) {
300 bpid = cvmx_helper_get_bpid(interface, port);
301 if (bpid == CVMX_INVALID_BPID)
302 cvmx_dprintf(
303 "setup_red: cvmx_helper_get_bpid(%d, %d) = %d\n",
304 interface, port, cvmx_helper_get_bpid(interface, port));
305 else
306 cvmx_write_csr(CVMX_IPD_BPIDX_MBUF_TH(bpid), 0);
307 }
308 }
309 }
310 else
311 {
312 cvmx_ipd_portx_bp_page_cnt_t page_cnt;
313
314 page_cnt.u64 = 0;
315 page_cnt.s.bp_enb = 0;
316 page_cnt.s.page_cnt = 100;
317 for (interface = 0; interface < CVMX_HELPER_MAX_GMX; interface++)
318 {
319 for (port = cvmx_helper_get_first_ipd_port(interface);
320 port < cvmx_helper_get_last_ipd_port(interface); port++)
321 cvmx_write_csr(CVMX_IPD_PORTX_BP_PAGE_CNT(port), page_cnt.u64);
322 }
323 }
324
325 for (queue = 0; queue < 8; queue++)
326 cvmx_helper_setup_red_queue(queue, pass_thresh, drop_thresh);
327
328 /*
329 * Shutoff the dropping based on the per port page count. SW isn't
330 * decrementing it right now
331 */
332 if (octeon_has_feature(OCTEON_FEATURE_PKND))
333 cvmx_write_csr(CVMX_IPD_ON_BP_DROP_PKTX(0), 0);
334 else
335 cvmx_write_csr(CVMX_IPD_BP_PRT_RED_END, 0);
336
337 #define IPD_RED_AVG_DLY 1000
338 #define IPD_RED_PRB_DLY 1000
339 /*
340 * Setting up avg_dly and prb_dly, enable bits
341 */
342 if (octeon_has_feature(OCTEON_FEATURE_PKND))
343 {
344 cvmx_ipd_red_delay_t red_delay;
345 cvmx_ipd_red_bpid_enablex_t red_bpid_enable;
346
347 red_delay.u64 = 0;
348 red_delay.s.avg_dly = IPD_RED_AVG_DLY;
349 red_delay.s.prb_dly = IPD_RED_PRB_DLY;
350 cvmx_write_csr(CVMX_IPD_RED_DELAY, red_delay.u64);
351
352 /*
353 * Only enable the gmx ports
354 */
355 red_bpid_enable.u64 = 0;
356 for (interface = 0; interface < CVMX_HELPER_MAX_GMX; interface++)
357 {
358 int num_ports = cvmx_helper_ports_on_interface(interface);
359 for (port = 0; port < num_ports; port++)
360 red_bpid_enable.u64 |= (((uint64_t) 1) <<
361 cvmx_helper_get_bpid(interface, port));
362 }
363 cvmx_write_csr(CVMX_IPD_RED_BPID_ENABLEX(0), red_bpid_enable.u64);
364 }
365 else
366 {
367 cvmx_ipd_red_port_enable_t red_port_enable;
368
369 red_port_enable.u64 = 0;
370 red_port_enable.s.prt_enb = 0xfffffffffull;
371 red_port_enable.s.avg_dly = IPD_RED_AVG_DLY;
372 red_port_enable.s.prb_dly = IPD_RED_PRB_DLY;
373 cvmx_write_csr(CVMX_IPD_RED_PORT_ENABLE, red_port_enable.u64);
374
375 /*
376 * Shutoff the dropping of packets based on RED for SRIO ports
377 */
378 if (octeon_has_feature(OCTEON_FEATURE_SRIO))
379 {
380 cvmx_ipd_red_port_enable2_t red_port_enable2;
381 red_port_enable2.u64 = 0;
382 red_port_enable2.s.prt_enb = 0xf0;
383 cvmx_write_csr(CVMX_IPD_RED_PORT_ENABLE2, red_port_enable2.u64);
384 }
385 }
386
387 return 0;
388 }
389 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
390 EXPORT_SYMBOL(cvmx_helper_setup_red);
391 #endif
392
393
394 /**
395 * @INTERNAL
396 * Setup the common GMX settings that determine the number of
397 * ports. These setting apply to almost all configurations of all
398 * chips.
399 *
400 * @param interface Interface to configure
401 * @param num_ports Number of ports on the interface
402 *
403 * @return Zero on success, negative on failure
404 */
__cvmx_helper_setup_gmx(int interface,int num_ports)405 int __cvmx_helper_setup_gmx(int interface, int num_ports)
406 {
407 cvmx_gmxx_tx_prts_t gmx_tx_prts;
408 cvmx_gmxx_rx_prts_t gmx_rx_prts;
409 cvmx_pko_reg_gmx_port_mode_t pko_mode;
410 cvmx_gmxx_txx_thresh_t gmx_tx_thresh;
411 int index;
412
413 /*
414 * Tell GMX the number of TX ports on this interface
415 */
416 gmx_tx_prts.u64 = cvmx_read_csr(CVMX_GMXX_TX_PRTS(interface));
417 gmx_tx_prts.s.prts = num_ports;
418 cvmx_write_csr(CVMX_GMXX_TX_PRTS(interface), gmx_tx_prts.u64);
419
420 /*
421 * Tell GMX the number of RX ports on this interface. This only applies
422 * to GMII and XAUI ports
423 */
424 if (cvmx_helper_interface_get_mode(interface) == CVMX_HELPER_INTERFACE_MODE_RGMII
425 || cvmx_helper_interface_get_mode(interface) == CVMX_HELPER_INTERFACE_MODE_SGMII
426 || cvmx_helper_interface_get_mode(interface) == CVMX_HELPER_INTERFACE_MODE_GMII
427 || cvmx_helper_interface_get_mode(interface) == CVMX_HELPER_INTERFACE_MODE_XAUI)
428 {
429 if (num_ports > 4)
430 {
431 cvmx_dprintf("__cvmx_helper_setup_gmx: Illegal num_ports\n");
432 return(-1);
433 }
434
435 gmx_rx_prts.u64 = cvmx_read_csr(CVMX_GMXX_RX_PRTS(interface));
436 gmx_rx_prts.s.prts = num_ports;
437 cvmx_write_csr(CVMX_GMXX_RX_PRTS(interface), gmx_rx_prts.u64);
438 }
439
440 /*
441 * Skip setting CVMX_PKO_REG_GMX_PORT_MODE on 30XX, 31XX, 50XX,
442 * and 68XX.
443 */
444 if (!OCTEON_IS_MODEL(OCTEON_CN30XX) && !OCTEON_IS_MODEL(OCTEON_CN31XX) &&
445 !OCTEON_IS_MODEL(OCTEON_CN50XX) && !OCTEON_IS_MODEL(OCTEON_CN68XX))
446 {
447 /* Tell PKO the number of ports on this interface */
448 pko_mode.u64 = cvmx_read_csr(CVMX_PKO_REG_GMX_PORT_MODE);
449 if (interface == 0)
450 {
451 if (num_ports == 1)
452 pko_mode.s.mode0 = 4;
453 else if (num_ports == 2)
454 pko_mode.s.mode0 = 3;
455 else if (num_ports <= 4)
456 pko_mode.s.mode0 = 2;
457 else if (num_ports <= 8)
458 pko_mode.s.mode0 = 1;
459 else
460 pko_mode.s.mode0 = 0;
461 }
462 else
463 {
464 if (num_ports == 1)
465 pko_mode.s.mode1 = 4;
466 else if (num_ports == 2)
467 pko_mode.s.mode1 = 3;
468 else if (num_ports <= 4)
469 pko_mode.s.mode1 = 2;
470 else if (num_ports <= 8)
471 pko_mode.s.mode1 = 1;
472 else
473 pko_mode.s.mode1 = 0;
474 }
475 cvmx_write_csr(CVMX_PKO_REG_GMX_PORT_MODE, pko_mode.u64);
476 }
477
478 /*
479 * Set GMX to buffer as much data as possible before starting
480 * transmit. This reduces the chances that we have a TX under run
481 * due to memory contention. Any packet that fits entirely in the
482 * GMX FIFO can never have an under run regardless of memory load.
483 */
484 gmx_tx_thresh.u64 = cvmx_read_csr(CVMX_GMXX_TXX_THRESH(0, interface));
485 if (OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX) ||
486 OCTEON_IS_MODEL(OCTEON_CN50XX))
487 /* These chips have a fixed max threshold of 0x40 */
488 gmx_tx_thresh.s.cnt = 0x40;
489 else
490 {
491 /* ccn - common cnt numberator */
492 int ccn = 0x100;
493
494 /* Choose the max value for the number of ports */
495 if (num_ports <= 1)
496 gmx_tx_thresh.s.cnt = ccn / 1;
497 else if (num_ports == 2)
498 gmx_tx_thresh.s.cnt = ccn / 2;
499 else
500 gmx_tx_thresh.s.cnt = ccn / 4;
501 }
502
503 /*
504 * SPI and XAUI can have lots of ports but the GMX hardware only ever has
505 * a max of 4
506 */
507 if (num_ports > 4)
508 num_ports = 4;
509 for (index = 0; index < num_ports; index++)
510 cvmx_write_csr(CVMX_GMXX_TXX_THRESH(index, interface),
511 gmx_tx_thresh.u64);
512
513 /*
514 * For o68, we need to setup the pipes
515 */
516 if (OCTEON_IS_MODEL(OCTEON_CN68XX) && interface < CVMX_HELPER_MAX_GMX)
517 {
518 cvmx_gmxx_txx_pipe_t config;
519
520 for (index = 0; index < num_ports; index++)
521 {
522 config.u64 = 0;
523
524 if (__cvmx_helper_cfg_pko_port_base(interface, index) >= 0)
525 {
526 config.u64 = cvmx_read_csr(
527 CVMX_GMXX_TXX_PIPE(index, interface));
528 config.s.nump = __cvmx_helper_cfg_pko_port_num(interface, index);
529 config.s.base = __cvmx_helper_cfg_pko_port_base(interface, index);
530 cvmx_write_csr(CVMX_GMXX_TXX_PIPE(index, interface),
531 config.u64);
532 }
533 }
534 }
535
536 return 0;
537 }
538
cvmx_helper_get_pko_port(int interface,int port)539 int cvmx_helper_get_pko_port(int interface, int port)
540 {
541 return cvmx_pko_get_base_pko_port(interface, port);
542 }
543 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
544 EXPORT_SYMBOL(cvmx_helper_get_pko_port);
545 #endif
546
cvmx_helper_get_ipd_port(int interface,int port)547 int cvmx_helper_get_ipd_port(int interface, int port)
548 {
549 if (octeon_has_feature(OCTEON_FEATURE_PKND))
550 {
551 if (interface >= 0 && interface <= 4)
552 {
553 cvmx_helper_interface_mode_t mode = cvmx_helper_interface_get_mode(interface);
554 if (mode == CVMX_HELPER_INTERFACE_MODE_XAUI || mode == CVMX_HELPER_INTERFACE_MODE_RXAUI)
555 return 0x840 + (interface * 0x100);
556 else
557 return 0x800 + (interface * 0x100) + (port * 16);
558 }
559 else if (interface == 5 || interface == 6)
560 return 0x400 + (interface - 5) * 0x100 + port;
561 else if (interface == 7)
562 return 0x100 + port;
563 else if (interface == 8)
564 return port;
565 else
566 return -1;
567 }
568 switch (interface)
569 {
570 case 0: return port;
571 case 1: return port + 16;
572 case 2: return port + 32;
573 case 3: return port + 36;
574 case 4: return port + 40;
575 case 5: return port + 42;
576 case 6: return port + 44;
577 }
578 return -1;
579 }
580 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
581 EXPORT_SYMBOL(cvmx_helper_get_ipd_port);
582 #endif
583
__cvmx_helper_get_num_ipd_ports(int interface)584 int __cvmx_helper_get_num_ipd_ports(int interface)
585 {
586 struct cvmx_iface *piface;
587
588 if (interface >= cvmx_helper_get_number_of_interfaces())
589 return -1;
590
591 piface = &cvmx_interfaces[interface];
592 return piface->cvif_ipd_nports;
593 }
594
__cvmx_helper_get_pko_padding(int interface)595 enum cvmx_pko_padding __cvmx_helper_get_pko_padding(int interface)
596 {
597 struct cvmx_iface *piface;
598
599 if (interface >= cvmx_helper_get_number_of_interfaces())
600 return CVMX_PKO_PADDING_NONE;
601
602 piface = &cvmx_interfaces[interface];
603 return piface->cvif_padding;
604 }
605
__cvmx_helper_init_interface(int interface,int num_ipd_ports,int has_fcs,enum cvmx_pko_padding pad)606 int __cvmx_helper_init_interface(int interface, int num_ipd_ports, int has_fcs, enum cvmx_pko_padding pad)
607 {
608 struct cvmx_iface *piface;
609 int sz;
610
611 if (interface >= cvmx_helper_get_number_of_interfaces())
612 return -1;
613
614 piface = &cvmx_interfaces[interface];
615 piface->cvif_ipd_nports = num_ipd_ports;
616 piface->cvif_padding = pad;
617
618 piface->cvif_has_fcs = has_fcs;
619
620 /*
621 * allocate the per-ipd_port link_info structure
622 */
623 sz = piface->cvif_ipd_nports * sizeof(cvmx_helper_link_info_t);
624 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
625 if (sz == 0)
626 sz = sizeof(cvmx_helper_link_info_t);
627 piface->cvif_ipd_port_link_info = (cvmx_helper_link_info_t *)kmalloc(sz, GFP_KERNEL);
628 if (ZERO_OR_NULL_PTR(piface->cvif_ipd_port_link_info))
629 panic("Cannot allocate memory in __cvmx_helper_init_interface.");
630 #else
631 piface->cvif_ipd_port_link_info = (cvmx_helper_link_info_t *)cvmx_bootmem_alloc(sz, sizeof(cvmx_helper_link_info_t));
632 #endif
633 if (!piface->cvif_ipd_port_link_info)
634 return -1;
635
636 /* Initialize 'em */ {
637 int i;
638 cvmx_helper_link_info_t *p;
639 p = piface->cvif_ipd_port_link_info;
640
641 for (i = 0; i < piface->cvif_ipd_nports; i++)
642 {
643 (*p).u64 = 0;
644 p++;
645 }
646 }
647
648 return 0;
649 }
650
651 /*
652 * Shut down the interfaces; free the resources.
653 * @INTERNAL
654 */
__cvmx_helper_shutdown_interfaces(void)655 void __cvmx_helper_shutdown_interfaces(void)
656 {
657 int i;
658 int nifaces; /* number of interfaces */
659 struct cvmx_iface *piface;
660
661 nifaces = cvmx_helper_get_number_of_interfaces();
662 for (i = 0; i < nifaces; i++)
663 {
664 piface = cvmx_interfaces + i;
665 if (piface->cvif_ipd_port_link_info)
666 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
667 kfree(piface->cvif_ipd_port_link_info);
668 #else
669 /*
670 * For SE apps, bootmem was meant to be allocated and never
671 * freed.
672 */
673 #endif
674 piface->cvif_ipd_port_link_info = 0;
675 }
676 }
677
__cvmx_helper_set_link_info(int interface,int port,cvmx_helper_link_info_t link_info)678 int __cvmx_helper_set_link_info(int interface, int port,
679 cvmx_helper_link_info_t link_info)
680 {
681 struct cvmx_iface *piface;
682
683 if (interface >= cvmx_helper_get_number_of_interfaces())
684 return -1;
685
686 piface = &cvmx_interfaces[interface];
687
688 if (piface->cvif_ipd_port_link_info)
689 {
690 piface->cvif_ipd_port_link_info[port] = link_info;
691 return 0;
692 }
693
694 return -1;
695 }
696
__cvmx_helper_get_link_info(int interface,int port)697 cvmx_helper_link_info_t __cvmx_helper_get_link_info(int interface, int port)
698 {
699 struct cvmx_iface *piface;
700 cvmx_helper_link_info_t err;
701
702 err.u64 = 0;
703
704 if (interface >= cvmx_helper_get_number_of_interfaces())
705 return err;
706 piface = &cvmx_interfaces[interface];
707
708 if (piface->cvif_ipd_port_link_info)
709 return piface->cvif_ipd_port_link_info[port];
710
711 return err;
712 }
713
__cvmx_helper_get_has_fcs(int interface)714 int __cvmx_helper_get_has_fcs(int interface)
715 {
716 return cvmx_interfaces[interface].cvif_has_fcs;
717 }
718
cvmx_helper_get_pknd(int interface,int port)719 int cvmx_helper_get_pknd(int interface, int port)
720 {
721 if (octeon_has_feature(OCTEON_FEATURE_PKND))
722 return __cvmx_helper_cfg_pknd(interface, port);
723
724 return CVMX_INVALID_PKND;
725 }
726 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
727 EXPORT_SYMBOL(cvmx_helper_get_pknd);
728 #endif
729
cvmx_helper_get_bpid(int interface,int port)730 int cvmx_helper_get_bpid(int interface, int port)
731 {
732 if (octeon_has_feature(OCTEON_FEATURE_PKND))
733 return __cvmx_helper_cfg_bpid(interface, port);
734
735 return CVMX_INVALID_BPID;
736 }
737 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
738 EXPORT_SYMBOL(cvmx_helper_get_bpid);
739 #endif
740
741 /**
742 * Display interface statistics.
743 *
744 * @param port IPD/PKO port number
745 *
746 * @return none
747 */
cvmx_helper_show_stats(int port)748 void cvmx_helper_show_stats(int port)
749 {
750 cvmx_pip_port_status_t status;
751 cvmx_pko_port_status_t pko_status;
752
753 /* ILK stats */
754 if (octeon_has_feature(OCTEON_FEATURE_ILK))
755 __cvmx_helper_ilk_show_stats();
756
757 /* PIP stats */
758 cvmx_pip_get_port_status (port, 0, &status);
759 cvmx_dprintf ("port %d: the number of packets - ipd: %d\n", port, (int)status.packets);
760
761 /* PKO stats */
762 cvmx_pko_get_port_status (port, 0, &pko_status);
763 cvmx_dprintf ("port %d: the number of packets - pko: %d\n", port, (int)pko_status.packets);
764
765 /* TODO: other stats */
766 }
767 #endif /* CVMX_ENABLE_HELPER_FUNCTIONS */
768
769 /**
770 * Returns the interface number for an IPD/PKO port number.
771 *
772 * @param ipd_port IPD/PKO port number
773 *
774 * @return Interface number
775 */
cvmx_helper_get_interface_num(int ipd_port)776 int cvmx_helper_get_interface_num(int ipd_port)
777 {
778 if (octeon_has_feature(OCTEON_FEATURE_PKND))
779 {
780 if (ipd_port >= 0x800 && ipd_port < 0x900)
781 return 0;
782 else if (ipd_port >= 0x900 && ipd_port < 0xa00)
783 return 1;
784 else if (ipd_port >= 0xa00 && ipd_port < 0xb00)
785 return 2;
786 else if (ipd_port >= 0xb00 && ipd_port < 0xc00)
787 return 3;
788 else if (ipd_port >= 0xc00 && ipd_port < 0xd00)
789 return 4;
790 else if (ipd_port >= 0x400 && ipd_port < 0x500)
791 return 5;
792 else if (ipd_port >= 0x500 && ipd_port < 0x600)
793 return 6;
794 else if (ipd_port >= 0x100 && ipd_port < 0x120)
795 return 7;
796 else if (ipd_port < 8)
797 return 8;
798 } else {
799 if (ipd_port < 16)
800 return 0;
801 else if (ipd_port < 32)
802 return 1;
803 else if (ipd_port < 36)
804 return 2;
805 else if (ipd_port < 40)
806 return 3;
807 else if (ipd_port < 42)
808 return 4;
809 else if (ipd_port < 44)
810 return 5;
811 else if (ipd_port < 46)
812 return 6;
813 }
814 cvmx_dprintf("cvmx_helper_get_interface_num: Illegal IPD port number %d\n", ipd_port);
815 return -1;
816 }
817 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
818 EXPORT_SYMBOL(cvmx_helper_get_interface_num);
819 #endif
820
821
822 /**
823 * Returns the interface index number for an IPD/PKO port
824 * number.
825 *
826 * @param ipd_port IPD/PKO port number
827 *
828 * @return Interface index number
829 */
cvmx_helper_get_interface_index_num(int ipd_port)830 int cvmx_helper_get_interface_index_num(int ipd_port)
831 {
832 if (octeon_has_feature(OCTEON_FEATURE_PKND))
833 {
834 if (ipd_port >= 0x800 && ipd_port < 0xd00)
835 {
836 int port = ((ipd_port & 0xff) >> 6);
837 return ((port) ? (port - 1) : ((ipd_port & 0xff) >> 4));
838 }
839 else if (ipd_port >= 0x400 && ipd_port < 0x600)
840 return (ipd_port & 0xff);
841 else if (ipd_port >= 0x100 && ipd_port < 0x120)
842 return (ipd_port & 0xff);
843 else if (ipd_port < 8)
844 return ipd_port;
845 else
846 cvmx_dprintf("cvmx_helper_get_interface_index_num: Illegal IPD port number %d\n", ipd_port);
847 return -1;
848 }
849 if (ipd_port < 32)
850 return ipd_port & 15;
851 else if (ipd_port < 40)
852 return ipd_port & 3;
853 else if (ipd_port < 44)
854 return ipd_port & 1;
855 else if (ipd_port < 46)
856 return ipd_port & 1;
857 else
858 cvmx_dprintf("cvmx_helper_get_interface_index_num: Illegal IPD port number\n");
859
860 return -1;
861 }
862 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
863 EXPORT_SYMBOL(cvmx_helper_get_interface_index_num);
864 #endif
865