/* Free all mapped memory blocks */
list_for_each_entry_safe(atomisp_map, tm, &asd->acc.memory_maps, list) {
list_del(&atomisp_map->list);
- mmgr_free(atomisp_map->ptr);
+ hmm_free(atomisp_map->ptr);
kfree(atomisp_map);
}
}
atomisp_map = kmalloc(sizeof(*atomisp_map), GFP_KERNEL);
if (!atomisp_map) {
- mmgr_free(cssptr);
+ hmm_free(cssptr);
return -ENOMEM;
}
atomisp_map->ptr = cssptr;
return -EINVAL;
list_del(&atomisp_map->list);
- mmgr_free(atomisp_map->ptr);
+ hmm_free(atomisp_map->ptr);
kfree(atomisp_map);
return 0;
}
/* ia_css_debug_dtrace(IA_CSS_DBG_TRACE,
"ia_css_refcount_uninit: freeing (%x)\n",
entry->data);*/
- mmgr_free(entry->data);
+ hmm_free(entry->data);
entry->data = mmgr_NULL;
entry->count = 0;
entry->id = 0;
if (entry->count == 0) {
/* ia_css_debug_dtrace(IA_CSS_DBEUG_TRACE,
"ia_css_refcount_decrement: freeing\n");*/
- mmgr_free(ptr);
+ hmm_free(ptr);
entry->data = mmgr_NULL;
entry->id = 0;
}
} else {
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
"ia_css_refcount_clear: "
- "using mmgr_free: "
+ "using hmm_free: "
"no clear_func\n");
- mmgr_free(entry->data);
+ hmm_free(entry->data);
}
#ifndef ISP2401
*/
#include "device_access.h"
+#include "hmm/hmm.h"
+
/*!
* \brief
* Bit masks for specialised allocation functions
*/
extern hrt_vaddress mmgr_calloc(const size_t N, const size_t size);
-/*! Free the memory allocation identified by the address
-
- \param vaddr[in] Address of the allocation
-
- \return vaddress
- */
-extern void mmgr_free(hrt_vaddress vaddr);
-
/*! Return the address of an allocation in memory
\param size[in] Size in bytes of the allocation
return mmgr_alloc_attr(size * N, MMGR_ATTRIBUTE_CLEARED);
}
-void
-mmgr_free(hrt_vaddress vaddr)
-{
- hmm_free(vaddr);
-}
-
void
mmgr_clear(hrt_vaddress vaddr, const size_t size)
{
ia_css_isp_dvs_statistics_free(struct ia_css_isp_dvs_statistics *me)
{
if (me != NULL) {
- mmgr_free(me->data_ptr);
+ hmm_free(me->data_ptr);
sh_css_free(me);
}
}
ia_css_isp_dvs2_statistics_free(struct ia_css_isp_dvs_statistics *me)
{
if (me != NULL) {
- mmgr_free(me->data_ptr);
+ hmm_free(me->data_ptr);
sh_css_free(me);
}
}
for (i = 0; i < IA_CSS_BINARY_NUM_MODES; i++) {
for (b = binary_infos[i]; b; b = b->next) {
if (b->xmem_addr)
- mmgr_free(b->xmem_addr);
+ hmm_free(b->xmem_addr);
b->xmem_addr = mmgr_NULL;
}
binary_infos[i] = NULL;
IA_CSS_ENTER_PRIVATE("frame = %p", frame);
if (frame != NULL) {
- mmgr_free(frame->data);
+ hmm_free(frame->data);
sh_css_free(frame);
}
if (mem_params->params[pclass][mem].address)
sh_css_free(mem_params->params[pclass][mem].address);
if (css_params->params[pclass][mem].address)
- mmgr_free(css_params->params[pclass][mem].address);
+ hmm_free(css_params->params[pclass][mem].address);
mem_params->params[pclass][mem].address = NULL;
css_params->params[pclass][mem].address = 0x0;
}
#include <type_support.h>
#include <assert_support.h>
#include <platform_support.h> /* memset */
-#include <memory_access.h> /* mmmgr_malloc, mmmgr_free */
+#include <memory_access.h> /* mmmgr_malloc, mhmm_free */
#include <ia_css_debug.h>
/**
pool->handles[i]->vptr,
pool->handles[i]->count);
/* free memory */
- mmgr_free(pool->handles[i]->vptr);
+ hmm_free(pool->handles[i]->vptr);
/* remove from refcount admin */
ia_css_rmgr_refcount_release_vbuf(
&pool->handles[i]);
if ((*handle)->count == 1) {
if (!pool->recycle) {
/* non recycling pool, free mem */
- mmgr_free((*handle)->vptr);
+ hmm_free((*handle)->vptr);
} else {
/* recycle to pool */
rmgr_push_handle(pool, handle);
if (sizeof(hrt_vaddress) > sizeof(hrt_data)) {
ia_css_debug_dtrace(IA_CSS_DEBUG_ERROR,
"size of hrt_vaddress can not be greater than hrt_data\n");
- mmgr_free(code_addr);
+ hmm_free(code_addr);
code_addr = mmgr_NULL;
return IA_CSS_ERR_INTERNAL_ERROR;
}
if ((init_dmem_cfg->ddr_data_addr % HIVE_ISP_DDR_WORD_BYTES) != 0) {
ia_css_debug_dtrace(IA_CSS_DEBUG_ERROR,
"DDR address pointer is not properly aligned for DMA transfer\n");
- mmgr_free(code_addr);
+ hmm_free(code_addr);
code_addr = mmgr_NULL;
return IA_CSS_ERR_INTERNAL_ERROR;
}
/* freeup the resource */
if (spctrl_cofig_info[sp_id].code_addr)
- mmgr_free(spctrl_cofig_info[sp_id].code_addr);
+ hmm_free(spctrl_cofig_info[sp_id].code_addr);
spctrl_loaded[sp_id] = false;
return IA_CSS_SUCCESS;
}
#ifndef ISP2401
if (pipe->scaler_pp_lut != mmgr_NULL) {
- mmgr_free(pipe->scaler_pp_lut);
+ hmm_free(pipe->scaler_pp_lut);
pipe->scaler_pp_lut = mmgr_NULL;
}
#else
while (hd){
hdn = (hd->next) ? &(*hd->next) : NULL;
if (hd->info.isp.xmem_addr) {
- mmgr_free(hd->info.isp.xmem_addr);
+ hmm_free(hd->info.isp.xmem_addr);
hd->info.isp.xmem_addr = mmgr_NULL;
}
hd->isp_code = NULL;
ia_css_isp_3a_statistics_free(struct ia_css_isp_3a_statistics *me)
{
if (me != NULL) {
- mmgr_free(me->data_ptr);
+ hmm_free(me->data_ptr);
sh_css_free(me);
}
}
* We found this to be confusing during development
* and debugging. */
IA_CSS_ENTER("me=%p", me);
- mmgr_free(me->address);
+ hmm_free(me->address);
sh_css_free(me);
IA_CSS_LEAVE("void");
}
inline void sh_css_params_free_gdc_lut(hrt_vaddress addr)
{
if (addr != mmgr_NULL)
- mmgr_free(addr);
+ hmm_free(addr);
}
enum ia_css_err ia_css_pipe_set_bci_scaler_lut(struct ia_css_pipe *pipe,
/* Free any existing tables. */
#ifndef ISP2401
if (pipe->scaler_pp_lut != mmgr_NULL) {
- mmgr_free(pipe->scaler_pp_lut);
+ hmm_free(pipe->scaler_pp_lut);
pipe->scaler_pp_lut = mmgr_NULL;
}
#else
#ifndef ISP2401
if (default_gdc_lut != mmgr_NULL) {
- mmgr_free(default_gdc_lut);
+ hmm_free(default_gdc_lut);
default_gdc_lut = mmgr_NULL;
}
#else
{
IA_CSS_ENTER_PRIVATE("void");
- mmgr_free(ptr);
+ hmm_free(ptr);
IA_CSS_LEAVE_PRIVATE("void");
}
}
/*
- * MW: we can define mmgr_free() to return a NULL
- * then you can write ptr = mmgr_free(ptr);
+ * MW: we can define hmm_free() to return a NULL
+ * then you can write ptr = hmm_free(ptr);
*/
#define safe_free(id, x) \
do { \
MMGR_ATTRIBUTE_CLEARED|MMGR_ATTRIBUTE_CACHED);
}
-void mmgr_free(ia_css_ptr vaddr)
-{
-/* "free()" should accept NULL, "hmm_free()" may not */
- if (vaddr)
- hmm_free(vaddr);
-}
-
ia_css_ptr mmgr_alloc_attr(const size_t size, const uint16_t attribute)
{
ia_css_ptr ptr;