1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* EHCI HCD (Host Controller Driver) SRAM Glue.
*
*/
#ifndef CONFIG_HAVE_GENERIC_DMA_COHERENT
#include <linux/slab.h>
#include <linux/dmapool.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/export.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/wait.h>
#include "ehci-sram.h"
struct dma_coherent_mem {
void *virt_base;
dma_addr_t device_base;
phys_addr_t pfn_base;
int size;
int flags;
unsigned long *bitmap;
};
static void *ehci_sram_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
gfp_t gfp, struct dma_attrs *attrs);
static void ehci_sram_free(struct device *dev, size_t size, void *vaddr,
dma_addr_t dma_handle, struct dma_attrs *attrs);
static struct dma_map_ops sram_ops;
static struct dma_map_ops *dma_ops_org;
/* NOTE: the following routine should be in arch/x86/include/asm/dma-mapping.h
* along with get_dma_ops.
*/
static inline void set_dma_ops(struct device *dev, struct dma_map_ops *ops)
{
#ifdef CONFIG_X86_DEV_DMA_OPS
dev->archdata.dma_ops = ops;
#endif
}
/* Attach SRAM to device */
int ehci_sram_declare(struct device *dev, dma_addr_t bus_addr,
dma_addr_t device_addr, size_t size, int flags)
{
void __iomem *mem_base = NULL;
int pages = size >> PAGE_SHIFT;
int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
dma_ops_org = get_dma_ops(dev);
if ((flags & (DMA_MEMORY_MAP | DMA_MEMORY_IO)) == 0)
goto out;
if (!size)
goto out;
if (dev->dma_mem)
goto out;
mem_base = ioremap(bus_addr, size);
if (!mem_base)
goto out;
dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
if (!dev->dma_mem)
goto out;
dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
if (!dev->dma_mem->bitmap)
goto free1_out;
dev->dma_mem->virt_base = mem_base;
dev->dma_mem->device_base = device_addr;
dev->dma_mem->pfn_base = PFN_DOWN(bus_addr);
dev->dma_mem->size = pages;
dev->dma_mem->flags = flags;
memcpy(&sram_ops, dma_ops_org, sizeof(struct dma_map_ops));
sram_ops.alloc = ehci_sram_alloc;
sram_ops.free = ehci_sram_free;
set_dma_ops(dev, &sram_ops);
return 1;
free1_out:
kfree(dev->dma_mem);
out:
if (mem_base)
iounmap(mem_base);
return 0;
}
/* Detach SRAM from device */
void ehci_sram_release(struct device *dev)
{
struct dma_coherent_mem *mem = dev->dma_mem;
if (!mem)
return;
set_dma_ops(dev, dma_ops_org);
dev->dma_mem = NULL;
iounmap(mem->virt_base);
kfree(mem->bitmap);
kfree(mem);
}
/**
* ehci_sram_alloc() - try to allocate memory from the SRAM
*
* @dev: device from which we allocate memory
* @size: size of requested memory area
* @dma_handle: This will be filled with the correct dma handle
*
* This function allocate a block from SRAM.
*
* Returns the virtual address to allocated area, or NULL if failed.
*/
void *ehci_sram_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
gfp_t gfp, struct dma_attrs *attrs)
{
struct dma_coherent_mem *mem;
int order = get_order(size);
int pageno;
void *pret;
if (!dev)
return 0;
mem = dev->dma_mem;
if (!mem)
return 0;
pret = NULL;
if (unlikely(size > (mem->size << PAGE_SHIFT)))
goto err;
pageno = bitmap_find_free_region(mem->bitmap, mem->size, order);
if (unlikely(pageno < 0))
goto err;
/*
* Memory was found in the per-device area.
*/
*dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
pret = mem->virt_base + (pageno << PAGE_SHIFT);
memset(pret, 0, size);
return pret;
err:
/*
* In the case where the allocation can not be satisfied from the
* per-device area, try to fall back to generic memory if the
* constraints allow it.
*/
if (dma_ops_org->alloc)
return dma_ops_org->alloc(dev, size, dma_handle, gfp, attrs);
return NULL;
}
/**
* ehci_sram_free() - try to free the memory allocated from SRAM
* @dev: device from which the memory was allocated
* @size: size of memory area
* @vaddr: virtual address of allocated pages
*
* This checks whether the memory was allocated from the SRAM
* and if so, releases that memory.
*
* Returns 1 if we correctly released the memory, or 0 if not
*/
void ehci_sram_free(struct device *dev, size_t size, void *vaddr,
dma_addr_t dma_handle, struct dma_attrs *attrs)
{
struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
int order = get_order(size);
if (mem && vaddr >= mem->virt_base && vaddr <
(mem->virt_base + (mem->size << PAGE_SHIFT))) {
int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;
bitmap_release_region(mem->bitmap, page, order);
} else if (mem && dma_ops_org->free) {
dma_ops_org->free(dev, size, vaddr, dma_handle, attrs);
}
}
#endif
|
