]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 | 2 | /* |
1da177e4 LT |
3 | * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> |
4 | * Martin Schwidefsky <schwidefsky@de.ibm.com> | |
5 | * Bugreports.to..: <Linux390@de.ibm.com> | |
a53c8fab HC |
6 | * Copyright IBM Corp. 2000 |
7 | * | |
1da177e4 LT |
8 | * History of changes |
9 | * 07/24/00 new file | |
10 | * 05/04/02 code restructuring. | |
11 | */ | |
12 | ||
13 | #ifndef _S390_IDALS_H | |
14 | #define _S390_IDALS_H | |
15 | ||
1da177e4 LT |
16 | #include <linux/errno.h> |
17 | #include <linux/err.h> | |
18 | #include <linux/types.h> | |
19 | #include <linux/slab.h> | |
20 | #include <asm/cio.h> | |
7c0f6ba6 | 21 | #include <linux/uaccess.h> |
1da177e4 | 22 | |
1da177e4 | 23 | #define IDA_SIZE_LOG 12 /* 11 for 2k , 12 for 4k */ |
1da177e4 LT |
24 | #define IDA_BLOCK_SIZE (1L<<IDA_SIZE_LOG) |
25 | ||
26 | /* | |
27 | * Test if an address/length pair needs an idal list. | |
28 | */ | |
29 | static inline int | |
30 | idal_is_needed(void *vaddr, unsigned int length) | |
31 | { | |
1da177e4 | 32 | return ((__pa(vaddr) + length - 1) >> 31) != 0; |
1da177e4 LT |
33 | } |
34 | ||
35 | ||
36 | /* | |
37 | * Return the number of idal words needed for an address/length pair. | |
38 | */ | |
f3eb5384 | 39 | static inline unsigned int idal_nr_words(void *vaddr, unsigned int length) |
1da177e4 | 40 | { |
f3eb5384 SW |
41 | return ((__pa(vaddr) & (IDA_BLOCK_SIZE-1)) + length + |
42 | (IDA_BLOCK_SIZE-1)) >> IDA_SIZE_LOG; | |
1da177e4 LT |
43 | } |
44 | ||
45 | /* | |
46 | * Create the list of idal words for an address/length pair. | |
47 | */ | |
f3eb5384 SW |
48 | static inline unsigned long *idal_create_words(unsigned long *idaws, |
49 | void *vaddr, unsigned int length) | |
1da177e4 | 50 | { |
1da177e4 LT |
51 | unsigned long paddr; |
52 | unsigned int cidaw; | |
53 | ||
54 | paddr = __pa(vaddr); | |
55 | cidaw = ((paddr & (IDA_BLOCK_SIZE-1)) + length + | |
56 | (IDA_BLOCK_SIZE-1)) >> IDA_SIZE_LOG; | |
57 | *idaws++ = paddr; | |
58 | paddr &= -IDA_BLOCK_SIZE; | |
59 | while (--cidaw > 0) { | |
60 | paddr += IDA_BLOCK_SIZE; | |
61 | *idaws++ = paddr; | |
62 | } | |
1da177e4 LT |
63 | return idaws; |
64 | } | |
65 | ||
66 | /* | |
67 | * Sets the address of the data in CCW. | |
68 | * If necessary it allocates an IDAL and sets the appropriate flags. | |
69 | */ | |
70 | static inline int | |
71 | set_normalized_cda(struct ccw1 * ccw, void *vaddr) | |
72 | { | |
1da177e4 LT |
73 | unsigned int nridaws; |
74 | unsigned long *idal; | |
75 | ||
76 | if (ccw->flags & CCW_FLAG_IDA) | |
77 | return -EINVAL; | |
78 | nridaws = idal_nr_words(vaddr, ccw->count); | |
79 | if (nridaws > 0) { | |
80 | idal = kmalloc(nridaws * sizeof(unsigned long), | |
81 | GFP_ATOMIC | GFP_DMA ); | |
82 | if (idal == NULL) | |
83 | return -ENOMEM; | |
84 | idal_create_words(idal, vaddr, ccw->count); | |
85 | ccw->flags |= CCW_FLAG_IDA; | |
86 | vaddr = idal; | |
87 | } | |
1da177e4 LT |
88 | ccw->cda = (__u32)(unsigned long) vaddr; |
89 | return 0; | |
90 | } | |
91 | ||
92 | /* | |
93 | * Releases any allocated IDAL related to the CCW. | |
94 | */ | |
95 | static inline void | |
96 | clear_normalized_cda(struct ccw1 * ccw) | |
97 | { | |
1da177e4 LT |
98 | if (ccw->flags & CCW_FLAG_IDA) { |
99 | kfree((void *)(unsigned long) ccw->cda); | |
100 | ccw->flags &= ~CCW_FLAG_IDA; | |
101 | } | |
1da177e4 LT |
102 | ccw->cda = 0; |
103 | } | |
104 | ||
105 | /* | |
106 | * Idal buffer extension | |
107 | */ | |
108 | struct idal_buffer { | |
109 | size_t size; | |
110 | size_t page_order; | |
111 | void *data[0]; | |
112 | }; | |
113 | ||
114 | /* | |
115 | * Allocate an idal buffer | |
116 | */ | |
117 | static inline struct idal_buffer * | |
118 | idal_buffer_alloc(size_t size, int page_order) | |
119 | { | |
120 | struct idal_buffer *ib; | |
121 | int nr_chunks, nr_ptrs, i; | |
122 | ||
123 | nr_ptrs = (size + IDA_BLOCK_SIZE - 1) >> IDA_SIZE_LOG; | |
124 | nr_chunks = (4096 << page_order) >> IDA_SIZE_LOG; | |
125 | ib = kmalloc(sizeof(struct idal_buffer) + nr_ptrs*sizeof(void *), | |
126 | GFP_DMA | GFP_KERNEL); | |
127 | if (ib == NULL) | |
128 | return ERR_PTR(-ENOMEM); | |
129 | ib->size = size; | |
130 | ib->page_order = page_order; | |
131 | for (i = 0; i < nr_ptrs; i++) { | |
132 | if ((i & (nr_chunks - 1)) != 0) { | |
133 | ib->data[i] = ib->data[i-1] + IDA_BLOCK_SIZE; | |
134 | continue; | |
135 | } | |
136 | ib->data[i] = (void *) | |
137 | __get_free_pages(GFP_KERNEL, page_order); | |
138 | if (ib->data[i] != NULL) | |
139 | continue; | |
140 | // Not enough memory | |
141 | while (i >= nr_chunks) { | |
142 | i -= nr_chunks; | |
143 | free_pages((unsigned long) ib->data[i], | |
144 | ib->page_order); | |
145 | } | |
146 | kfree(ib); | |
147 | return ERR_PTR(-ENOMEM); | |
148 | } | |
149 | return ib; | |
150 | } | |
151 | ||
152 | /* | |
153 | * Free an idal buffer. | |
154 | */ | |
155 | static inline void | |
156 | idal_buffer_free(struct idal_buffer *ib) | |
157 | { | |
158 | int nr_chunks, nr_ptrs, i; | |
159 | ||
160 | nr_ptrs = (ib->size + IDA_BLOCK_SIZE - 1) >> IDA_SIZE_LOG; | |
161 | nr_chunks = (4096 << ib->page_order) >> IDA_SIZE_LOG; | |
162 | for (i = 0; i < nr_ptrs; i += nr_chunks) | |
163 | free_pages((unsigned long) ib->data[i], ib->page_order); | |
164 | kfree(ib); | |
165 | } | |
166 | ||
167 | /* | |
168 | * Test if a idal list is really needed. | |
169 | */ | |
170 | static inline int | |
171 | __idal_buffer_is_needed(struct idal_buffer *ib) | |
172 | { | |
1da177e4 LT |
173 | return ib->size > (4096ul << ib->page_order) || |
174 | idal_is_needed(ib->data[0], ib->size); | |
1da177e4 LT |
175 | } |
176 | ||
177 | /* | |
178 | * Set channel data address to idal buffer. | |
179 | */ | |
180 | static inline void | |
181 | idal_buffer_set_cda(struct idal_buffer *ib, struct ccw1 *ccw) | |
182 | { | |
183 | if (__idal_buffer_is_needed(ib)) { | |
184 | // setup idals; | |
185 | ccw->cda = (u32)(addr_t) ib->data; | |
186 | ccw->flags |= CCW_FLAG_IDA; | |
187 | } else | |
188 | // we do not need idals - use direct addressing | |
189 | ccw->cda = (u32)(addr_t) ib->data[0]; | |
190 | ccw->count = ib->size; | |
191 | } | |
192 | ||
193 | /* | |
194 | * Copy count bytes from an idal buffer to user memory | |
195 | */ | |
196 | static inline size_t | |
197 | idal_buffer_to_user(struct idal_buffer *ib, void __user *to, size_t count) | |
198 | { | |
199 | size_t left; | |
200 | int i; | |
201 | ||
202 | BUG_ON(count > ib->size); | |
203 | for (i = 0; count > IDA_BLOCK_SIZE; i++) { | |
204 | left = copy_to_user(to, ib->data[i], IDA_BLOCK_SIZE); | |
205 | if (left) | |
206 | return left + count - IDA_BLOCK_SIZE; | |
207 | to = (void __user *) to + IDA_BLOCK_SIZE; | |
208 | count -= IDA_BLOCK_SIZE; | |
209 | } | |
210 | return copy_to_user(to, ib->data[i], count); | |
211 | } | |
212 | ||
213 | /* | |
214 | * Copy count bytes from user memory to an idal buffer | |
215 | */ | |
216 | static inline size_t | |
217 | idal_buffer_from_user(struct idal_buffer *ib, const void __user *from, size_t count) | |
218 | { | |
219 | size_t left; | |
220 | int i; | |
221 | ||
222 | BUG_ON(count > ib->size); | |
223 | for (i = 0; count > IDA_BLOCK_SIZE; i++) { | |
224 | left = copy_from_user(ib->data[i], from, IDA_BLOCK_SIZE); | |
225 | if (left) | |
226 | return left + count - IDA_BLOCK_SIZE; | |
227 | from = (void __user *) from + IDA_BLOCK_SIZE; | |
228 | count -= IDA_BLOCK_SIZE; | |
229 | } | |
230 | return copy_from_user(ib->data[i], from, count); | |
231 | } | |
232 | ||
233 | #endif |