SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/sparc/kernel/dma.c

   1 /* dma.c: PCI and SBUS DMA accessors for 32-bit sparc.
   2  *
   3  * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/dma-mapping.h>
   9 #include <linux/scatterlist.h>
  10 #include <linux/mm.h>
  11
  12 #ifdef CONFIG_PCI
  13 #include <linux/pci.h>
  14 #endif
  15
  16 #include "dma.h"
  17
  18 int dma_supported(struct device *dev, u64 mask)
  19 {
  20 #ifdef CONFIG_PCI
  21         if (dev->bus == &pci_bus_type)
  22                 return pci_dma_supported(to_pci_dev(dev), mask);
  23 #endif
  24         return 0;
  25 }
  26 EXPORT_SYMBOL(dma_supported);
  27
  28 int dma_set_mask(struct device *dev, u64 dma_mask)
  29 {
  30 #ifdef CONFIG_PCI
  31         if (dev->bus == &pci_bus_type)
  32                 return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
  33 #endif
  34         return -EOPNOTSUPP;
  35 }
  36 EXPORT_SYMBOL(dma_set_mask);
  37
  38 static void *dma32_alloc_coherent(struct device *dev, size_t size,
  39                                   dma_addr_t *dma_handle, gfp_t flag)
  40 {
  41 #ifdef CONFIG_PCI
  42         if (dev->bus == &pci_bus_type)
  43                 return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
  44 #endif
  45         return sbus_alloc_consistent(dev, size, dma_handle);
  46 }
  47
  48 static void dma32_free_coherent(struct device *dev, size_t size,
  49                                 void *cpu_addr, dma_addr_t dma_handle)
  50 {
  51 #ifdef CONFIG_PCI
  52         if (dev->bus == &pci_bus_type) {
  53                 pci_free_consistent(to_pci_dev(dev), size,
  54                                     cpu_addr, dma_handle);
  55                 return;
  56         }
  57 #endif
  58         sbus_free_consistent(dev, size, cpu_addr, dma_handle);
  59 }
  60
  61 static dma_addr_t dma32_map_page(struct device *dev, struct page *page,
  62                                  unsigned long offset, size_t size,
  63                                  enum dma_data_direction direction,
  64                                  struct dma_attrs *attrs)
  65 {
  66 #ifdef CONFIG_PCI
  67         if (dev->bus == &pci_bus_type)
  68                 return pci_map_page(to_pci_dev(dev), page, offset,
  69                                     size, (int)direction);
  70 #endif
  71         return sbus_map_single(dev, page_address(page) + offset,
  72                                size, (int)direction);
  73 }
  74
  75 static void dma32_unmap_page(struct device *dev, dma_addr_t dma_address,
  76                              size_t size, enum dma_data_direction direction,
  77                              struct dma_attrs *attrs)
  78 {
  79 #ifdef CONFIG_PCI
  80         if (dev->bus == &pci_bus_type) {
  81                 pci_unmap_page(to_pci_dev(dev), dma_address,
  82                                size, (int)direction);
  83                 return;
  84         }
  85 #endif
  86         sbus_unmap_single(dev, dma_address, size, (int)direction);
  87 }
  88
  89 static int dma32_map_sg(struct device *dev, struct scatterlist *sg,
  90                         int nents, enum dma_data_direction direction,
  91                         struct dma_attrs *attrs)
  92 {
  93 #ifdef CONFIG_PCI
  94         if (dev->bus == &pci_bus_type)
  95                 return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
  96 #endif
  97         return sbus_map_sg(dev, sg, nents, direction);
  98 }
  99
 100 void dma32_unmap_sg(struct device *dev, struct scatterlist *sg,
 101                     int nents, enum dma_data_direction direction,
 102                     struct dma_attrs *attrs)
 103 {
 104 #ifdef CONFIG_PCI
 105         if (dev->bus == &pci_bus_type) {
 106                 pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction);
 107                 return;
 108         }
 109 #endif
 110         sbus_unmap_sg(dev, sg, nents, (int)direction);
 111 }
 112
 113 static void dma32_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
 114                                       size_t size,
 115                                       enum dma_data_direction direction)
 116 {
 117 #ifdef CONFIG_PCI
 118         if (dev->bus == &pci_bus_type) {
 119                 pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
 120                                             size, (int)direction);
 121                 return;
 122         }
 123 #endif
 124         sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction);
 125 }
 126
 127 static void dma32_sync_single_for_device(struct device *dev,
 128                                          dma_addr_t dma_handle, size_t size,
 129                                          enum dma_data_direction direction)
 130 {
 131 #ifdef CONFIG_PCI
 132         if (dev->bus == &pci_bus_type) {
 133                 pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
 134                                                size, (int)direction);
 135                 return;
 136         }
 137 #endif
 138         sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction);
 139 }
 140
 141 static void dma32_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
 142                                   int nelems, enum dma_data_direction direction)
 143 {
 144 #ifdef CONFIG_PCI
 145         if (dev->bus == &pci_bus_type) {
 146                 pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg,
 147                                         nelems, (int)direction);
 148                 return;
 149         }
 150 #endif
 151         BUG();
 152 }
 153
 154 static void dma32_sync_sg_for_device(struct device *dev,
 155                                      struct scatterlist *sg, int nelems,
 156                                      enum dma_data_direction direction)
 157 {
 158 #ifdef CONFIG_PCI
 159         if (dev->bus == &pci_bus_type) {
 160                 pci_dma_sync_sg_for_device(to_pci_dev(dev), sg,
 161                                            nelems, (int)direction);
 162                 return;
 163         }
 164 #endif
 165         BUG();
 166 }
 167
 168 static const struct dma_map_ops dma32_dma_ops = {
 169         .alloc_coherent         = dma32_alloc_coherent,
 170         .free_coherent          = dma32_free_coherent,
 171         .map_page               = dma32_map_page,
 172         .unmap_page             = dma32_unmap_page,
 173         .map_sg                 = dma32_map_sg,
 174         .unmap_sg               = dma32_unmap_sg,
 175         .sync_single_for_cpu    = dma32_sync_single_for_cpu,
 176         .sync_single_for_device = dma32_sync_single_for_device,
 177         .sync_sg_for_cpu        = dma32_sync_sg_for_cpu,
 178         .sync_sg_for_device     = dma32_sync_sg_for_device,
 179 };
 180
 181 const struct dma_map_ops *dma_ops = &dma32_dma_ops;
 182 EXPORT_SYMBOL(dma_ops);