~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/frv/mb93090-mb00/pci-dma-nommu.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* pci-dma-nommu.c: Dynamic DMA mapping support for the FRV
  2  *
  3  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
  4  * Written by David Woodhouse (dwmw2@infradead.org)
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License
  8  * as published by the Free Software Foundation; either version
  9  * 2 of the License, or (at your option) any later version.
 10  */
 11 
 12 #include <linux/types.h>
 13 #include <linux/slab.h>
 14 #include <linux/export.h>
 15 #include <linux/dma-mapping.h>
 16 #include <linux/list.h>
 17 #include <linux/pci.h>
 18 #include <asm/io.h>
 19 
 20 #if 1
 21 #define DMA_SRAM_START  dma_coherent_mem_start
 22 #define DMA_SRAM_END    dma_coherent_mem_end
 23 #else // Use video RAM on Matrox
 24 #define DMA_SRAM_START  0xe8900000
 25 #define DMA_SRAM_END    0xe8a00000
 26 #endif
 27 
 28 struct dma_alloc_record {
 29         struct list_head        list;
 30         unsigned long           ofs;
 31         unsigned long           len;
 32 };
 33 
 34 static DEFINE_SPINLOCK(dma_alloc_lock);
 35 static LIST_HEAD(dma_alloc_list);
 36 
 37 static void *frv_dma_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
 38                 gfp_t gfp, unsigned long attrs)
 39 {
 40         struct dma_alloc_record *new;
 41         struct list_head *this = &dma_alloc_list;
 42         unsigned long flags;
 43         unsigned long start = DMA_SRAM_START;
 44         unsigned long end;
 45 
 46         if (!DMA_SRAM_START) {
 47                 printk("%s called without any DMA area reserved!\n", __func__);
 48                 return NULL;
 49         }
 50 
 51         new = kmalloc(sizeof (*new), GFP_ATOMIC);
 52         if (!new)
 53                 return NULL;
 54 
 55         /* Round up to a reasonable alignment */
 56         new->len = (size + 31) & ~31;
 57 
 58         spin_lock_irqsave(&dma_alloc_lock, flags);
 59 
 60         list_for_each (this, &dma_alloc_list) {
 61                 struct dma_alloc_record *this_r = list_entry(this, struct dma_alloc_record, list);
 62                 end = this_r->ofs;
 63 
 64                 if (end - start >= size)
 65                         goto gotone;
 66 
 67                 start = this_r->ofs + this_r->len;
 68         }
 69         /* Reached end of list. */
 70         end = DMA_SRAM_END;
 71         this = &dma_alloc_list;
 72 
 73         if (end - start >= size) {
 74         gotone:
 75                 new->ofs = start;
 76                 list_add_tail(&new->list, this);
 77                 spin_unlock_irqrestore(&dma_alloc_lock, flags);
 78 
 79                 *dma_handle = start;
 80                 return (void *)start;
 81         }
 82 
 83         kfree(new);
 84         spin_unlock_irqrestore(&dma_alloc_lock, flags);
 85         return NULL;
 86 }
 87 
 88 static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,
 89                 dma_addr_t dma_handle, unsigned long attrs)
 90 {
 91         struct dma_alloc_record *rec;
 92         unsigned long flags;
 93 
 94         spin_lock_irqsave(&dma_alloc_lock, flags);
 95 
 96         list_for_each_entry(rec, &dma_alloc_list, list) {
 97                 if (rec->ofs == dma_handle) {
 98                         list_del(&rec->list);
 99                         kfree(rec);
100                         spin_unlock_irqrestore(&dma_alloc_lock, flags);
101                         return;
102                 }
103         }
104         spin_unlock_irqrestore(&dma_alloc_lock, flags);
105         BUG();
106 }
107 
108 static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,
109                 int nents, enum dma_data_direction direction,
110                 unsigned long attrs)
111 {
112         struct scatterlist *sg;
113         int i;
114 
115         BUG_ON(direction == DMA_NONE);
116 
117         if (attrs & DMA_ATTR_SKIP_CPU_SYNC)
118                 return nents;
119 
120         for_each_sg(sglist, sg, nents, i) {
121                 frv_cache_wback_inv(sg_dma_address(sg),
122                                     sg_dma_address(sg) + sg_dma_len(sg));
123         }
124 
125         return nents;
126 }
127 
128 static dma_addr_t frv_dma_map_page(struct device *dev, struct page *page,
129                 unsigned long offset, size_t size,
130                 enum dma_data_direction direction, unsigned long attrs)
131 {
132         BUG_ON(direction == DMA_NONE);
133 
134         if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
135                 flush_dcache_page(page);
136 
137         return (dma_addr_t) page_to_phys(page) + offset;
138 }
139 
140 static void frv_dma_sync_single_for_device(struct device *dev,
141                 dma_addr_t dma_handle, size_t size,
142                 enum dma_data_direction direction)
143 {
144         flush_write_buffers();
145 }
146 
147 static void frv_dma_sync_sg_for_device(struct device *dev,
148                 struct scatterlist *sg, int nelems,
149                 enum dma_data_direction direction)
150 {
151         flush_write_buffers();
152 }
153 
154 
155 static int frv_dma_supported(struct device *dev, u64 mask)
156 {
157         /*
158          * we fall back to GFP_DMA when the mask isn't all 1s,
159          * so we can't guarantee allocations that must be
160          * within a tighter range than GFP_DMA..
161          */
162         if (mask < 0x00ffffff)
163                 return 0;
164         return 1;
165 }
166 
167 const struct dma_map_ops frv_dma_ops = {
168         .alloc                  = frv_dma_alloc,
169         .free                   = frv_dma_free,
170         .map_page               = frv_dma_map_page,
171         .map_sg                 = frv_dma_map_sg,
172         .sync_single_for_device = frv_dma_sync_single_for_device,
173         .sync_sg_for_device     = frv_dma_sync_sg_for_device,
174         .dma_supported          = frv_dma_supported,
175 };
176 EXPORT_SYMBOL(frv_dma_ops);
177 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp