cmem.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2014 Texas Instruments Incorporated - https://www.ti.com
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef ti_CMEM_H
#define ti_CMEM_H

#if defined (__cplusplus)
extern "C" {
#endif


#define CMEM_VERSION    0x04000300U

#define MAX_POOLS 32

/* magic "block" corresponding to CMA regions */
#define CMEM_CMABLOCKID                 -1

/* ioctl cmd "flavors" */
#define CMEM_WB                         0x00010000
#define CMEM_INV                        0x00020000
#define CMEM_HEAP                       0x00040000  
#define CMEM_POOL                       0x00000000  
#define CMEM_CACHED                     0x00080000  
#define CMEM_NONCACHED                  0x00000000  
#define CMEM_PHYS                       0x00100000

#define CMEM_IOCMAGIC                   0x0000fe00

/* supported "base" ioctl cmds for the driver. */
#define CMEM_IOCALLOC                   1
#define CMEM_IOCALLOCHEAP               2
#define CMEM_IOCFREE                    3
#define CMEM_IOCGETPHYS                 4
#define CMEM_IOCGETSIZE                 5
#define CMEM_IOCGETPOOL                 6
#define CMEM_IOCCACHE                   7
#define CMEM_IOCGETVERSION              8
#define CMEM_IOCGETBLOCK                9
#define CMEM_IOCREGUSER                 10
#define CMEM_IOCGETNUMBLOCKS            11
#define CMEM_IOCCACHEWBINVALL           12
/*
 * New ioctl cmds should use integers greater than the largest current cmd
 * in order to not break backward compatibility.
 */

/* supported "flavors" to "base" ioctl cmds for the driver. */
#define CMEM_IOCCACHEWBINV              CMEM_IOCCACHE | CMEM_WB | CMEM_INV
#define CMEM_IOCCACHEWB                 CMEM_IOCCACHE | CMEM_WB
#define CMEM_IOCCACHEINV                CMEM_IOCCACHE | CMEM_INV
#define CMEM_IOCALLOCCACHED             CMEM_IOCALLOC | CMEM_CACHED
#define CMEM_IOCALLOCHEAPCACHED         CMEM_IOCALLOCHEAP | CMEM_CACHED
#define CMEM_IOCFREEHEAP                CMEM_IOCFREE | CMEM_HEAP
#define CMEM_IOCFREEPHYS                CMEM_IOCFREE | CMEM_PHYS
#define CMEM_IOCFREEHEAPPHYS            CMEM_IOCFREE | CMEM_HEAP | CMEM_PHYS

#define CMEM_IOCCMDMASK                 0x000000ff

typedef struct CMEM_AllocParams {
    int type;           
    int flags;          
    size_t alignment;   
} CMEM_AllocParams;

extern CMEM_AllocParams CMEM_DEFAULTPARAMS;

typedef struct CMEM_BlockAttrs {
    off_t phys_base;
    unsigned long long size;
} CMEM_BlockAttrs;

union CMEM_AllocUnion {
    struct {                    
        size_t size;
        size_t align;
        int blockid;
    } alloc_heap_inparams;      
    struct {                    
        int poolid;
        int blockid;
    } alloc_pool_inparams;      
    struct {                    
        int poolid;
        int blockid;
    } get_size_inparams;        
    struct {                    
        unsigned long long size;
        int blockid;
    } get_pool_inparams;        
    struct {                    
        unsigned long long physp;
        unsigned long long size;
    } alloc_pool_outparams;     
    struct {                    
        unsigned long long physp;
        unsigned long long size;
    } get_block_outparams;      
    struct {                    
        int poolid;
        size_t size;
    } free_outparams;           
    unsigned long long physp;
    void *virtp;
    size_t size;
    int poolid;
    int blockid;
};

int CMEM_init(void);

int CMEM_getPool(unsigned long long size);

int CMEM_getPool2(int blockid, unsigned long long size);

void *CMEM_allocPool(int poolid, CMEM_AllocParams *params);

void *CMEM_allocPool2(int blockid, int poolid, CMEM_AllocParams *params);

void *CMEM_alloc(size_t size, CMEM_AllocParams *params);

void *CMEM_alloc2(int blockid, size_t size, CMEM_AllocParams *params);

off_t CMEM_allocPoolPhys(int poolid, CMEM_AllocParams *params);

off_t CMEM_allocPoolPhys2(int blockid, int poolid, CMEM_AllocParams *params);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

off64_t CMEM_allocPoolPhys64(int blockid, int poolid, CMEM_AllocParams *params);
#endif

off_t CMEM_allocPhys(size_t size, CMEM_AllocParams *params);

off_t CMEM_allocPhys2(int blockid, size_t size, CMEM_AllocParams *params);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

off64_t CMEM_allocPhys64(int blockid, size_t size, CMEM_AllocParams *params);
#endif

void *CMEM_registerAlloc(off_t physp);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

void *CMEM_registerAlloc64(off64_t physp);
#endif

int CMEM_free(void *ptr, CMEM_AllocParams *params);

int CMEM_freePhys(off_t physp, CMEM_AllocParams *params);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

int CMEM_freePhys64(off64_t physp, CMEM_AllocParams *params);
#endif

int CMEM_unregister(void *ptr, CMEM_AllocParams *params);

off_t CMEM_getPhys(void *ptr);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

off64_t CMEM_getPhys64(void *ptr);
#endif

int CMEM_cacheWbInvAll(void);

int CMEM_cacheWb(void *ptr, size_t size);

void *CMEM_map(off_t physp, size_t size);

#if defined(LINUXUTILS_BUILDOS_ANDROID)

void *CMEM_map64(off64_t physp, size_t size);
#endif

int CMEM_unmap(void *userp, size_t size);

int CMEM_cacheInv(void *ptr, size_t size);

int CMEM_cacheWbInv(void *ptr, size_t size);

int CMEM_getVersion(void);

int CMEM_getBlock(off_t *pphys_base, unsigned long long *psize);

int CMEM_getBlockAttrs(int blockid, CMEM_BlockAttrs *pattrs);

int CMEM_getNumBlocks(int *pnblocks);

int CMEM_exit(void);

#if defined (__cplusplus)
}
#endif

#endif