1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Functions for incremental construction of fcx enabled I/O control blocks.
4 *
5 * Copyright IBM Corp. 2008
6 * Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
7 */
8
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/string.h>
12 #include <linux/errno.h>
13 #include <linux/err.h>
14 #include <linux/module.h>
15 #include <asm/fcx.h>
16 #include <asm/itcw.h>
17
18 /*
19 * struct itcw - incremental tcw helper data type
20 *
21 * This structure serves as a handle for the incremental construction of a
22 * tcw and associated tccb, tsb, data tidaw-list plus an optional interrogate
23 * tcw and associated data. The data structures are contained inside a single
24 * contiguous buffer provided by the user.
25 *
26 * The itcw construction functions take care of overall data integrity:
27 * - reset unused fields to zero
28 * - fill in required pointers
29 * - ensure required alignment for data structures
30 * - prevent data structures to cross 4k-byte boundary where required
31 * - calculate tccb-related length fields
32 * - optionally provide ready-made interrogate tcw and associated structures
33 *
34 * Restrictions apply to the itcws created with these construction functions:
35 * - tida only supported for data address, not for tccb
36 * - only contiguous tidaw-lists (no ttic)
37 * - total number of bytes required per itcw may not exceed 4k bytes
38 * - either read or write operation (may not work with r=0 and w=0)
39 *
40 * Example:
41 * struct itcw *itcw;
42 * void *buffer;
43 * size_t size;
44 *
45 * size = itcw_calc_size(1, 2, 0);
46 * buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
47 * if (!buffer)
48 * return -ENOMEM;
49 * itcw = itcw_init(buffer, size, ITCW_OP_READ, 1, 2, 0);
50 * if (IS_ERR(itcw))
51 * return PTR_ER(itcw);
52 * itcw_add_dcw(itcw, 0x2, 0, NULL, 0, 72);
53 * itcw_add_tidaw(itcw, 0, 0x30000, 20);
54 * itcw_add_tidaw(itcw, 0, 0x40000, 52);
55 * itcw_finalize(itcw);
56 *
57 */
58 struct itcw {
59 struct tcw *tcw;
60 struct tcw *intrg_tcw;
61 int num_tidaws;
62 int max_tidaws;
63 int intrg_num_tidaws;
64 int intrg_max_tidaws;
65 };
66
67 /**
68 * itcw_get_tcw - return pointer to tcw associated with the itcw
69 * @itcw: address of the itcw
70 *
71 * Return pointer to the tcw associated with the itcw.
72 */
73 struct tcw *itcw_get_tcw(struct itcw *itcw)
74 {
75 return itcw->tcw;
76 }
77 EXPORT_SYMBOL(itcw_get_tcw);
78
79 /**
80 * itcw_calc_size - return the size of an itcw with the given parameters
81 * @intrg: if non-zero, add an interrogate tcw
82 * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
83 * if no tida is to be used.
84 * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
85 * by the interrogate tcw, if specified
86 *
87 * Calculate and return the number of bytes required to hold an itcw with the
88 * given parameters and assuming tccbs with maximum size.
89 *
90 * Note that the resulting size also contains bytes needed for alignment
91 * padding as well as padding to ensure that data structures don't cross a
92 * 4k-boundary where required.
93 */
94 size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)
95 {
96 size_t len;
97 int cross_count;
98
99 /* Main data. */
100 len = sizeof(struct itcw);
101 len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
102 /* TSB */ sizeof(struct tsb) +
103 /* TIDAL */ max_tidaws * sizeof(struct tidaw);
104 /* Interrogate data. */
105 if (intrg) {
106 len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
107 /* TSB */ sizeof(struct tsb) +
108 /* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw);
109 }
110
111 /* Maximum required alignment padding. */
112 len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7;
113
114 /* TIDAW lists may not cross a 4k boundary. To cross a
115 * boundary we need to add a TTIC TIDAW. We need to reserve
116 * one additional TIDAW for a TTIC that we may need to add due
117 * to the placement of the data chunk in memory, and a further
118 * TIDAW for each page boundary that the TIDAW list may cross
119 * due to it's own size.
120 */
121 if (max_tidaws) {
122 cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
123 >> PAGE_SHIFT);
124 len += cross_count * sizeof(struct tidaw);
125 }
126 if (intrg_max_tidaws) {
127 cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
128 >> PAGE_SHIFT);
129 len += cross_count * sizeof(struct tidaw);
130 }
131 return len;
132 }
133 EXPORT_SYMBOL(itcw_calc_size);
134
135 #define CROSS4K(x, l) (((x) & ~4095) != ((x + l) & ~4095))
136
137 static inline void *fit_chunk(addr_t *start, addr_t end, size_t len,
138 int align, int check_4k)
139 {
140 addr_t addr;
141
142 addr = ALIGN(*start, align);
143 if (check_4k && CROSS4K(addr, len)) {
144 addr = ALIGN(addr, 4096);
145 addr = ALIGN(addr, align);
146 }
147 if (addr + len > end)
148 return ERR_PTR(-ENOSPC);
149 *start = addr + len;
150 return (void *) addr;
151 }
152
153 /**
154 * itcw_init - initialize incremental tcw data structure
155 * @buffer: address of buffer to use for data structures
156 * @size: number of bytes in buffer
157 * @op: %ITCW_OP_READ for a read operation tcw, %ITCW_OP_WRITE for a write
158 * operation tcw
159 * @intrg: if non-zero, add and initialize an interrogate tcw
160 * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
161 * if no tida is to be used.
162 * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
163 * by the interrogate tcw, if specified
164 *
165 * Prepare the specified buffer to be used as an incremental tcw, i.e. a
166 * helper data structure that can be used to construct a valid tcw by
167 * successive calls to other helper functions. Note: the buffer needs to be
168 * located below the 2G address limit. The resulting tcw has the following
169 * restrictions:
170 * - no tccb tidal
171 * - input/output tidal is contiguous (no ttic)
172 * - total data should not exceed 4k
173 * - tcw specifies either read or write operation
174 *
175 * On success, return pointer to the resulting incremental tcw data structure,
176 * ERR_PTR otherwise.
177 */
178 struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
179 int max_tidaws, int intrg_max_tidaws)
180 {
181 struct itcw *itcw;
182 void *chunk;
183 addr_t start;
184 addr_t end;
185 int cross_count;
186
187 /* Check for 2G limit. */
188 start = (addr_t) buffer;
189 end = start + size;
190 if (end > (1 << 31))
191 return ERR_PTR(-EINVAL);
192 memset(buffer, 0, size);
193 /* ITCW. */
194 chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0);
195 if (IS_ERR(chunk))
196 return chunk;
197 itcw = chunk;
198 /* allow for TTIC tidaws that may be needed to cross a page boundary */
199 cross_count = 0;
200 if (max_tidaws)
201 cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
202 >> PAGE_SHIFT);
203 itcw->max_tidaws = max_tidaws + cross_count;
204 cross_count = 0;
205 if (intrg_max_tidaws)
206 cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
207 >> PAGE_SHIFT);
208 itcw->intrg_max_tidaws = intrg_max_tidaws + cross_count;
209 /* Main TCW. */
210 chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
211 if (IS_ERR(chunk))
212 return chunk;
213 itcw->tcw = chunk;
214 tcw_init(itcw->tcw, (op == ITCW_OP_READ) ? 1 : 0,
215 (op == ITCW_OP_WRITE) ? 1 : 0);
216 /* Interrogate TCW. */
217 if (intrg) {
218 chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
219 if (IS_ERR(chunk))
220 return chunk;
221 itcw->intrg_tcw = chunk;
222 tcw_init(itcw->intrg_tcw, 1, 0);
223 tcw_set_intrg(itcw->tcw, itcw->intrg_tcw);
224 }
225 /* Data TIDAL. */
226 if (max_tidaws > 0) {
227 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
228 itcw->max_tidaws, 16, 0);
229 if (IS_ERR(chunk))
230 return chunk;
231 tcw_set_data(itcw->tcw, chunk, 1);
232 }
233 /* Interrogate data TIDAL. */
234 if (intrg && (intrg_max_tidaws > 0)) {
235 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
236 itcw->intrg_max_tidaws, 16, 0);
237 if (IS_ERR(chunk))
238 return chunk;
239 tcw_set_data(itcw->intrg_tcw, chunk, 1);
240 }
241 /* TSB. */
242 chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
243 if (IS_ERR(chunk))
244 return chunk;
245 tsb_init(chunk);
246 tcw_set_tsb(itcw->tcw, chunk);
247 /* Interrogate TSB. */
248 if (intrg) {
249 chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
250 if (IS_ERR(chunk))
251 return chunk;
252 tsb_init(chunk);
253 tcw_set_tsb(itcw->intrg_tcw, chunk);
254 }
255 /* TCCB. */
256 chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
257 if (IS_ERR(chunk))
258 return chunk;
259 tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT);
260 tcw_set_tccb(itcw->tcw, chunk);
261 /* Interrogate TCCB. */
262 if (intrg) {
263 chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
264 if (IS_ERR(chunk))
265 return chunk;
266 tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG);
267 tcw_set_tccb(itcw->intrg_tcw, chunk);
268 tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL,
269 sizeof(struct dcw_intrg_data), 0);
270 tcw_finalize(itcw->intrg_tcw, 0);
271 }
272 return itcw;
273 }
274 EXPORT_SYMBOL(itcw_init);
275
276 /**
277 * itcw_add_dcw - add a dcw to the itcw
278 * @itcw: address of the itcw
279 * @cmd: the dcw command
280 * @flags: flags for the dcw
281 * @cd: address of control data for this dcw or NULL if none is required
282 * @cd_count: number of control data bytes for this dcw
283 * @count: number of data bytes for this dcw
284 *
285 * Add a new dcw to the specified itcw by writing the dcw information specified
286 * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
287 * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
288 * would exceed the available space.
289 *
290 * Note: the tcal field of the tccb header will be updated to reflect added
291 * content.
292 */
293 struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd,
294 u8 cd_count, u32 count)
295 {
296 return tccb_add_dcw(tcw_get_tccb(itcw->tcw), TCCB_MAX_SIZE, cmd,
297 flags, cd, cd_count, count);
298 }
299 EXPORT_SYMBOL(itcw_add_dcw);
300
301 /**
302 * itcw_add_tidaw - add a tidaw to the itcw
303 * @itcw: address of the itcw
304 * @flags: flags for the new tidaw
305 * @addr: address value for the new tidaw
306 * @count: count value for the new tidaw
307 *
308 * Add a new tidaw to the input/output data tidaw-list of the specified itcw
309 * (depending on the value of the r-flag and w-flag). Return a pointer to
310 * the new tidaw on success or -%ENOSPC if the new tidaw would exceed the
311 * available space.
312 *
313 * Note: TTIC tidaws are automatically added when needed, so explicitly calling
314 * this interface with the TTIC flag is not supported. The last-tidaw flag
315 * for the last tidaw in the list will be set by itcw_finalize.
316 */
317 struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count)
318 {
319 struct tidaw *following;
320
321 if (itcw->num_tidaws >= itcw->max_tidaws)
322 return ERR_PTR(-ENOSPC);
323 /*
324 * Is the tidaw, which follows the one we are about to fill, on the next
325 * page? Then we have to insert a TTIC tidaw first, that points to the
326 * tidaw on the new page.
327 */
328 following = ((struct tidaw *) tcw_get_data(itcw->tcw))
329 + itcw->num_tidaws + 1;
330 if (itcw->num_tidaws && !((unsigned long) following & ~PAGE_MASK)) {
331 tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++,
332 TIDAW_FLAGS_TTIC, following, 0);
333 if (itcw->num_tidaws >= itcw->max_tidaws)
334 return ERR_PTR(-ENOSPC);
335 }
336 return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count);
337 }
338 EXPORT_SYMBOL(itcw_add_tidaw);
339
340 /**
341 * itcw_set_data - set data address and tida flag of the itcw
342 * @itcw: address of the itcw
343 * @addr: the data address
344 * @use_tidal: zero of the data address specifies a contiguous block of data,
345 * non-zero if it specifies a list if tidaws.
346 *
347 * Set the input/output data address of the itcw (depending on the value of the
348 * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
349 * is set as well.
350 */
351 void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal)
352 {
353 tcw_set_data(itcw->tcw, addr, use_tidal);
354 }
355 EXPORT_SYMBOL(itcw_set_data);
356
357 /**
358 * itcw_finalize - calculate length and count fields of the itcw
359 * @itcw: address of the itcw
360 *
361 * Calculate tcw input-/output-count and tccbl fields and add a tcat the tccb.
362 * In case input- or output-tida is used, the tidaw-list must be stored in
363 * continuous storage (no ttic). The tcal field in the tccb must be
364 * up-to-date.
365 */
366 void itcw_finalize(struct itcw *itcw)
367 {
368 tcw_finalize(itcw->tcw, itcw->num_tidaws);
369 }
370 EXPORT_SYMBOL(itcw_finalize);