release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/staging/octeon/ethernet-mem.c

   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  */
  45 static 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  */
  72 static 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  */
 102 static 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  */
 139 static 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
 161 int 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
 171 void 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 }