// SPDX-License-Identifier: GPL-2.0
|
/*
|
* This file is based on code from OCTEON SDK by Cavium Networks.
|
*
|
* Copyright (c) 2003-2010 Cavium Networks
|
*/
|
|
#include <linux/kernel.h>
|
#include <linux/netdevice.h>
|
#include <linux/slab.h>
|
|
#include "octeon-ethernet.h"
|
#include "ethernet-mem.h"
|
#include "ethernet-defines.h"
|
|
/**
|
* cvm_oct_fill_hw_skbuff - fill the supplied hardware pool with skbuffs
|
* @pool: Pool to allocate an skbuff for
|
* @size: Size of the buffer needed for the pool
|
* @elements: Number of buffers to allocate
|
*
|
* Returns the actual number of buffers allocated.
|
*/
|
static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
|
{
|
int freed = elements;
|
|
while (freed) {
|
struct sk_buff *skb = dev_alloc_skb(size + 256);
|
|
if (unlikely(!skb))
|
break;
|
skb_reserve(skb, 256 - (((unsigned long)skb->data) & 0x7f));
|
*(struct sk_buff **)(skb->data - sizeof(void *)) = skb;
|
cvmx_fpa_free(skb->data, pool, size / 128);
|
freed--;
|
}
|
return elements - freed;
|
}
|
|
/**
|
* cvm_oct_free_hw_skbuff- free hardware pool skbuffs
|
* @pool: Pool to allocate an skbuff for
|
* @size: Size of the buffer needed for the pool
|
* @elements: Number of buffers to allocate
|
*/
|
static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
|
{
|
char *memory;
|
|
do {
|
memory = cvmx_fpa_alloc(pool);
|
if (memory) {
|
struct sk_buff *skb =
|
*(struct sk_buff **)(memory - sizeof(void *));
|
elements--;
|
dev_kfree_skb(skb);
|
}
|
} while (memory);
|
|
if (elements < 0)
|
pr_warn("Freeing of pool %u had too many skbuffs (%d)\n",
|
pool, elements);
|
else if (elements > 0)
|
pr_warn("Freeing of pool %u is missing %d skbuffs\n",
|
pool, elements);
|
}
|
|
/**
|
* cvm_oct_fill_hw_memory - fill a hardware pool with memory.
|
* @pool: Pool to populate
|
* @size: Size of each buffer in the pool
|
* @elements: Number of buffers to allocate
|
*
|
* Returns the actual number of buffers allocated.
|
*/
|
static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
|
{
|
char *memory;
|
char *fpa;
|
int freed = elements;
|
|
while (freed) {
|
/*
|
* FPA memory must be 128 byte aligned. Since we are
|
* aligning we need to save the original pointer so we
|
* can feed it to kfree when the memory is returned to
|
* the kernel.
|
*
|
* We allocate an extra 256 bytes to allow for
|
* alignment and space for the original pointer saved
|
* just before the block.
|
*/
|
memory = kmalloc(size + 256, GFP_ATOMIC);
|
if (unlikely(!memory)) {
|
pr_warn("Unable to allocate %u bytes for FPA pool %d\n",
|
elements * size, pool);
|
break;
|
}
|
fpa = (char *)(((unsigned long)memory + 256) & ~0x7fUL);
|
*((char **)fpa - 1) = memory;
|
cvmx_fpa_free(fpa, pool, 0);
|
freed--;
|
}
|
return elements - freed;
|
}
|
|
/**
|
* cvm_oct_free_hw_memory - Free memory allocated by cvm_oct_fill_hw_memory
|
* @pool: FPA pool to free
|
* @size: Size of each buffer in the pool
|
* @elements: Number of buffers that should be in the pool
|
*/
|
static void cvm_oct_free_hw_memory(int pool, int size, int elements)
|
{
|
char *memory;
|
char *fpa;
|
|
do {
|
fpa = cvmx_fpa_alloc(pool);
|
if (fpa) {
|
elements--;
|
fpa = (char *)phys_to_virt(cvmx_ptr_to_phys(fpa));
|
memory = *((char **)fpa - 1);
|
kfree(memory);
|
}
|
} while (fpa);
|
|
if (elements < 0)
|
pr_warn("Freeing of pool %u had too many buffers (%d)\n",
|
pool, elements);
|
else if (elements > 0)
|
pr_warn("Warning: Freeing of pool %u is missing %d buffers\n",
|
pool, elements);
|
}
|
|
int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
|
{
|
int freed;
|
|
if (pool == CVMX_FPA_PACKET_POOL)
|
freed = cvm_oct_fill_hw_skbuff(pool, size, elements);
|
else
|
freed = cvm_oct_fill_hw_memory(pool, size, elements);
|
return freed;
|
}
|
|
void cvm_oct_mem_empty_fpa(int pool, int size, int elements)
|
{
|
if (pool == CVMX_FPA_PACKET_POOL)
|
cvm_oct_free_hw_skbuff(pool, size, elements);
|
else
|
cvm_oct_free_hw_memory(pool, size, elements);
|
}
|
