home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-cris / dma-mapping.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  4.0 KB  |  180 lines
  1. /* DMA mapping. Nothing tricky here, just virt_to_phys */
  2.  
  3. #ifndef _ASM_CRIS_DMA_MAPPING_H
  4. #define _ASM_CRIS_DMA_MAPPING_H
  5.  
  6. #include <linux/mm.h>
  7. #include <linux/kernel.h>
  8.  
  9. #include <asm/cache.h>
  10. #include <asm/io.h>
  11. #include <asm/scatterlist.h>
  12.  
  13. #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
  14. #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
  15.  
  16. #ifdef CONFIG_PCI
  17. void *dma_alloc_coherent(struct device *dev, size_t size,
  18.                dma_addr_t *dma_handle, gfp_t flag);
  19.  
  20. void dma_free_coherent(struct device *dev, size_t size,
  21.              void *vaddr, dma_addr_t dma_handle);
  22. #else
  23. static inline void *
  24. dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  25.                    gfp_t flag)
  26. {
  27.         BUG();
  28.         return NULL;
  29. }
  30.  
  31. static inline void
  32. dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
  33.                     dma_addr_t dma_handle)
  34. {
  35.         BUG();
  36. }
  37. #endif
  38. static inline dma_addr_t
  39. dma_map_single(struct device *dev, void *ptr, size_t size,
  40.            enum dma_data_direction direction)
  41. {
  42.     BUG_ON(direction == DMA_NONE);
  43.     return virt_to_phys(ptr);
  44. }
  45.  
  46. static inline void
  47. dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
  48.          enum dma_data_direction direction)
  49. {
  50.     BUG_ON(direction == DMA_NONE);
  51. }
  52.  
  53. static inline int
  54. dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
  55.        enum dma_data_direction direction)
  56. {
  57.     printk("Map sg\n");
  58.     return nents;
  59. }
  60.  
  61. static inline dma_addr_t
  62. dma_map_page(struct device *dev, struct page *page, unsigned long offset,
  63.          size_t size, enum dma_data_direction direction)
  64. {
  65.     BUG_ON(direction == DMA_NONE);
  66.     return page_to_phys(page) + offset;
  67. }
  68.  
  69. static inline void
  70. dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
  71.            enum dma_data_direction direction)
  72. {
  73.     BUG_ON(direction == DMA_NONE);
  74. }
  75.  
  76.  
  77. static inline void
  78. dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
  79.          enum dma_data_direction direction)
  80. {
  81.     BUG_ON(direction == DMA_NONE);
  82. }
  83.  
  84. static inline void
  85. dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
  86.             enum dma_data_direction direction)
  87. {
  88. }
  89.  
  90. static inline void
  91. dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
  92.             enum dma_data_direction direction)
  93. {
  94. }
  95.  
  96. static inline void
  97. dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
  98.                   unsigned long offset, size_t size,
  99.                   enum dma_data_direction direction)
  100. {
  101. }
  102.  
  103. static inline void
  104. dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
  105.                  unsigned long offset, size_t size,
  106.                  enum dma_data_direction direction)
  107. {
  108. }
  109.  
  110. static inline void
  111. dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
  112.             enum dma_data_direction direction)
  113. {
  114. }
  115.  
  116. static inline void
  117. dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
  118.             enum dma_data_direction direction)
  119. {
  120. }
  121.  
  122. static inline int
  123. dma_mapping_error(dma_addr_t dma_addr)
  124. {
  125.     return 0;
  126. }
  127.  
  128. static inline int
  129. dma_supported(struct device *dev, u64 mask)
  130. {
  131.         /*
  132.          * we fall back to GFP_DMA when the mask isn't all 1s,
  133.          * so we can't guarantee allocations that must be
  134.          * within a tighter range than GFP_DMA..
  135.          */
  136.         if(mask < 0x00ffffff)
  137.                 return 0;
  138.  
  139.     return 1;
  140. }
  141.  
  142. static inline int
  143. dma_set_mask(struct device *dev, u64 mask)
  144. {
  145.     if(!dev->dma_mask || !dma_supported(dev, mask))
  146.         return -EIO;
  147.  
  148.     *dev->dma_mask = mask;
  149.  
  150.     return 0;
  151. }
  152.  
  153. static inline int
  154. dma_get_cache_alignment(void)
  155. {
  156.     return (1 << INTERNODE_CACHE_SHIFT);
  157. }
  158.  
  159. #define dma_is_consistent(d)    (1)
  160.  
  161. static inline void
  162. dma_cache_sync(void *vaddr, size_t size,
  163.            enum dma_data_direction direction)
  164. {
  165. }
  166.  
  167. #define ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
  168. extern int
  169. dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
  170.                 dma_addr_t device_addr, size_t size, int flags);
  171.  
  172. extern void
  173. dma_release_declared_memory(struct device *dev);
  174.  
  175. extern void *
  176. dma_mark_declared_memory_occupied(struct device *dev,
  177.                   dma_addr_t device_addr, size_t size);
  178.  
  179. #endif
  180.