LXR linux/arch/openrisc/include/asm/dma-mapping.h

   1/*
   2 * OpenRISC Linux
   3 *
   4 * Linux architectural port borrowing liberally from similar works of
   5 * others.  All original copyrights apply as per the original source
   6 * declaration.
   7 *
   8 * OpenRISC implementation:
   9 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2 of the License, or
  14 * (at your option) any later version.
  15 */
  16
  17#ifndef __ASM_OPENRISC_DMA_MAPPING_H
  18#define __ASM_OPENRISC_DMA_MAPPING_H
  19
  20/*
  21 * See Documentation/DMA-API-HOWTO.txt and
  22 * Documentation/DMA-API.txt for documentation.
  23 */
  24
  25#include <linux/dma-debug.h>
  26#include <asm-generic/dma-coherent.h>
  27#include <linux/kmemcheck.h>
  28#include <linux/dma-mapping.h>
  29
  30#define DMA_ERROR_CODE          (~(dma_addr_t)0x0)
  31
  32extern struct dma_map_ops or1k_dma_map_ops;
  33
  34static inline struct dma_map_ops *get_dma_ops(struct device *dev)
  35{
  36        return &or1k_dma_map_ops;
  37}
  38
  39#include <asm-generic/dma-mapping-common.h>
  40
  41#define dma_alloc_coherent(d,s,h,f) dma_alloc_attrs(d,s,h,f,NULL) 
  42
  43static inline void *dma_alloc_attrs(struct device *dev, size_t size,
  44                                    dma_addr_t *dma_handle, gfp_t gfp,
  45                                    struct dma_attrs *attrs)
  46{
  47        struct dma_map_ops *ops = get_dma_ops(dev);
  48        void *memory;
  49
  50        memory = ops->alloc(dev, size, dma_handle, gfp, attrs);
  51
  52        debug_dma_alloc_coherent(dev, size, *dma_handle, memory);
  53
  54        return memory;
  55}
  56
  57#define dma_free_coherent(d,s,c,h) dma_free_attrs(d,s,c,h,NULL)
  58
  59static inline void dma_free_attrs(struct device *dev, size_t size,
  60                                  void *cpu_addr, dma_addr_t dma_handle,
  61                                  struct dma_attrs *attrs)
  62{
  63        struct dma_map_ops *ops = get_dma_ops(dev);
  64
  65        debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
  66
  67        ops->free(dev, size, cpu_addr, dma_handle, attrs);
  68}
  69
  70static inline void *dma_alloc_noncoherent(struct device *dev, size_t size,
  71                                          dma_addr_t *dma_handle, gfp_t gfp)
  72{
  73        struct dma_attrs attrs;
  74
  75        dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
  76
  77        return dma_alloc_attrs(dev, size, dma_handle, gfp, &attrs);
  78}
  79
  80static inline void dma_free_noncoherent(struct device *dev, size_t size,
  81                                         void *cpu_addr, dma_addr_t dma_handle)
  82{
  83        struct dma_attrs attrs;
  84
  85        dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
  86
  87        dma_free_attrs(dev, size, cpu_addr, dma_handle, &attrs);
  88}
  89
  90static inline int dma_supported(struct device *dev, u64 dma_mask)
  91{
  92        /* Support 32 bit DMA mask exclusively */
  93        return dma_mask == DMA_BIT_MASK(32);
  94}
  95
  96static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
  97{
  98        return 0;
  99}
 100
 101static inline int dma_set_mask(struct device *dev, u64 dma_mask)
 102{
 103        if (!dev->dma_mask || !dma_supported(dev, dma_mask))
 104                return -EIO;
 105
 106        *dev->dma_mask = dma_mask;
 107
 108        return 0;
 109}
 110#endif  /* __ASM_OPENRISC_DMA_MAPPING_H */
 111