/* Public domain. */

#ifndef _LINUX_DMA_MAPPING_H
#define _LINUX_DMA_MAPPING_H

#include <linux/sizes.h>
#include <linux/scatterlist.h>
#include <linux/dma-direction.h>

struct device;

#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : (1ULL<<(n)) -1)

#define DMA_MAPPING_ERROR (dma_addr_t)-1

#define DMA_ATTR_SKIP_CPU_SYNC  (1 << 1)

static inline int
dma_set_coherent_mask(struct device *dev, uint64_t m)
{
        return 0;
}

static inline int
dma_set_max_seg_size(struct device *dev, unsigned int sz)
{
        return 0;
}

static inline int
dma_set_mask(struct device *dev, uint64_t m)
{
        return 0;
}

static inline int
dma_set_mask_and_coherent(void *dev, uint64_t m)
{
        return 0;
}

static inline bool
dma_addressing_limited(void *dev)
{
        return false;
}

static inline dma_addr_t
dma_map_page(void *dev, struct vm_page *page, size_t offset,
    size_t size, enum dma_data_direction dir)
{
        return VM_PAGE_TO_PHYS(page);
}
static inline dma_addr_t
dma_map_page_attrs(void *dev, struct vm_page *page, size_t offset,
    size_t size, enum dma_data_direction dir, unsigned long attrs)
{
        return VM_PAGE_TO_PHYS(page);
}

static inline void
dma_unmap_page(void *dev, dma_addr_t addr, size_t size,
    enum dma_data_direction dir)
{
}

static inline void
dma_unmap_page_attrs(void *dev, dma_addr_t addr, size_t size,
    enum dma_data_direction dir, unsigned long attrs)
{
}

static inline int
dma_mapping_error(void *dev, dma_addr_t addr)
{
        return 0;
}

void *dma_alloc_coherent(struct device *, size_t, dma_addr_t *, int);
void dma_free_coherent(struct device *, size_t, void *, dma_addr_t);

static inline void *
dmam_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dva, int gfp)
{
        return dma_alloc_coherent(dev, size, dva, gfp);
}

int     dma_get_sgtable(struct device *, struct sg_table *, void *,
            dma_addr_t, size_t);
int     dma_map_sgtable(struct device *, struct sg_table *,
            enum dma_data_direction, u_long);
void    dma_unmap_sgtable(struct device *, struct sg_table *,
            enum dma_data_direction, u_long);

dma_addr_t dma_map_resource(struct device *, phys_addr_t, size_t,
    enum dma_data_direction, u_long);

#endif