← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to arch/openrisc/include/asm/dma-mapping.h

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/openrisc/include/asm/dma-mapping.h
 
1
/*
 
2
 * OpenRISC Linux
 
3
 *
 
4
 * Linux architectural port borrowing liberally from similar works of
 
5
 * others.  All original copyrights apply as per the original source
 
6
 * declaration.
 
7
 *
 
8
 * OpenRISC implementation:
 
9
 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
 
10
 *
 
11
 * This program is free software; you can redistribute it and/or modify
 
12
 * it under the terms of the GNU General Public License as published by
 
13
 * the Free Software Foundation; either version 2 of the License, or
 
14
 * (at your option) any later version.
 
15
 */
 
16
 
 
17
#ifndef __ASM_OPENRISC_DMA_MAPPING_H
 
18
#define __ASM_OPENRISC_DMA_MAPPING_H
 
19
 
 
20
/*
 
21
 * See Documentation/DMA-API-HOWTO.txt and
 
22
 * Documentation/DMA-API.txt for documentation.
 
23
 *
 
24
 * This file is written with the intention of eventually moving over
 
25
 * to largely using asm-generic/dma-mapping-common.h in its place.
 
26
 */
 
27
 
 
28
#include <linux/dma-debug.h>
 
29
#include <asm-generic/dma-coherent.h>
 
30
#include <linux/kmemcheck.h>
 
31
 
 
32
#define DMA_ERROR_CODE          (~(dma_addr_t)0x0)
 
33
 
 
34
 
 
35
#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
 
36
#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 
37
 
 
38
void *or1k_dma_alloc_coherent(struct device *dev, size_t size,
 
39
                              dma_addr_t *dma_handle, gfp_t flag);
 
40
void or1k_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 
41
                            dma_addr_t dma_handle);
 
42
dma_addr_t or1k_map_page(struct device *dev, struct page *page,
 
43
                         unsigned long offset, size_t size,
 
44
                         enum dma_data_direction dir,
 
45
                         struct dma_attrs *attrs);
 
46
void or1k_unmap_page(struct device *dev, dma_addr_t dma_handle,
 
47
                     size_t size, enum dma_data_direction dir,
 
48
                     struct dma_attrs *attrs);
 
49
int or1k_map_sg(struct device *dev, struct scatterlist *sg,
 
50
                int nents, enum dma_data_direction dir,
 
51
                struct dma_attrs *attrs);
 
52
void or1k_unmap_sg(struct device *dev, struct scatterlist *sg,
 
53
                   int nents, enum dma_data_direction dir,
 
54
                   struct dma_attrs *attrs);
 
55
void or1k_sync_single_for_cpu(struct device *dev,
 
56
                              dma_addr_t dma_handle, size_t size,
 
57
                              enum dma_data_direction dir);
 
58
void or1k_sync_single_for_device(struct device *dev,
 
59
                                 dma_addr_t dma_handle, size_t size,
 
60
                                 enum dma_data_direction dir);
 
61
 
 
62
static inline void *dma_alloc_coherent(struct device *dev, size_t size,
 
63
                                        dma_addr_t *dma_handle, gfp_t flag)
 
64
{
 
65
        void *memory;
 
66
 
 
67
        memory = or1k_dma_alloc_coherent(dev, size, dma_handle, flag);
 
68
 
 
69
        debug_dma_alloc_coherent(dev, size, *dma_handle, memory);
 
70
        return memory;
 
71
}
 
72
 
 
73
static inline void dma_free_coherent(struct device *dev, size_t size,
 
74
                                     void *cpu_addr, dma_addr_t dma_handle)
 
75
{
 
76
        debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
 
77
        or1k_dma_free_coherent(dev, size, cpu_addr, dma_handle);
 
78
}
 
79
 
 
80
static inline dma_addr_t dma_map_single(struct device *dev, void *ptr,
 
81
                                        size_t size,
 
82
                                        enum dma_data_direction dir)
 
