HAP_mem.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2020 Qualcomm Technologies, Inc.
 * All Rights Reserved.
 * Confidential and Proprietary - Qualcomm Technologies, Inc
 */

#ifndef HAP_MEM_H
#define HAP_MEM_H
#include <stdlib.h>
#include "AEEStdDef.h"
#include "AEEStdErr.h"

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Protections are chosen from these bits, or-ed together
 */



#define HAP_PROT_NONE   0x00    /* no permissions */

#define HAP_PROT_READ   0x01    /* pages can be read */

#define HAP_PROT_WRITE  0x02    /* pages can be written */

#define HAP_PROT_EXEC   0x04    /* pages can be executed */



/*
 * Cache policy or-ed with protections parameter
 */


#define HAP_MEM_CACHE_WRITEBACK    (0x10)    /* cache write back */

#define HAP_MEM_CACHE_NON_SHARED   (0x20)    /* normal uncached memory */

#define HAP_MEM_CACHE_WRITETHROUGH  (0x40)    /* write through memory */



#define HAP_MEM_FLAGS_SKIP_DSP_MAP    0

#define HAP_MEM_FLAGS_DSP_MAP         1

#define HAP_MEM_FLAGS_EXTENDED_MAP    2

#define HAP_MEM_FLAGS_MAX             (HAP_MEM_FLAGS_EXTENDED_MAP + 1)


static inline int HAP_malloc(uint32 bytes, void** pptr)
{
    *pptr = malloc(bytes);
    if (*pptr) {
        return AEE_SUCCESS;
    }
    return AEE_ENOMEMORY;
}

static inline int HAP_free(void* ptr)
{
    if(ptr == NULL)
        return AEE_EBADCLASS;
    free(ptr);
    return AEE_SUCCESS;
}

struct HAP_mem_stats {
   uint64 bytes_free; 
   uint64 bytes_used; 
   uint64 seg_free;   
   uint64 seg_used;   
   uint64 min_grow_bytes; 
};

enum HAP_mem_stats_request {
  USAGE_STATS = 1,
  MAX_USED
};

typedef struct {
  enum HAP_mem_stats_request req_id;
  union {
    struct HAP_mem_stats usage_stats;
    unsigned long max_used; /* Peak heap usage */
  };
} HAP_mem_heap_info_t;

int HAP_mem_get_stats(struct HAP_mem_stats *stats);

int HAP_mem_get_heap_info(HAP_mem_heap_info_t *payload);

typedef enum
{
  START = 0,
  END
} marker_t;

typedef enum
{
  HAP_MEM_LOG_BLOCKS = 1,
  HAP_MEM_SET_MARKER = 2,
  HAP_MEM_MAP        = 3,
  HAP_MEM_UNMAP      = 4,
  HAP_RESERVE_VA     = 5,
  HAP_UNRESERVE_VA   = 6
} HAP_mem_req_t;

typedef struct
{
  marker_t marker_type;
  uint16_t instance;
} HAP_mem_marker_payload_t;

/* Payload structure for HAP_MEM_MAP request */
typedef struct {
    uint64_t addr;   // [in] reserved va (optional). If 0, buffer mapped at random VA
    uint64_t len;    // [in] length of buffer to be mapped
    int prot;        // [in] permissions and cache-mode of mapping
    int flags;       // [in] buffer flags
    int fd;          // [in] file descriptor of buffer
    uint64_t dsp_pa; // [in] Offset
    uint64_t dsp_va; // [out] Mapped DSP virtual address
} HAP_mem_map_t;

/* Payload structure for HAP_MEM_UNMAP request */
typedef struct {
    uint64_t dsp_va;   // [in] DSP VA to be unmapped
    uint64_t len;      // [in] length of mapping
} HAP_mem_unmap_t;

/* Payload structure for HAP_RESERVE_VA request */
typedef struct {
  uint64_t len;     // [in] Length of VA space to be reserved
  int prot;         // [in] Permissions of the VA space
  int flags;         // [in] flags (unused for now)
  uint64_t dsp_va;  // [out] Reserved DSP virtual address
} HAP_mem_reserve_t;

/* Payload structure for HAP_UNRESERVE_VA request */
typedef struct {
   uint64_t dsp_va;   // [in] DSP VA to be unreserved
   uint64_t len;      // [in] Length of buffer to be unreserved
} HAP_mem_unreserve_t;

typedef struct
{
  HAP_mem_req_t request_id;
  union {
    HAP_mem_marker_payload_t mem_marker_payload;
    HAP_mem_map_t mmap;
    HAP_mem_unmap_t munmap;
    HAP_mem_reserve_t reserve;
    HAP_mem_unreserve_t unreserve;
  };
} HAP_mem_req_payload_t;

int HAP_mem_request(HAP_mem_req_payload_t *mem_payload);

int HAP_mem_set_grow_size(uint64 min, uint64 max);

int HAP_mem_set_heap_thresholds(unsigned int low_largest_block_size, unsigned int high_largest_block_size);


void* HAP_mmap(void *addr, int len, int prot, int flags, int fd, long offset);

void* HAP_mmap2(void *addr, size_t len, int prot, int flags, int fd, long offset);

int HAP_munmap(void *addr, int len);

int HAP_munmap2(void *addr, size_t len);

int HAP_mmap_get(int fd, void **vaddr, uint64 *paddr);

int HAP_mmap_put(int fd);

uint64 HAP_mem_available_stack(void);

int HAP_apps_mem_request(size_t len, uint32_t flags, int *fd, uint64_t *dsp_va);

int HAP_apps_mem_release(int fd);

#ifdef __cplusplus
}
#endif

#endif // HAP_MEM_H