summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: fb7f297)
raw | patch | inline | side by side (parent: fb7f297)
author | Wendy Liang <jliang@xilinx.com> | |
Fri, 12 Aug 2016 21:55:59 +0000 (14:55 -0700) | ||
committer | Wendy Liang <jliang@xilinx.com> | |
Thu, 13 Oct 2016 05:01:48 +0000 (22:01 -0700) |
Replace:
* env_allocate_memory with metal_allocate_memory
* env_free_memory with metal_free_memory
* env_allocate_memory with metal_allocate_memory
* env_free_memory with metal_free_memory
diff --git a/lib/common/sh_mem.c b/lib/common/sh_mem.c
index 8f5b8155cc06a7084c64d91d0c79a9d69ee86c2a..d87074697c77d04430de79b9fa98fc3de12de8c5 100644 (file)
--- a/lib/common/sh_mem.c
+++ b/lib/common/sh_mem.c
**************************************************************************/
#include <string.h>
#include "openamp/sh_mem.h"
+#include "metal/alloc.h"
/**
* sh_mem_create_pool
pool_size = sizeof(struct sh_mem_pool) + BITMAP_WORD_SIZE * bmp_size;
/* Create pool control block. */
- mem_pool = env_allocate_memory(pool_size);
+ mem_pool = metal_allocate_memory(pool_size);
if (mem_pool) {
/* Initialize pool parameters */
if (pool) {
metal_mutex_deinit(&pool->lock);
- env_free_memory(pool);
+ metal_free_memory(pool);
}
}
index 8b6270a85541df8eafaef3529e39c68d362592a7..2c9355d80c02994f2204662db66e5ea7d844e26f 100644 (file)
#include "openamp/open_amp.h"
#include "openamp/rpmsg_retarget.h"
+#include "metal/alloc.h"
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
int rpmsg_retarget_init(struct rpmsg_channel *rp_chnl, rpc_shutdown_cb cb)
{
/* Allocate memory for rpc control block */
- rpc_data =
- (struct _rpc_data *)env_allocate_memory(sizeof(struct _rpc_data));
+ rpc_data = (struct _rpc_data *)metal_allocate_memory(sizeof(struct _rpc_data));
/* Create a mutex for synchronization */
metal_mutex_init(&rpc_data->rpc_lock);
rpc_data->rpmsg_chnl = rp_chnl;
rpc_data->rp_ept = rpmsg_create_ept(rpc_data->rpmsg_chnl, rpc_cb,
RPMSG_NULL, PROXY_ENDPOINT);
- rpc_data->rpc = env_allocate_memory(RPC_BUFF_SIZE);
- rpc_data->rpc_response = env_allocate_memory(RPC_BUFF_SIZE);
+ rpc_data->rpc = metal_allocate_memory(RPC_BUFF_SIZE);
+ rpc_data->rpc_response = metal_allocate_memory(RPC_BUFF_SIZE);
rpc_data->shutdown_cb = cb;
return 0;
{
(void)rp_chnl;
- env_free_memory(rpc_data->rpc);
- env_free_memory(rpc_data->rpc_response);
+ metal_free_memory(rpc_data->rpc);
+ metal_free_memory(rpc_data->rpc_response);
metal_mutex_deinit(&rpc_data->rpc_lock);
rpmsg_destroy_ept(rpc_data->rp_ept);
- env_free_memory(rpc_data);
+ metal_free_memory(rpc_data);
rpc_data = NULL;
return 0;
diff --git a/lib/remoteproc/drivers/zynq_remoteproc_a9.c b/lib/remoteproc/drivers/zynq_remoteproc_a9.c
index fe47cc2af8e6e28f8de485a4dcfb76acd6bfb377..7141f595a62b9a392ec5b90c26623055ad98df30 100644 (file)
#include <string.h>
#include "openamp/hil.h"
#include "openamp/machine/machine_common.h"
+#include "metal/alloc.h"
/* ------------------------- Macros --------------------------*/
#define ESAL_DP_SLCR_BASE 0xF8000000
struct hil_proc *proc;
/* Allocate memory for proc instance */
- proc = env_allocate_memory(sizeof(struct hil_proc));
+ proc = metal_allocate_memory(sizeof(struct hil_proc));
if (!proc) {
return NULL;
}
static void _release(struct hil_proc *proc)
{
- env_free_memory(proc);
+ metal_free_memory(proc);
}
diff --git a/lib/remoteproc/drivers/zynqmp_remoteproc_a53.c b/lib/remoteproc/drivers/zynqmp_remoteproc_a53.c
index d2139650cfe40d5e5b362e3e9b5f732dc65095d9..061baab398cba8e8a9f03cf5be04c2c59908565f 100644 (file)
#include "metal/utilities.h"
#include "metal/atomic.h"
#include "metal/irq.h"
+#include "metal/alloc.h"
#include "openamp/hil.h"
#include "openamp/remoteproc_plat.h"
#include "openamp/virtqueue.h"
unsigned int ipi_intr_status;
/* Allocate memory for proc instance */
- proc = env_allocate_memory(sizeof(struct hil_proc));
+ proc = metal_allocate_memory(sizeof(struct hil_proc));
if (!proc) {
return NULL;
}
error:
if (proc) {
rproc_close_plat(proc);
- env_free_memory(proc);
+ metal_free_memory(proc);
}
return NULL;
}
metal_io_write32(io, IPI_IDR_OFFSET, ipi->ipi_chn_mask);
rproc_close_plat(proc);
- env_free_memory(proc);
+ metal_free_memory(proc);
}
}
index 101c6ab875d79c06a13434b6a77c0415a20269e4..a983eb3ddcca1859599e4a902b6bb81bc956fdf2 100644 (file)
*/
#include <string.h>
+#include "metal/alloc.h"
#include "openamp/elf_loader.h"
/* Local functions. */
int status;
/* Allocate memory for decode info structure. */
- elf_info = env_allocate_memory(sizeof(struct elf_decode_info));
+ elf_info = metal_allocate_memory(sizeof(struct elf_decode_info));
if (!elf_info) {
return RPROC_ERR_NO_MEM;
@@ -105,7 +106,7 @@ int elf_loader_attach_firmware(struct remoteproc_loader *loader, void *firmware)
if (status) {
/* Free memory. */
- env_free_memory(elf_info);
+ metal_free_memory(elf_info);
return status;
}
(struct elf_decode_info *)loader->fw_decode_info;
if (elf_info) {
/* Free memory. */
- env_free_memory(elf_info->shstrtab);
- env_free_memory(elf_info->section_headers_start);
- env_free_memory(elf_info);
+ metal_free_memory(elf_info->shstrtab);
+ metal_free_memory(elf_info->section_headers_start);
+ metal_free_memory(elf_info);
}
return RPROC_SUCCESS;
section_count = elf_info->elf_header.e_shnum;
/* Allocate memory to read in the section headers. */
- elf_info->section_headers_start =
- env_allocate_memory(section_count *
- elf_info->elf_header.e_shentsize);
+ elf_info->section_headers_start = metal_allocate_memory(section_count * elf_info->elf_header.e_shentsize);
/* Check if the allocation was successful. */
if (elf_info->section_headers_start) {
e_shentsize);
/* Allocate the memory for section header string table. */
- elf_info->shstrtab =
- env_allocate_memory
- (section_header_string_table->sh_size);
+ elf_info->shstrtab = metal_allocate_memory(section_header_string_table->sh_size);
/* Ensure the allocation was successful. */
if (elf_info->shstrtab) {
index d66b20c718ace55eafab0d91d55cdbcfec02cc66..f933bdafa166fdb4d50908103eeccf3b26e180a8 100644 (file)
#include "openamp/env.h"
#include "openamp/hil.h"
#include "metal/sys.h"
+#include "metal/alloc.h"
/**
* remoteproc_resource_init
return RPROC_ERR_PARAM;
}
- rproc = env_allocate_memory(sizeof(struct remote_proc));
+ rproc = metal_allocate_memory(sizeof(struct remote_proc));
if (rproc) {
memset(rproc, 0x00, sizeof(struct remote_proc));
/* There can be only one master for remote configuration so use the
if (rproc->rdev) {
rpmsg_deinit(rproc->rdev);
}
- env_free_memory(rproc);
+ metal_free_memory(rproc);
}
return RPROC_SUCCESS;
return RPROC_ERR_PARAM;
}
- rproc = env_allocate_memory(sizeof(struct remote_proc));
+ rproc = metal_allocate_memory(sizeof(struct remote_proc));
if (rproc) {
memset((void *)rproc, 0x00, sizeof(struct remote_proc));
/* Create proc instance */
hil_delete_proc(rproc->proc);
rproc->proc = RPROC_NULL;
}
- env_free_memory(rproc);
+ metal_free_memory(rproc);
}
return RPROC_SUCCESS;
index 27365d98eabec0c25f43f8e5215f7b6b69fd0c01..e7e96359d09edbfc5d99904225a6ce217b143fff 100644 (file)
*/
#include <string.h>
+#include "metal/alloc.h"
#include "openamp/remoteproc_loader.h"
/**
}
/* Allocate a loader handle. */
- loader = env_allocate_memory(sizeof(struct remoteproc_loader));
+ loader = metal_allocate_memory(sizeof(struct remoteproc_loader));
if (!loader) {
return RPROC_NULL;
default:
/* Loader not supported. */
- env_free_memory(loader);
+ metal_free_memory(loader);
loader = RPROC_NULL;
break;
}
}
/* Recover the allocated memory. */
- env_free_memory(loader);
+ metal_free_memory(loader);
return status;
}
index 8314d9a8204c34796156e53afff9eab35bc1fa14..746e681c2b2a29368cb92cb26e1611fac0c4ed81 100644 (file)
#include <string.h>
#include "openamp/rpmsg.h"
#include "metal/utilities.h"
+#include "metal/alloc.h"
/* Macro to initialize vring HW info */
#define INIT_VRING_ALLOC_INFO(ring_info,vring_hw) \
@@ -108,9 +109,7 @@ int rpmsg_rdev_init(void *pdata, struct remote_device **rdev, int dev_id, int ro
}
/* Create software representation of remote processor. */
- rdev_loc =
- (struct remote_device *)
- env_allocate_memory(sizeof(struct remote_device));
+ rdev_loc = (struct remote_device *)metal_allocate_memory(sizeof(struct remote_device));
if (!rdev_loc) {
return RPMSG_ERR_NO_MEM;
rdev->proc = 0;
}
- env_free_memory(rdev);
+ metal_free_memory(rdev);
}
/**
diff --git a/lib/rpmsg/rpmsg_core.c b/lib/rpmsg/rpmsg_core.c
index cd11dcabce761d958ee8d115330853e14ba02c17..18f65ff65b3982463ebc45c807529d2fb7db6cca 100644 (file)
--- a/lib/rpmsg/rpmsg_core.c
+++ b/lib/rpmsg/rpmsg_core.c
#include "metal/utilities.h"
#include "metal/io.h"
#include "metal/cache.h"
+#include "metal/alloc.h"
/* Internal functions */
static void rpmsg_rx_callback(struct virtqueue *vq);
{
struct rpmsg_channel *rp_chnl;
- rp_chnl = env_allocate_memory(sizeof(struct rpmsg_channel));
+ rp_chnl = metal_allocate_memory(sizeof(struct rpmsg_channel));
if (rp_chnl) {
memset(rp_chnl, 0x00, sizeof(struct rpmsg_channel));
strncpy(rp_chnl->name, name, sizeof(rp_chnl->name));
metal_mutex_acquire(&rp_chnl->rdev->lock);
metal_list_del(&rp_chnl->node);
metal_mutex_release(&rp_chnl->rdev->lock);
- env_free_memory(rp_chnl);
+ metal_free_memory(rp_chnl);
}
}
struct rpmsg_endpoint *rp_ept;
int status = RPMSG_SUCCESS;
- rp_ept = env_allocate_memory(sizeof(struct rpmsg_endpoint));
+ rp_ept = metal_allocate_memory(sizeof(struct rpmsg_endpoint));
if (!rp_ept) {
return RPMSG_NULL;
}
/* Do cleanup in case of error and return */
if (RPMSG_SUCCESS != status) {
- env_free_memory(rp_ept);
+ metal_free_memory(rp_ept);
metal_mutex_release(&rdev->lock);
return RPMSG_NULL;
}
metal_list_del(&rp_ept->node);
metal_mutex_release(&rdev->lock);
/* free node and rp_ept */
- env_free_memory(rp_ept);
+ metal_free_memory(rp_ept);
}
/**
diff --git a/lib/virtio/virtqueue.c b/lib/virtio/virtqueue.c
index 4025760bf66609127ee177b34d7ff1c7041caf96..d9f4fa8f0f964468e82f7fda7fab7c46a77dd1e1 100644 (file)
--- a/lib/virtio/virtqueue.c
+++ b/lib/virtio/virtqueue.c
#include "metal/atomic.h"
#include "metal/dma.h"
#include "metal/io.h"
+#include "metal/alloc.h"
/* Prototype for internal functions. */
static void vq_ring_init(struct virtqueue *);
vq_size = sizeof(struct virtqueue)
+ (ring->num_descs) * sizeof(struct vq_desc_extra);
- vq = (struct virtqueue *)env_allocate_memory(vq_size);
+ vq = (struct virtqueue *)metal_allocate_memory(vq_size);
if (vq == VQ_NULL) {
return (ERROR_NO_MEM);
vq->vq_ring_mem = VQ_NULL;
}
- env_free_memory(vq);
+ metal_free_memory(vq);
}
}