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 / ia64 / include / asm / dma-mapping.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  5.0 KB  |  150 lines
  1. #ifndef _ASM_IA64_DMA_MAPPING_H
  2. #define _ASM_IA64_DMA_MAPPING_H
  3.  
  4. /*
  5.  * Copyright (C) 2003-2004 Hewlett-Packard Co
  6.  *    David Mosberger-Tang <davidm@hpl.hp.com>
  7.  */
  8. #include <asm/machvec.h>
  9. #include <linux/scatterlist.h>
  10. #include <asm/swiotlb.h>
  11.  
  12. struct dma_mapping_ops {
  13.     int             (*mapping_error)(struct device *dev,
  14.                      dma_addr_t dma_addr);
  15.     void*           (*alloc_coherent)(struct device *dev, size_t size,
  16.                 dma_addr_t *dma_handle, gfp_t gfp);
  17.     void            (*free_coherent)(struct device *dev, size_t size,
  18.                 void *vaddr, dma_addr_t dma_handle);
  19.     dma_addr_t      (*map_single)(struct device *hwdev, unsigned long ptr,
  20.                 size_t size, int direction);
  21.     void            (*unmap_single)(struct device *dev, dma_addr_t addr,
  22.                 size_t size, int direction);
  23.     void            (*sync_single_for_cpu)(struct device *hwdev,
  24.                 dma_addr_t dma_handle, size_t size,
  25.                 int direction);
  26.     void            (*sync_single_for_device)(struct device *hwdev,
  27.                 dma_addr_t dma_handle, size_t size,
  28.                 int direction);
  29.     void            (*sync_single_range_for_cpu)(struct device *hwdev,
  30.                 dma_addr_t dma_handle, unsigned long offset,
  31.                 size_t size, int direction);
  32.     void            (*sync_single_range_for_device)(struct device *hwdev,
  33.                 dma_addr_t dma_handle, unsigned long offset,
  34.                 size_t size, int direction);
  35.     void            (*sync_sg_for_cpu)(struct device *hwdev,
  36.                 struct scatterlist *sg, int nelems,
  37.                 int direction);
  38.     void            (*sync_sg_for_device)(struct device *hwdev,
  39.                 struct scatterlist *sg, int nelems,
  40.                 int direction);
  41.     int             (*map_sg)(struct device *hwdev, struct scatterlist *sg,
  42.                 int nents, int direction);
  43.     void            (*unmap_sg)(struct device *hwdev,
  44.                 struct scatterlist *sg, int nents,
  45.                 int direction);
  46.     int             (*dma_supported_op)(struct device *hwdev, u64 mask);
  47.     int        is_phys;
  48. };
  49.  
  50. extern struct dma_mapping_ops *dma_ops;
  51. extern struct ia64_machine_vector ia64_mv;
  52. extern void set_iommu_machvec(void);
  53.  
  54. #define dma_alloc_coherent(dev, size, handle, gfp)    \
  55.     platform_dma_alloc_coherent(dev, size, handle, (gfp) | GFP_DMA)
  56.  
  57. /* coherent mem. is cheap */
  58. static inline void *
  59. dma_alloc_noncoherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  60.               gfp_t flag)
  61. {
  62.     return dma_alloc_coherent(dev, size, dma_handle, flag);
  63. }
  64. #define dma_free_coherent    platform_dma_free_coherent
  65. static inline void
  66. dma_free_noncoherent(struct device *dev, size_t size, void *cpu_addr,
  67.              dma_addr_t dma_handle)
  68. {
  69.     dma_free_coherent(dev, size, cpu_addr, dma_handle);
  70. }
  71. #define dma_map_single_attrs    platform_dma_map_single_attrs
  72. static inline dma_addr_t dma_map_single(struct device *dev, void *cpu_addr,
  73.                     size_t size, int dir)
  74. {
  75.     return dma_map_single_attrs(dev, cpu_addr, size, dir, NULL);
  76. }
  77. #define dma_map_sg_attrs    platform_dma_map_sg_attrs
  78. static inline int dma_map_sg(struct device *dev, struct scatterlist *sgl,
  79.                  int nents, int dir)
  80. {
  81.     return dma_map_sg_attrs(dev, sgl, nents, dir, NULL);
  82. }
  83. #define dma_unmap_single_attrs    platform_dma_unmap_single_attrs
  84. static inline void dma_unmap_single(struct device *dev, dma_addr_t cpu_addr,
  85.                     size_t size, int dir)
  86. {
  87.     return dma_unmap_single_attrs(dev, cpu_addr, size, dir, NULL);
  88. }
  89. #define dma_unmap_sg_attrs    platform_dma_unmap_sg_attrs
  90. static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sgl,
  91.                 int nents, int dir)
  92. {
  93.     return dma_unmap_sg_attrs(dev, sgl, nents, dir, NULL);
  94. }
  95. #define dma_sync_single_for_cpu    platform_dma_sync_single_for_cpu
  96. #define dma_sync_sg_for_cpu    platform_dma_sync_sg_for_cpu
  97. #define dma_sync_single_for_device platform_dma_sync_single_for_device
  98. #define dma_sync_sg_for_device    platform_dma_sync_sg_for_device
  99. #define dma_mapping_error    platform_dma_mapping_error
  100.  
  101. #define dma_map_page(dev, pg, off, size, dir)                \
  102.     dma_map_single(dev, page_address(pg) + (off), (size), (dir))
  103. #define dma_unmap_page(dev, dma_addr, size, dir)            \
  104.     dma_unmap_single(dev, dma_addr, size, dir)
  105.  
  106. /*
  107.  * Rest of this file is part of the "Advanced DMA API".  Use at your own risk.
  108.  * See Documentation/DMA-API.txt for details.
  109.  */
  110.  
  111. #define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir)    \
  112.     dma_sync_single_for_cpu(dev, dma_handle, size, dir)
  113. #define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir)    \
  114.     dma_sync_single_for_device(dev, dma_handle, size, dir)
  115.  
  116. #define dma_supported        platform_dma_supported
  117.  
  118. static inline int
  119. dma_set_mask (struct device *dev, u64 mask)
  120. {
  121.     if (!dev->dma_mask || !dma_supported(dev, mask))
  122.         return -EIO;
  123.     *dev->dma_mask = mask;
  124.     return 0;
  125. }
  126.  
  127. extern int dma_get_cache_alignment(void);
  128.  
  129. static inline void
  130. dma_cache_sync (struct device *dev, void *vaddr, size_t size,
  131.     enum dma_data_direction dir)
  132. {
  133.     /*
  134.      * IA-64 is cache-coherent, so this is mostly a no-op.  However, we do need to
  135.      * ensure that dma_cache_sync() enforces order, hence the mb().
  136.      */
  137.     mb();
  138. }
  139.  
  140. #define dma_is_consistent(d, h)    (1)    /* all we do is coherent memory... */
  141.  
  142. static inline struct dma_mapping_ops *get_dma_ops(struct device *dev)
  143. {
  144.     return dma_ops;
  145. }
  146.  
  147.  
  148.  
  149. #endif /* _ASM_IA64_DMA_MAPPING_H */
  150.