LXR linux/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 <asm/octeon/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