Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://openrisc.net/~jonas/linux
* 'for-linus' of git://openrisc.net/~jonas/linux:
Add missing DMA ops
openrisc: don't use pt_regs in struct sigcontext
+96
-27
+57
-2
arch/openrisc/include/asm/dma-mapping.h
+57
-2
arch/openrisc/include/asm/dma-mapping.h
···
31
31
32
32
#define DMA_ERROR_CODE (~(dma_addr_t)0x0)
33
33
34
-
int dma_mapping_error(struct device *dev, dma_addr_t dma_addr);
35
34
36
35
#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
37
36
#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
···
46
47
void or1k_unmap_page(struct device *dev, dma_addr_t dma_handle,
47
48
size_t size, enum dma_data_direction dir,
48
49
struct dma_attrs *attrs);
50
+
int or1k_map_sg(struct device *dev, struct scatterlist *sg,
51
+
int nents, enum dma_data_direction dir,
52
+
struct dma_attrs *attrs);
53
+
void or1k_unmap_sg(struct device *dev, struct scatterlist *sg,
54
+
int nents, enum dma_data_direction dir,
55
+
struct dma_attrs *attrs);
49
56
void or1k_sync_single_for_cpu(struct device *dev,
50
57
dma_addr_t dma_handle, size_t size,
51
58
enum dma_data_direction dir);
···
103
98
debug_dma_unmap_page(dev, addr, size, dir, true);
104
99
}
105
100
101
+
static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
102
+
int nents, enum dma_data_direction dir)
103
+
{
104
+
int i, ents;
105
+
struct scatterlist *s;
106
+
107
+
for_each_sg(sg, s, nents, i)
108
+
kmemcheck_mark_initialized(sg_virt(s), s->length);
109
+
BUG_ON(!valid_dma_direction(dir));
110
+
ents = or1k_map_sg(dev, sg, nents, dir, NULL);
111
+
debug_dma_map_sg(dev, sg, nents, ents, dir);
112
+
113
+
return ents;
114
+
}
115
+
116
+
static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
117
+
int nents, enum dma_data_direction dir)
118
+
{
119
+
BUG_ON(!valid_dma_direction(dir));
120
+
debug_dma_unmap_sg(dev, sg, nents, dir);
121
+
or1k_unmap_sg(dev, sg, nents, dir, NULL);
122
+
}
123
+
124
+
static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
125
+
size_t offset, size_t size,
126
+
enum dma_data_direction dir)
127
+
{
128
+
dma_addr_t addr;
129
+
130
+
kmemcheck_mark_initialized(page_address(page) + offset, size);
131
+
BUG_ON(!valid_dma_direction(dir));
132
+
addr = or1k_map_page(dev, page, offset, size, dir, NULL);
133
+
debug_dma_map_page(dev, page, offset, size, dir, addr, false);
134
+
135
+
return addr;
136
+
}
137
+
138
+
static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
139
+
size_t size, enum dma_data_direction dir)
140
+
{
141
+
BUG_ON(!valid_dma_direction(dir));
142
+
or1k_unmap_page(dev, addr, size, dir, NULL);
143
+
debug_dma_unmap_page(dev, addr, size, dir, true);
144
+
}
145
+
106
146
static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
107
147
size_t size,
108
148
enum dma_data_direction dir)
···
169
119
static inline int dma_supported(struct device *dev, u64 dma_mask)
170
120
{
171
121
/* Support 32 bit DMA mask exclusively */
172
-
return dma_mask == 0xffffffffULL;
122
+
return dma_mask == DMA_BIT_MASK(32);
123
+
}
124
+
125
+
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
126
+
{
127
+
return 0;
173
128
}
174
129
175
130
static inline int dma_set_mask(struct device *dev, u64 dma_mask)
+1
-6
arch/openrisc/include/asm/sigcontext.h
+1
-6
arch/openrisc/include/asm/sigcontext.h
···
23
23
24
24
/* This struct is saved by setup_frame in signal.c, to keep the current
25
25
context while a signal handler is executed. It's restored by sys_sigreturn.
26
-
27
-
To keep things simple, we use pt_regs here even though normally you just
28
-
specify the list of regs to save. Then we can use copy_from_user on the
29
-
entire regs instead of a bunch of get_user's as well...
30
26
*/
31
27
32
28
struct sigcontext {
33
-
struct pt_regs regs; /* needs to be first */
29
+
struct user_regs_struct regs; /* needs to be first */
34
30
unsigned long oldmask;
35
-
unsigned long usp; /* usp before stacking this gunk on it */
36
31
};
37
32
38
33
#endif /* __ASM_OPENRISC_SIGCONTEXT_H */
+27
-1
arch/openrisc/kernel/dma.c
+27
-1
arch/openrisc/kernel/dma.c
···
154
154
/* Nothing special to do here... */
155
155
}
156
156
157
+
int or1k_map_sg(struct device *dev, struct scatterlist *sg,
158
+
int nents, enum dma_data_direction dir,
159
+
struct dma_attrs *attrs)
160
+
{
161
+
struct scatterlist *s;
162
+
int i;
163
+
164
+
for_each_sg(sg, s, nents, i) {
165
+
s->dma_address = or1k_map_page(dev, sg_page(s), s->offset,
166
+
s->length, dir, NULL);
167
+
}
168
+
169
+
return nents;
170
+
}
171
+
172
+
void or1k_unmap_sg(struct device *dev, struct scatterlist *sg,
173
+
int nents, enum dma_data_direction dir,
174
+
struct dma_attrs *attrs)
175
+
{
176
+
struct scatterlist *s;
177
+
int i;
178
+
179
+
for_each_sg(sg, s, nents, i) {
180
+
or1k_unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, NULL);
181
+
}
182
+
}
183
+
157
184
void or1k_sync_single_for_cpu(struct device *dev,
158
185
dma_addr_t dma_handle, size_t size,
159
186
enum dma_data_direction dir)
···
214
187
215
188
return 0;
216
189
}
217
-
218
190
fs_initcall(dma_init);
+11
-18
arch/openrisc/kernel/signal.c
+11
-18
arch/openrisc/kernel/signal.c
···
52
52
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
53
53
{
54
54
unsigned int err = 0;
55
-
unsigned long old_usp;
56
55
57
56
/* Alwys make any pending restarted system call return -EINTR */
58
57
current_thread_info()->restart_block.fn = do_no_restart_syscall;
59
58
60
-
/* restore the regs from &sc->regs (same as sc, since regs is first)
59
+
/*
60
+
* Restore the regs from &sc->regs.
61
61
* (sc is already checked for VERIFY_READ since the sigframe was
62
62
* checked in sys_sigreturn previously)
63
63
*/
64
-
65
-
if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))
64
+
if (__copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long)))
65
+
goto badframe;
66
+
if (__copy_from_user(®s->pc, &sc->regs.pc, sizeof(unsigned long)))
67
+
goto badframe;
68
+
if (__copy_from_user(®s->sr, &sc->regs.sr, sizeof(unsigned long)))
66
69
goto badframe;
67
70
68
71
/* make sure the SM-bit is cleared so user-mode cannot fool us */
69
72
regs->sr &= ~SPR_SR_SM;
70
-
71
-
/* restore the old USP as it was before we stacked the sc etc.
72
-
* (we cannot just pop the sigcontext since we aligned the sp and
73
-
* stuff after pushing it)
74
-
*/
75
-
76
-
err |= __get_user(old_usp, &sc->usp);
77
-
78
-
regs->sp = old_usp;
79
73
80
74
/* TODO: the other ports use regs->orig_XX to disable syscall checks
81
75
* after this completes, but we don't use that mechanism. maybe we can
···
131
137
unsigned long mask)
132
138
{
133
139
int err = 0;
134
-
unsigned long usp = regs->sp;
135
140
136
-
/* copy the regs. they are first in sc so we can use sc directly */
141
+
/* copy the regs */
137
142
138
-
err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));
143
+
err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long));
144
+
err |= __copy_to_user(&sc->regs.pc, ®s->pc, sizeof(unsigned long));
145
+
err |= __copy_to_user(&sc->regs.sr, ®s->sr, sizeof(unsigned long));
139
146
140
147
/* then some other stuff */
141
148
142
149
err |= __put_user(mask, &sc->oldmask);
143
-
144
-
err |= __put_user(usp, &sc->usp);
145
150
146
151
return err;
147
152
}