Loading...
1/*
2 * This file is based on code from OCTEON SDK by Cavium Networks.
3 *
4 * Copyright (c) 2003-2010 Cavium Networks
5 *
6 * This file is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, Version 2, as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/kernel.h>
12#include <linux/netdevice.h>
13#include <linux/slab.h>
14
15#include <asm/octeon/octeon.h>
16
17#include "ethernet-mem.h"
18#include "ethernet-defines.h"
19
20#include <asm/octeon/cvmx-fpa.h>
21
22/**
23 * cvm_oct_fill_hw_skbuff - fill the supplied hardware pool with skbuffs
24 * @pool: Pool to allocate an skbuff for
25 * @size: Size of the buffer needed for the pool
26 * @elements: Number of buffers to allocate
27 *
28 * Returns the actual number of buffers allocated.
29 */
30static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
31{
32 int freed = elements;
33
34 while (freed) {
35 struct sk_buff *skb = dev_alloc_skb(size + 256);
36
37 if (unlikely(!skb))
38 break;
39 skb_reserve(skb, 256 - (((unsigned long)skb->data) & 0x7f));
40 *(struct sk_buff **)(skb->data - sizeof(void *)) = skb;
41 cvmx_fpa_free(skb->data, pool, size / 128);
42 freed--;
43 }
44 return elements - freed;
45}
46
47/**
48 * cvm_oct_free_hw_skbuff- free hardware pool skbuffs
49 * @pool: Pool to allocate an skbuff for
50 * @size: Size of the buffer needed for the pool
51 * @elements: Number of buffers to allocate
52 */
53static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
54{
55 char *memory;
56
57 do {
58 memory = cvmx_fpa_alloc(pool);
59 if (memory) {
60 struct sk_buff *skb =
61 *(struct sk_buff **)(memory - sizeof(void *));
62 elements--;
63 dev_kfree_skb(skb);
64 }
65 } while (memory);
66
67 if (elements < 0)
68 pr_warn("Freeing of pool %u had too many skbuffs (%d)\n",
69 pool, elements);
70 else if (elements > 0)
71 pr_warn("Freeing of pool %u is missing %d skbuffs\n",
72 pool, elements);
73}
74
75/**
76 * cvm_oct_fill_hw_memory - fill a hardware pool with memory.
77 * @pool: Pool to populate
78 * @size: Size of each buffer in the pool
79 * @elements: Number of buffers to allocate
80 *
81 * Returns the actual number of buffers allocated.
82 */
83static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
84{
85 char *memory;
86 char *fpa;
87 int freed = elements;
88
89 while (freed) {
90 /*
91 * FPA memory must be 128 byte aligned. Since we are
92 * aligning we need to save the original pointer so we
93 * can feed it to kfree when the memory is returned to
94 * the kernel.
95 *
96 * We allocate an extra 256 bytes to allow for
97 * alignment and space for the original pointer saved
98 * just before the block.
99 */
100 memory = kmalloc(size + 256, GFP_ATOMIC);
101 if (unlikely(!memory)) {
102 pr_warn("Unable to allocate %u bytes for FPA pool %d\n",
103 elements * size, pool);
104 break;
105 }
106 fpa = (char *)(((unsigned long)memory + 256) & ~0x7fUL);
107 *((char **)fpa - 1) = memory;
108 cvmx_fpa_free(fpa, pool, 0);
109 freed--;
110 }
111 return elements - freed;
112}
113
114/**
115 * cvm_oct_free_hw_memory - Free memory allocated by cvm_oct_fill_hw_memory
116 * @pool: FPA pool to free
117 * @size: Size of each buffer in the pool
118 * @elements: Number of buffers that should be in the pool
119 */
120static void cvm_oct_free_hw_memory(int pool, int size, int elements)
121{
122 char *memory;
123 char *fpa;
124
125 do {
126 fpa = cvmx_fpa_alloc(pool);
127 if (fpa) {
128 elements--;
129 fpa = (char *)phys_to_virt(cvmx_ptr_to_phys(fpa));
130 memory = *((char **)fpa - 1);
131 kfree(memory);
132 }
133 } while (fpa);
134
135 if (elements < 0)
136 pr_warn("Freeing of pool %u had too many buffers (%d)\n",
137 pool, elements);
138 else if (elements > 0)
139 pr_warn("Warning: Freeing of pool %u is missing %d buffers\n",
140 pool, elements);
141}
142
143int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
144{
145 int freed;
146
147 if (pool == CVMX_FPA_PACKET_POOL)
148 freed = cvm_oct_fill_hw_skbuff(pool, size, elements);
149 else
150 freed = cvm_oct_fill_hw_memory(pool, size, elements);
151 return freed;
152}
153
154void cvm_oct_mem_empty_fpa(int pool, int size, int elements)
155{
156 if (pool == CVMX_FPA_PACKET_POOL)
157 cvm_oct_free_hw_skbuff(pool, size, elements);
158 else
159 cvm_oct_free_hw_memory(pool, size, elements);
160}
1/**********************************************************************
2 * Author: Cavium Networks
3 *
4 * Contact: support@caviumnetworks.com
5 * This file is part of the OCTEON SDK
6 *
7 * Copyright (c) 2003-2010 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**********************************************************************/
27#include <linux/kernel.h>
28#include <linux/netdevice.h>
29#include <linux/slab.h>
30
31#include <asm/octeon/octeon.h>
32
33#include "ethernet-defines.h"
34
35#include "cvmx-fpa.h"
36
37/**
38 * cvm_oct_fill_hw_skbuff - fill the supplied hardware pool with skbuffs
39 * @pool: Pool to allocate an skbuff for
40 * @size: Size of the buffer needed for the pool
41 * @elements: Number of buffers to allocate
42 *
43 * Returns the actual number of buffers allocated.
44 */
45static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
46{
47 int freed = elements;
48 while (freed) {
49
50 struct sk_buff *skb = dev_alloc_skb(size + 256);
51 if (unlikely(skb == NULL)) {
52 pr_warning
53 ("Failed to allocate skb for hardware pool %d\n",
54 pool);
55 break;
56 }
57
58 skb_reserve(skb, 256 - (((unsigned long)skb->data) & 0x7f));
59 *(struct sk_buff **)(skb->data - sizeof(void *)) = skb;
60 cvmx_fpa_free(skb->data, pool, DONT_WRITEBACK(size / 128));
61 freed--;
62 }
63 return elements - freed;
64}
65
66/**
67 * cvm_oct_free_hw_skbuff- free hardware pool skbuffs
68 * @pool: Pool to allocate an skbuff for
69 * @size: Size of the buffer needed for the pool
70 * @elements: Number of buffers to allocate
71 */
72static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
73{
74 char *memory;
75
76 do {
77 memory = cvmx_fpa_alloc(pool);
78 if (memory) {
79 struct sk_buff *skb =
80 *(struct sk_buff **)(memory - sizeof(void *));
81 elements--;
82 dev_kfree_skb(skb);
83 }
84 } while (memory);
85
86 if (elements < 0)
87 pr_warning("Freeing of pool %u had too many skbuffs (%d)\n",
88 pool, elements);
89 else if (elements > 0)
90 pr_warning("Freeing of pool %u is missing %d skbuffs\n",
91 pool, elements);
92}
93
94/**
95 * cvm_oct_fill_hw_memory - fill a hardware pool with memory.
96 * @pool: Pool to populate
97 * @size: Size of each buffer in the pool
98 * @elements: Number of buffers to allocate
99 *
100 * Returns the actual number of buffers allocated.
101 */
102static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
103{
104 char *memory;
105 char *fpa;
106 int freed = elements;
107
108 while (freed) {
109 /*
110 * FPA memory must be 128 byte aligned. Since we are
111 * aligning we need to save the original pointer so we
112 * can feed it to kfree when the memory is returned to
113 * the kernel.
114 *
115 * We allocate an extra 256 bytes to allow for
116 * alignment and space for the original pointer saved
117 * just before the block.
118 */
119 memory = kmalloc(size + 256, GFP_ATOMIC);
120 if (unlikely(memory == NULL)) {
121 pr_warning("Unable to allocate %u bytes for FPA pool %d\n",
122 elements * size, pool);
123 break;
124 }
125 fpa = (char *)(((unsigned long)memory + 256) & ~0x7fUL);
126 *((char **)fpa - 1) = memory;
127 cvmx_fpa_free(fpa, pool, 0);
128 freed--;
129 }
130 return elements - freed;
131}
132
133/**
134 * cvm_oct_free_hw_memory - Free memory allocated by cvm_oct_fill_hw_memory
135 * @pool: FPA pool to free
136 * @size: Size of each buffer in the pool
137 * @elements: Number of buffers that should be in the pool
138 */
139static void cvm_oct_free_hw_memory(int pool, int size, int elements)
140{
141 char *memory;
142 char *fpa;
143 do {
144 fpa = cvmx_fpa_alloc(pool);
145 if (fpa) {
146 elements--;
147 fpa = (char *)phys_to_virt(cvmx_ptr_to_phys(fpa));
148 memory = *((char **)fpa - 1);
149 kfree(memory);
150 }
151 } while (fpa);
152
153 if (elements < 0)
154 pr_warning("Freeing of pool %u had too many buffers (%d)\n",
155 pool, elements);
156 else if (elements > 0)
157 pr_warning("Warning: Freeing of pool %u is missing %d buffers\n",
158 pool, elements);
159}
160
161int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
162{
163 int freed;
164 if (USE_SKBUFFS_IN_HW && pool == CVMX_FPA_PACKET_POOL)
165 freed = cvm_oct_fill_hw_skbuff(pool, size, elements);
166 else
167 freed = cvm_oct_fill_hw_memory(pool, size, elements);
168 return freed;
169}
170
171void cvm_oct_mem_empty_fpa(int pool, int size, int elements)
172{
173 if (USE_SKBUFFS_IN_HW && pool == CVMX_FPA_PACKET_POOL)
174 cvm_oct_free_hw_skbuff(pool, size, elements);
175 else
176 cvm_oct_free_hw_memory(pool, size, elements);
177}