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-sparc64 / dma-mapping.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  3.9 KB  |  166 lines

  1. #ifndef _ASM_SPARC64_DMA_MAPPING_H
  2. #define _ASM_SPARC64_DMA_MAPPING_H
  3.  
  4.  
  5. #ifdef CONFIG_PCI
  6.  
  7. /* we implement the API below in terms of the existing PCI one,
  8.  * so include it */
  9. #include <linux/pci.h>
  10. /* need struct page definitions */
  11. #include <linux/mm.h>
  12.  
  13. static inline int
  14. dma_supported(struct device *dev, u64 mask)
  15. {
  16.     BUG_ON(dev->bus != &pci_bus_type);
  17.  
  18.     return pci_dma_supported(to_pci_dev(dev), mask);
  19. }
  20.  
  21. static inline int
  22. dma_set_mask(struct device *dev, u64 dma_mask)
  23. {
  24.     BUG_ON(dev->bus != &pci_bus_type);
  25.  
  26.     return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
  27. }
  28.  
  29. static inline void *
  30. dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  31.            gfp_t flag)
  32. {
  33.     BUG_ON(dev->bus != &pci_bus_type);
  34.  
  35.     return pci_iommu_ops->alloc_consistent(to_pci_dev(dev), size, dma_handle, flag);
  36. }
  37.  
  38. static inline void
  39. dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
  40.             dma_addr_t dma_handle)
  41. {
  42.     BUG_ON(dev->bus != &pci_bus_type);
  43.  
  44.     pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
  45. }
  46.  
  47. static inline dma_addr_t
  48. dma_map_single(struct device *dev, void *cpu_addr, size_t size,
  49.            enum dma_data_direction direction)
  50. {
  51.     BUG_ON(dev->bus != &pci_bus_type);
  52.  
  53.     return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
  54. }
  55.  
  56. static inline void
  57. dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
  58.          enum dma_data_direction direction)
  59. {
  60.     BUG_ON(dev->bus != &pci_bus_type);
  61.  
  62.     pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
  63. }
  64.  
  65. static inline dma_addr_t
  66. dma_map_page(struct device *dev, struct page *page,
  67.          unsigned long offset, size_t size,
  68.          enum dma_data_direction direction)
  69. {
  70.     BUG_ON(dev->bus != &pci_bus_type);
  71.  
  72.     return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
  73. }
  74.  
  75. static inline void
  76. dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
  77.            enum dma_data_direction direction)
  78. {
  79.     BUG_ON(dev->bus != &pci_bus_type);
  80.  
  81.     pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
  82. }
  83.  
  84. static inline int
  85. dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
  86.        enum dma_data_direction direction)
  87. {
  88.     BUG_ON(dev->bus != &pci_bus_type);
  89.  
  90.     return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
  91. }
  92.  
  93. static inline void
  94. dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
  95.          enum dma_data_direction direction)
  96. {
  97.     BUG_ON(dev->bus != &pci_bus_type);
  98.  
  99.     pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
  100. }
  101.  
  102. static inline void
  103. dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
  104.             enum dma_data_direction direction)
  105. {
  106.     BUG_ON(dev->bus != &pci_bus_type);
  107.  
  108.     pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
  109.                     size, (int)direction);
  110. }
  111.  
  112. static inline void
  113. dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
  114.                enum dma_data_direction direction)
  115. {
  116.     BUG_ON(dev->bus != &pci_bus_type);
  117.  
  118.     pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
  119.                        size, (int)direction);
  120. }
  121.  
  122. static inline void
  123. dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
  124.             enum dma_data_direction direction)
  125. {
  126.     BUG_ON(dev->bus != &pci_bus_type);
  127.  
  128.     pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
  129. }
  130.  
  131. static inline void
  132. dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
  133.                enum dma_data_direction direction)
  134. {
  135.     BUG_ON(dev->bus != &pci_bus_type);
  136.  
  137.     pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
  138. }
  139.  
  140. static inline int
  141. dma_mapping_error(dma_addr_t dma_addr)
  142. {
  143.     return pci_dma_mapping_error(dma_addr);
  144. }
  145.  
  146. #else
  147.  
  148. struct device;
  149.  
  150. static inline void *dma_alloc_coherent(struct device *dev, size_t size,
  151.              dma_addr_t *dma_handle, gfp_t flag)
  152. {
  153.     BUG();
  154.     return NULL;
  155. }
  156.  
  157. static inline void dma_free_coherent(struct device *dev, size_t size,
  158.                void *vaddr, dma_addr_t dma_handle)
  159. {
  160.     BUG();
  161. }
  162.  
  163. #endif /* PCI */
  164.  
  165. #endif /* _ASM_SPARC64_DMA_MAPPING_H */
  166.