diff options
author | David Daney <david.daney@cavium.com> | 2012-07-05 08:49:49 -0400 |
---|---|---|
committer | Ralf Baechle <ralf@linux-mips.org> | 2012-07-23 08:54:51 -0400 |
commit | 05b8c8c1288c078f8920f5894854086f0e10f095 (patch) | |
tree | 24edd4ee12396371430f42605770640e481271f7 /arch | |
parent | 28a33cbc24e4256c143dce96c7d93bf423229f92 (diff) |
MIPS: OCTEON: Remove some unused files.
These FPA related files are not used anywhere in the kernel. Remove
them.
Signed-off-by: David Daney <david.daney@cavium.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/3892/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
Diffstat (limited to 'arch')
-rw-r--r-- | arch/mips/cavium-octeon/executive/cvmx-fpa.c | 183 | ||||
-rw-r--r-- | arch/mips/cavium-octeon/executive/cvmx-helper-fpa.c | 243 | ||||
-rw-r--r-- | arch/mips/include/asm/octeon/cvmx-helper-fpa.h | 64 | ||||
-rw-r--r-- | arch/mips/include/asm/octeon/cvmx-helper.h | 2 |
4 files changed, 0 insertions, 492 deletions
diff --git a/arch/mips/cavium-octeon/executive/cvmx-fpa.c b/arch/mips/cavium-octeon/executive/cvmx-fpa.c deleted file mode 100644 index ad44b8bd805..00000000000 --- a/arch/mips/cavium-octeon/executive/cvmx-fpa.c +++ /dev/null | |||
@@ -1,183 +0,0 @@ | |||
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 | * @file | ||
30 | * | ||
31 | * Support library for the hardware Free Pool Allocator. | ||
32 | * | ||
33 | * | ||
34 | */ | ||
35 | |||
36 | #include "cvmx-config.h" | ||
37 | #include "cvmx.h" | ||
38 | #include "cvmx-fpa.h" | ||
39 | #include "cvmx-ipd.h" | ||
40 | |||
41 | /** | ||
42 | * Current state of all the pools. Use access functions | ||
43 | * instead of using it directly. | ||
44 | */ | ||
45 | CVMX_SHARED cvmx_fpa_pool_info_t cvmx_fpa_pool_info[CVMX_FPA_NUM_POOLS]; | ||
46 | |||
47 | /** | ||
48 | * Setup a FPA pool to control a new block of memory. The | ||
49 | * buffer pointer must be a physical address. | ||
50 | * | ||
51 | * @pool: Pool to initialize | ||
52 | * 0 <= pool < 8 | ||
53 | * @name: Constant character string to name this pool. | ||
54 | * String is not copied. | ||
55 | * @buffer: Pointer to the block of memory to use. This must be | ||
56 | * accessible by all processors and external hardware. | ||
57 | * @block_size: Size for each block controlled by the FPA | ||
58 | * @num_blocks: Number of blocks | ||
59 | * | ||
60 | * Returns 0 on Success, | ||
61 | * -1 on failure | ||
62 | */ | ||
63 | int cvmx_fpa_setup_pool(uint64_t pool, const char *name, void *buffer, | ||
64 | uint64_t block_size, uint64_t num_blocks) | ||
65 | { | ||
66 | char *ptr; | ||
67 | if (!buffer) { | ||
68 | cvmx_dprintf | ||
69 | ("ERROR: cvmx_fpa_setup_pool: NULL buffer pointer!\n"); | ||
70 | return -1; | ||
71 | } | ||
72 | if (pool >= CVMX_FPA_NUM_POOLS) { | ||
73 | cvmx_dprintf("ERROR: cvmx_fpa_setup_pool: Illegal pool!\n"); | ||
74 | return -1; | ||
75 | } | ||
76 | |||
77 | if (block_size < CVMX_FPA_MIN_BLOCK_SIZE) { | ||
78 | cvmx_dprintf | ||
79 | ("ERROR: cvmx_fpa_setup_pool: Block size too small.\n"); | ||
80 | return -1; | ||
81 | } | ||
82 | |||
83 | if (((unsigned long)buffer & (CVMX_FPA_ALIGNMENT - 1)) != 0) { | ||
84 | cvmx_dprintf | ||
85 | ("ERROR: cvmx_fpa_setup_pool: Buffer not aligned properly.\n"); | ||
86 | return -1; | ||
87 | } | ||
88 | |||
89 | cvmx_fpa_pool_info[pool].name = name; | ||
90 | cvmx_fpa_pool_info[pool].size = block_size; | ||
91 | cvmx_fpa_pool_info[pool].starting_element_count = num_blocks; | ||
92 | cvmx_fpa_pool_info[pool].base = buffer; | ||
93 | |||
94 | ptr = (char *)buffer; | ||
95 | while (num_blocks--) { | ||
96 | cvmx_fpa_free(ptr, pool, 0); | ||
97 | ptr += block_size; | ||
98 | } | ||
99 | return 0; | ||
100 | } | ||
101 | |||
102 | /** | ||
103 | * Shutdown a Memory pool and validate that it had all of | ||
104 | * the buffers originally placed in it. | ||
105 | * | ||
106 | * @pool: Pool to shutdown | ||
107 | * Returns Zero on success | ||
108 | * - Positive is count of missing buffers | ||
109 | * - Negative is too many buffers or corrupted pointers | ||
110 | */ | ||
111 | uint64_t cvmx_fpa_shutdown_pool(uint64_t pool) | ||
112 | { | ||
113 | uint64_t errors = 0; | ||
114 | uint64_t count = 0; | ||
115 | uint64_t base = cvmx_ptr_to_phys(cvmx_fpa_pool_info[pool].base); | ||
116 | uint64_t finish = | ||
117 | base + | ||
118 | cvmx_fpa_pool_info[pool].size * | ||
119 | cvmx_fpa_pool_info[pool].starting_element_count; | ||
120 | void *ptr; | ||
121 | uint64_t address; | ||
122 | |||
123 | count = 0; | ||
124 | do { | ||
125 | ptr = cvmx_fpa_alloc(pool); | ||
126 | if (ptr) | ||
127 | address = cvmx_ptr_to_phys(ptr); | ||
128 | else | ||
129 | address = 0; | ||
130 | if (address) { | ||
131 | if ((address >= base) && (address < finish) && | ||
132 | (((address - | ||
133 | base) % cvmx_fpa_pool_info[pool].size) == 0)) { | ||
134 | count++; | ||
135 | } else { | ||
136 | cvmx_dprintf | ||
137 | ("ERROR: cvmx_fpa_shutdown_pool: Illegal address 0x%llx in pool %s(%d)\n", | ||
138 | (unsigned long long)address, | ||
139 | cvmx_fpa_pool_info[pool].name, (int)pool); | ||
140 | errors++; | ||
141 | } | ||
142 | } | ||
143 | } while (address); | ||
144 | |||
145 | #ifdef CVMX_ENABLE_PKO_FUNCTIONS | ||
146 | if (pool == 0) | ||
147 | cvmx_ipd_free_ptr(); | ||
148 | #endif | ||
149 | |||
150 | if (errors) { | ||
151 | cvmx_dprintf | ||
152 | ("ERROR: cvmx_fpa_shutdown_pool: Pool %s(%d) started at 0x%llx, ended at 0x%llx, with a step of 0x%llx\n", | ||
153 | cvmx_fpa_pool_info[pool].name, (int)pool, | ||
154 | (unsigned long long)base, (unsigned long long)finish, | ||
155 | (unsigned long long)cvmx_fpa_pool_info[pool].size); | ||
156 | return -errors; | ||
157 | } else | ||
158 | return 0; | ||
159 | } | ||
160 | |||
161 | uint64_t cvmx_fpa_get_block_size(uint64_t pool) | ||
162 | { | ||
163 | switch (pool) { | ||
164 | case 0: | ||
165 | return CVMX_FPA_POOL_0_SIZE; | ||
166 | case 1: | ||
167 | return CVMX_FPA_POOL_1_SIZE; | ||
168 | case 2: | ||
169 | return CVMX_FPA_POOL_2_SIZE; | ||
170 | case 3: | ||
171 | return CVMX_FPA_POOL_3_SIZE; | ||
172 | case 4: | ||
173 | return CVMX_FPA_POOL_4_SIZE; | ||
174 | case 5: | ||
175 | return CVMX_FPA_POOL_5_SIZE; | ||
176 | case 6: | ||
177 | return CVMX_FPA_POOL_6_SIZE; | ||
178 | case 7: | ||
179 | return CVMX_FPA_POOL_7_SIZE; | ||
180 | default: | ||
181 | return 0; | ||
182 | } | ||
183 | } | ||
diff --git a/arch/mips/cavium-octeon/executive/cvmx-helper-fpa.c b/arch/mips/cavium-octeon/executive/cvmx-helper-fpa.c deleted file mode 100644 index c239e5f4ab9..00000000000 --- a/arch/mips/cavium-octeon/executive/cvmx-helper-fpa.c +++ /dev/null | |||
@@ -1,243 +0,0 @@ | |||
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 | * @file | ||
30 | * | ||
31 | * Helper functions for FPA setup. | ||
32 | * | ||
33 | */ | ||
34 | #include "executive-config.h" | ||
35 | #include "cvmx-config.h" | ||
36 | #include "cvmx.h" | ||
37 | #include "cvmx-bootmem.h" | ||
38 | #include "cvmx-fpa.h" | ||
39 | #include "cvmx-helper-fpa.h" | ||
40 | |||
41 | /** | ||
42 | * Allocate memory for and initialize a single FPA pool. | ||
43 | * | ||
44 | * @pool: Pool to initialize | ||
45 | * @buffer_size: Size of buffers to allocate in bytes | ||
46 | * @buffers: Number of buffers to put in the pool. Zero is allowed | ||
47 | * @name: String name of the pool for debugging purposes | ||
48 | * Returns Zero on success, non-zero on failure | ||
49 | */ | ||
50 | static int __cvmx_helper_initialize_fpa_pool(int pool, uint64_t buffer_size, | ||
51 | uint64_t buffers, const char *name) | ||
52 | { | ||
53 | uint64_t current_num; | ||
54 | void *memory; | ||
55 | uint64_t align = CVMX_CACHE_LINE_SIZE; | ||
56 | |||
57 | /* | ||
58 | * Align the allocation so that power of 2 size buffers are | ||
59 | * naturally aligned. | ||
60 | */ | ||
61 | while (align < buffer_size) | ||
62 | align = align << 1; | ||
63 | |||
64 | if (buffers == 0) | ||
65 | return 0; | ||
66 | |||
67 | current_num = cvmx_read_csr(CVMX_FPA_QUEX_AVAILABLE(pool)); | ||
68 | if (current_num) { | ||
69 | cvmx_dprintf("Fpa pool %d(%s) already has %llu buffers. " | ||
70 | "Skipping setup.\n", | ||
71 | pool, name, (unsigned long long)current_num); | ||
72 | return 0; | ||
73 | } | ||
74 | |||
75 | memory = cvmx_bootmem_alloc(buffer_size * buffers, align); | ||
76 | if (memory == NULL) { | ||
77 | cvmx_dprintf("Out of memory initializing fpa pool %d(%s).\n", | ||
78 | pool, name); | ||
79 | return -1; | ||
80 | } | ||
81 | cvmx_fpa_setup_pool(pool, name, memory, buffer_size, buffers); | ||
82 | return 0; | ||
83 | } | ||
84 | |||
85 | /** | ||
86 | * Allocate memory and initialize the FPA pools using memory | ||
87 | * from cvmx-bootmem. Specifying zero for the number of | ||
88 | * buffers will cause that FPA pool to not be setup. This is | ||
89 | * useful if you aren't using some of the hardware and want | ||
90 | * to save memory. Use cvmx_helper_initialize_fpa instead of | ||
91 | * this function directly. | ||
92 | * | ||
93 | * @pip_pool: Should always be CVMX_FPA_PACKET_POOL | ||
94 | * @pip_size: Should always be CVMX_FPA_PACKET_POOL_SIZE | ||
95 | * @pip_buffers: | ||
96 | * Number of packet buffers. | ||
97 | * @wqe_pool: Should always be CVMX_FPA_WQE_POOL | ||
98 | * @wqe_size: Should always be CVMX_FPA_WQE_POOL_SIZE | ||
99 | * @wqe_entries: | ||
100 | * Number of work queue entries | ||
101 | * @pko_pool: Should always be CVMX_FPA_OUTPUT_BUFFER_POOL | ||
102 | * @pko_size: Should always be CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE | ||
103 | * @pko_buffers: | ||
104 | * PKO Command buffers. You should at minimum have two per | ||
105 | * each PKO queue. | ||
106 | * @tim_pool: Should always be CVMX_FPA_TIMER_POOL | ||
107 | * @tim_size: Should always be CVMX_FPA_TIMER_POOL_SIZE | ||
108 | * @tim_buffers: | ||
109 | * TIM ring buffer command queues. At least two per timer bucket | ||
110 | * is recommened. | ||
111 | * @dfa_pool: Should always be CVMX_FPA_DFA_POOL | ||
112 | * @dfa_size: Should always be CVMX_FPA_DFA_POOL_SIZE | ||
113 | * @dfa_buffers: | ||
114 | * DFA command buffer. A relatively small (32 for example) | ||
115 | * number should work. | ||
116 | * Returns Zero on success, non-zero if out of memory | ||
117 | */ | ||
118 | static int __cvmx_helper_initialize_fpa(int pip_pool, int pip_size, | ||
119 | int pip_buffers, int wqe_pool, | ||
120 | int wqe_size, int wqe_entries, | ||
121 | int pko_pool, int pko_size, | ||
122 | int pko_buffers, int tim_pool, | ||
123 | int tim_size, int tim_buffers, | ||
124 | int dfa_pool, int dfa_size, | ||
125 | int dfa_buffers) | ||
126 | { | ||
127 | int status; | ||
128 | |||
129 | cvmx_fpa_enable(); | ||
130 | |||
131 | if ((pip_buffers > 0) && (pip_buffers <= 64)) | ||
132 | cvmx_dprintf | ||
133 | ("Warning: %d packet buffers may not be enough for hardware" | ||
134 | " prefetch. 65 or more is recommended.\n", pip_buffers); | ||
135 | |||
136 | if (pip_pool >= 0) { | ||
137 | status = | ||
138 | __cvmx_helper_initialize_fpa_pool(pip_pool, pip_size, | ||
139 | pip_buffers, | ||
140 | "Packet Buffers"); | ||
141 | if (status) | ||
142 | return status; | ||
143 | } | ||
144 | |||
145 | if (wqe_pool >= 0) { | ||
146 | status = | ||
147 | __cvmx_helper_initialize_fpa_pool(wqe_pool, wqe_size, | ||
148 | wqe_entries, | ||
149 | "Work Queue Entries"); | ||
150 | if (status) | ||
151 | return status; | ||
152 | } | ||
153 | |||
154 | if (pko_pool >= 0) { | ||
155 | status = | ||
156 | __cvmx_helper_initialize_fpa_pool(pko_pool, pko_size, | ||
157 | pko_buffers, | ||
158 | "PKO Command Buffers"); | ||
159 | if (status) | ||
160 | return status; | ||
161 | } | ||
162 | |||
163 | if (tim_pool >= 0) { | ||
164 | status = | ||
165 | __cvmx_helper_initialize_fpa_pool(tim_pool, tim_size, | ||
166 | tim_buffers, | ||
167 | "TIM Command Buffers"); | ||
168 | if (status) | ||
169 | return status; | ||
170 | } | ||
171 | |||
172 | if (dfa_pool >= 0) { | ||
173 | status = | ||
174 | __cvmx_helper_initialize_fpa_pool(dfa_pool, dfa_size, | ||
175 | dfa_buffers, | ||
176 | "DFA Command Buffers"); | ||
177 | if (status) | ||
178 | return status; | ||
179 | } | ||
180 | |||
181 | return 0; | ||
182 | } | ||
183 | |||
184 | /** | ||
185 | * Allocate memory and initialize the FPA pools using memory | ||
186 | * from cvmx-bootmem. Sizes of each element in the pools is | ||
187 | * controlled by the cvmx-config.h header file. Specifying | ||
188 | * zero for any parameter will cause that FPA pool to not be | ||
189 | * setup. This is useful if you aren't using some of the | ||
190 | * hardware and want to save memory. | ||
191 | * | ||
192 | * @packet_buffers: | ||
193 | * Number of packet buffers to allocate | ||
194 | * @work_queue_entries: | ||
195 | * Number of work queue entries | ||
196 | * @pko_buffers: | ||
197 | * PKO Command buffers. You should at minimum have two per | ||
198 | * each PKO queue. | ||
199 | * @tim_buffers: | ||
200 | * TIM ring buffer command queues. At least two per timer bucket | ||
201 | * is recommened. | ||
202 | * @dfa_buffers: | ||
203 | * DFA command buffer. A relatively small (32 for example) | ||
204 | * number should work. | ||
205 | * Returns Zero on success, non-zero if out of memory | ||
206 | */ | ||
207 | int cvmx_helper_initialize_fpa(int packet_buffers, int work_queue_entries, | ||
208 | int pko_buffers, int tim_buffers, | ||
209 | int dfa_buffers) | ||
210 | { | ||
211 | #ifndef CVMX_FPA_PACKET_POOL | ||
212 | #define CVMX_FPA_PACKET_POOL -1 | ||
213 | #define CVMX_FPA_PACKET_POOL_SIZE 0 | ||
214 | #endif | ||
215 | #ifndef CVMX_FPA_WQE_POOL | ||
216 | #define CVMX_FPA_WQE_POOL -1 | ||
217 | #define CVMX_FPA_WQE_POOL_SIZE 0 | ||
218 | #endif | ||
219 | #ifndef CVMX_FPA_OUTPUT_BUFFER_POOL | ||
220 | #define CVMX_FPA_OUTPUT_BUFFER_POOL -1 | ||
221 | #define CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE 0 | ||
222 | #endif | ||
223 | #ifndef CVMX_FPA_TIMER_POOL | ||
224 | #define CVMX_FPA_TIMER_POOL -1 | ||
225 | #define CVMX_FPA_TIMER_POOL_SIZE 0 | ||
226 | #endif | ||
227 | #ifndef CVMX_FPA_DFA_POOL | ||
228 | #define CVMX_FPA_DFA_POOL -1 | ||
229 | #define CVMX_FPA_DFA_POOL_SIZE 0 | ||
230 | #endif | ||
231 | return __cvmx_helper_initialize_fpa(CVMX_FPA_PACKET_POOL, | ||
232 | CVMX_FPA_PACKET_POOL_SIZE, | ||
233 | packet_buffers, CVMX_FPA_WQE_POOL, | ||
234 | CVMX_FPA_WQE_POOL_SIZE, | ||
235 | work_queue_entries, | ||
236 | CVMX_FPA_OUTPUT_BUFFER_POOL, | ||
237 | CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, | ||
238 | pko_buffers, CVMX_FPA_TIMER_POOL, | ||
239 | CVMX_FPA_TIMER_POOL_SIZE, | ||
240 | tim_buffers, CVMX_FPA_DFA_POOL, | ||
241 | CVMX_FPA_DFA_POOL_SIZE, | ||
242 | dfa_buffers); | ||
243 | } | ||
diff --git a/arch/mips/include/asm/octeon/cvmx-helper-fpa.h b/arch/mips/include/asm/octeon/cvmx-helper-fpa.h deleted file mode 100644 index 5ff8c93198d..00000000000 --- a/arch/mips/include/asm/octeon/cvmx-helper-fpa.h +++ /dev/null | |||
@@ -1,64 +0,0 @@ | |||
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 | * @file | ||
30 | * | ||
31 | * Helper functions for FPA setup. | ||
32 | * | ||
33 | */ | ||
34 | #ifndef __CVMX_HELPER_H_FPA__ | ||
35 | #define __CVMX_HELPER_H_FPA__ | ||
36 | |||
37 | /** | ||
38 | * Allocate memory and initialize the FPA pools using memory | ||
39 | * from cvmx-bootmem. Sizes of each element in the pools is | ||
40 | * controlled by the cvmx-config.h header file. Specifying | ||
41 | * zero for any parameter will cause that FPA pool to not be | ||
42 | * setup. This is useful if you aren't using some of the | ||
43 | * hardware and want to save memory. | ||
44 | * | ||
45 | * @packet_buffers: | ||
46 | * Number of packet buffers to allocate | ||
47 | * @work_queue_entries: | ||
48 | * Number of work queue entries | ||
49 | * @pko_buffers: | ||
50 | * PKO Command buffers. You should at minimum have two per | ||
51 | * each PKO queue. | ||
52 | * @tim_buffers: | ||
53 | * TIM ring buffer command queues. At least two per timer bucket | ||
54 | * is recommened. | ||
55 | * @dfa_buffers: | ||
56 | * DFA command buffer. A relatively small (32 for example) | ||
57 | * number should work. | ||
58 | * Returns Zero on success, non-zero if out of memory | ||
59 | */ | ||
60 | extern int cvmx_helper_initialize_fpa(int packet_buffers, | ||
61 | int work_queue_entries, int pko_buffers, | ||
62 | int tim_buffers, int dfa_buffers); | ||
63 | |||
64 | #endif /* __CVMX_HELPER_H__ */ | ||
diff --git a/arch/mips/include/asm/octeon/cvmx-helper.h b/arch/mips/include/asm/octeon/cvmx-helper.h index 3169cd79f2a..0ac6b9f412b 100644 --- a/arch/mips/include/asm/octeon/cvmx-helper.h +++ b/arch/mips/include/asm/octeon/cvmx-helper.h | |||
@@ -61,8 +61,6 @@ typedef union { | |||
61 | } s; | 61 | } s; |
62 | } cvmx_helper_link_info_t; | 62 | } cvmx_helper_link_info_t; |
63 | 63 | ||
64 | #include "cvmx-helper-fpa.h" | ||
65 | |||
66 | #include <asm/octeon/cvmx-helper-errata.h> | 64 | #include <asm/octeon/cvmx-helper-errata.h> |
67 | #include "cvmx-helper-loop.h" | 65 | #include "cvmx-helper-loop.h" |
68 | #include "cvmx-helper-npi.h" | 66 | #include "cvmx-helper-npi.h" |