home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / sh / include / asm / dma-mapping.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  5.1 KB  |  194 lines
  1. #ifndef __ASM_SH_DMA_MAPPING_H
  2. #define __ASM_SH_DMA_MAPPING_H
  3.  
  4. #include <linux/mm.h>
  5. #include <linux/scatterlist.h>
  6. #include <asm/cacheflush.h>
  7. #include <asm/io.h>
  8. #include <asm-generic/dma-coherent.h>
  9.  
  10. extern struct bus_type pci_bus_type;
  11.  
  12. #define dma_supported(dev, mask)    (1)
  13.  
  14. static inline int dma_set_mask(struct device *dev, u64 mask)
  15. {
  16.     if (!dev->dma_mask || !dma_supported(dev, mask))
  17.         return -EIO;
  18.  
  19.     *dev->dma_mask = mask;
  20.  
  21.     return 0;
  22. }
  23.  
  24. void *dma_alloc_coherent(struct device *dev, size_t size,
  25.              dma_addr_t *dma_handle, gfp_t flag);
  26.  
  27. void dma_free_coherent(struct device *dev, size_t size,
  28.                void *vaddr, dma_addr_t dma_handle);
  29.  
  30. void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
  31.             enum dma_data_direction dir);
  32.  
  33. #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
  34. #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
  35. #define dma_is_consistent(d, h) (1)
  36.  
  37. static inline dma_addr_t dma_map_single(struct device *dev,
  38.                     void *ptr, size_t size,
  39.                     enum dma_data_direction dir)
  40. {
  41. #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT)
  42.     if (dev->bus == &pci_bus_type)
  43.         return virt_to_phys(ptr);
  44. #endif
  45.     dma_cache_sync(dev, ptr, size, dir);
  46.  
  47.     return virt_to_phys(ptr);
  48. }
  49.  
  50. #define dma_unmap_single(dev, addr, size, dir)    do { } while (0)
  51.  
  52. static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
  53.                  int nents, enum dma_data_direction dir)
  54. {
  55.     int i;
  56.  
  57.     for (i = 0; i < nents; i++) {
  58. #if !defined(CONFIG_PCI) || defined(CONFIG_SH_PCIDMA_NONCOHERENT)
  59.         dma_cache_sync(dev, sg_virt(&sg[i]), sg[i].length, dir);
  60. #endif
  61.         sg[i].dma_address = sg_phys(&sg[i]);
  62.     }
  63.  
  64.     return nents;
  65. }
  66.  
  67. #define dma_unmap_sg(dev, sg, nents, dir)    do { } while (0)
  68.  
  69. static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
  70.                       unsigned long offset, size_t size,
  71.                       enum dma_data_direction dir)
  72. {
  73.     return dma_map_single(dev, page_address(page) + offset, size, dir);
  74. }
  75.  
  76. static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address,
  77.                   size_t size, enum dma_data_direction dir)
  78. {
  79.     dma_unmap_single(dev, dma_address, size, dir);
  80. }
  81.  
  82. static inline void dma_sync_single(struct device *dev, dma_addr_t dma_handle,
  83.                    size_t size, enum dma_data_direction dir)
  84. {
  85. #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT)
  86.     if (dev->bus == &pci_bus_type)
  87.         return;
  88. #endif
  89.     dma_cache_sync(dev, phys_to_virt(dma_handle), size, dir);
  90. }
  91.  
  92. static inline void dma_sync_single_range(struct device *dev,
  93.                      dma_addr_t dma_handle,
  94.                      unsigned long offset, size_t size,
  95.                      enum dma_data_direction dir)
  96. {
  97. #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT)
  98.     if (dev->bus == &pci_bus_type)
  99.         return;
  100. #endif
  101.     dma_cache_sync(dev, phys_to_virt(dma_handle) + offset, size, dir);
  102. }
  103.  
  104. static inline void dma_sync_sg(struct device *dev, struct scatterlist *sg,
  105.                    int nelems, enum dma_data_direction dir)
  106. {
  107.     int i;
  108.  
  109.     for (i = 0; i < nelems; i++) {
  110. #if !defined(CONFIG_PCI) || defined(CONFIG_SH_PCIDMA_NONCOHERENT)
  111.         dma_cache_sync(dev, sg_virt(&sg[i]), sg[i].length, dir);
  112. #endif
  113.         sg[i].dma_address = sg_phys(&sg[i]);
  114.     }
  115. }
  116.  
  117. static inline void dma_sync_single_for_cpu(struct device *dev,
  118.                        dma_addr_t dma_handle, size_t size,
  119.                        enum dma_data_direction dir)
  120. {
  121.     dma_sync_single(dev, dma_handle, size, dir);
  122. }
  123.  
  124. static inline void dma_sync_single_for_device(struct device *dev,
  125.                           dma_addr_t dma_handle,
  126.                           size_t size,
  127.                           enum dma_data_direction dir)
  128. {
  129.     dma_sync_single(dev, dma_handle, size, dir);
  130. }
  131.  
  132. static inline void dma_sync_single_range_for_cpu(struct device *dev,
  133.                          dma_addr_t dma_handle,
  134.                          unsigned long offset,
  135.                          size_t size,
  136.                          enum dma_data_direction direction)
  137. {
  138.     dma_sync_single_for_cpu(dev, dma_handle+offset, size, direction);
  139. }
  140.  
  141. static inline void dma_sync_single_range_for_device(struct device *dev,
  142.                             dma_addr_t dma_handle,
  143.                             unsigned long offset,
  144.                             size_t size,
  145.                             enum dma_data_direction direction)
  146. {
  147.     dma_sync_single_for_device(dev, dma_handle+offset, size, direction);
  148. }
  149.  
  150.  
  151. static inline void dma_sync_sg_for_cpu(struct device *dev,
  152.                        struct scatterlist *sg, int nelems,
  153.                        enum dma_data_direction dir)
  154. {
  155.     dma_sync_sg(dev, sg, nelems, dir);
  156. }
  157.  
  158. static inline void dma_sync_sg_for_device(struct device *dev,
  159.                       struct scatterlist *sg, int nelems,
  160.                       enum dma_data_direction dir)
  161. {
  162.     dma_sync_sg(dev, sg, nelems, dir);
  163. }
  164.  
  165.  
  166. static inline int dma_get_cache_alignment(void)
  167. {
  168.     /*
  169.      * Each processor family will define its own L1_CACHE_SHIFT,
  170.      * L1_CACHE_BYTES wraps to this, so this is always safe.
  171.      */
  172.     return L1_CACHE_BYTES;
  173. }
  174.  
  175. static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
  176. {
  177.     return dma_addr == 0;
  178. }
  179.  
  180. #define ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
  181.  
  182. extern int
  183. dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
  184.                 dma_addr_t device_addr, size_t size, int flags);
  185.  
  186. extern void
  187. dma_release_declared_memory(struct device *dev);
  188.  
  189. extern void *
  190. dma_mark_declared_memory_occupied(struct device *dev,
  191.                   dma_addr_t device_addr, size_t size);
  192.  
  193. #endif /* __ASM_SH_DMA_MAPPING_H */
  194.