root/drivers/staging/octeon/ethernet-mem.c

DEFINITIONS

1. cvm_oct_fill_hw_skbuff
2. cvm_oct_free_hw_skbuff
3. cvm_oct_fill_hw_memory
4. cvm_oct_free_hw_memory
5. cvm_oct_mem_fill_fpa
6. cvm_oct_mem_empty_fpa

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