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} 178