83
{
 
84
        dma_addr_t addr;
 
85
 
 
86
        kmemcheck_mark_initialized(ptr, size);
 
87
        BUG_ON(!valid_dma_direction(dir));
 
88
        addr = or1k_map_page(dev, virt_to_page(ptr),
 
89
                             (unsigned long)ptr & ~PAGE_MASK, size,
 
90
                             dir, NULL);
 
91
        debug_dma_map_page(dev, virt_to_page(ptr),
 
92
                           (unsigned long)ptr & ~PAGE_MASK, size,
 
93
                           dir, addr, true);
 
94
        return addr;
 
95
}
 
96
 
 
97
static inline void dma_unmap_single(struct device *dev, dma_addr_t addr,
 
98
                                          size_t size,
 
99
                                          enum dma_data_direction dir)
 
100
{
 
101
        BUG_ON(!valid_dma_direction(dir));
 
102
        or1k_unmap_page(dev, addr, size, dir, NULL);
 
103
        debug_dma_unmap_page(dev, addr, size, dir, true);
 
104
}
 
105
 
 
106
static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
 
107
                                   int nents, enum dma_data_direction dir)
 
108
{
 
109
        int i, ents;
 
110
        struct scatterlist *s;
 
111
 
 
112
        for_each_sg(sg, s, nents, i)
 
113
                kmemcheck_mark_initialized(sg_virt(s), s->length);
 
114
        BUG_ON(!valid_dma_direction(dir));
 
115
        ents = or1k_map_sg(dev, sg, nents, dir, NULL);
 
116
        debug_dma_map_sg(dev, sg, nents, ents, dir);
 
117
 
 
118
        return ents;
 
119
}
 
120
 
 
121
static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
 
122
                                      int nents, enum dma_data_direction dir)
 
123
{
 
124
        BUG_ON(!valid_dma_direction(dir));
 
125
        debug_dma_unmap_sg(dev, sg, nents, dir);
 
126
        or1k_unmap_sg(dev, sg, nents, dir, NULL);
 
127
}
 
128
 
 
129
static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
 
130
                                      size_t offset, size_t size,
 
131
                                      enum dma_data_direction dir)
 
132
{
 
133
        dma_addr_t addr;
 
134
 
 
135
        kmemcheck_mark_initialized(page_address(page) + offset, size);
 
136
        BUG_ON(!valid_dma_direction(dir));
 
137
        addr = or1k_map_page(dev, page, offset, size, dir, NULL);
 
138
        debug_dma_map_page(dev, page, offset, size, dir, addr, false);
 
139
 
 
140
        return addr;
 
141
}
 
142
 
 
143
static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
 
144
                                  size_t size, enum dma_data_direction dir)
 
145
{
 
146
        BUG_ON(!valid_dma_direction(dir));
 
147
        or1k_unmap_page(dev, addr, size, dir, NULL);
 
148
        debug_dma_unmap_page(dev, addr, size, dir, true);
 
149
}
 
150
 
 
151
static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
 
152
                                           size_t size,
 
153
                                           enum dma_data_direction dir)
 
154
{
 
155
        BUG_ON(!valid_dma_direction(dir));
 
156
        or1k_sync_single_for_cpu(dev, addr, size, dir);
 
157
        debug_dma_sync_single_for_cpu(dev, addr, size, dir);
 
158
}
 
159
 
 
160
static inline void dma_sync_single_for_device(struct device *dev,
 
161
                                              dma_addr_t addr, size_t size,
 
162
                                              enum dma_data_direction dir)
 
163
{
 
164
        BUG_ON(!valid_dma_direction(dir));
 
165
        or1k_sync_single_for_device(dev, addr, size, dir);
 
166
        debug_dma_sync_single_for_device(dev, addr, size, dir);
 
167
}
 
168
 
 
169
static inline int dma_supported(struct device *dev, u64 dma_mask)
 
170
{
 
171
        /* Support 32 bit DMA mask exclusively */
 
172
        return dma_mask == DMA_BIT_MASK(32);
 
173
}
 
174
 
 
175
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 
176
{
 
177
        return 0;
 
178
}
 
179
 
 
180
static inline int dma_set_mask(struct device *dev, u64 dma_mask)
 
181
{
 
182
        if (!dev->dma_mask || !dma_supported(dev, dma_mask))
 
183
                return -EIO;
 
184
 
 
185
        *dev->dma_mask = dma_mask;
 
186
 
 
187
        return 0;
 
188
}
 
189
#endif  /* __ASM_OPENRISC_DMA_MAPPING_H */