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