1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Functions for assembling 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 "cio.h"
17
18 /**
19 * tcw_get_intrg - return pointer to associated interrogate tcw
20 * @tcw: pointer to the original tcw
21 *
22 * Return a pointer to the interrogate tcw associated with the specified tcw
23 * or %NULL if there is no associated interrogate tcw.
24 */
25 struct tcw *tcw_get_intrg(struct tcw *tcw)
26 {
27 return (struct tcw *) ((addr_t) tcw->intrg);
28 }
29 EXPORT_SYMBOL(tcw_get_intrg);
30
31 /**
32 * tcw_get_data - return pointer to input/output data associated with tcw
33 * @tcw: pointer to the tcw
34 *
35 * Return the input or output data address specified in the tcw depending
36 * on whether the r-bit or the w-bit is set. If neither bit is set, return
37 * %NULL.
38 */
39 void *tcw_get_data(struct tcw *tcw)
40 {
41 if (tcw->r)
42 return (void *) ((addr_t) tcw->input);
43 if (tcw->w)
44 return (void *) ((addr_t) tcw->output);
45 return NULL;
46 }
47 EXPORT_SYMBOL(tcw_get_data);
48
49 /**
50 * tcw_get_tccb - return pointer to tccb associated with tcw
51 * @tcw: pointer to the tcw
52 *
53 * Return pointer to the tccb associated with this tcw.
54 */
55 struct tccb *tcw_get_tccb(struct tcw *tcw)
56 {
57 return (struct tccb *) ((addr_t) tcw->tccb);
58 }
59 EXPORT_SYMBOL(tcw_get_tccb);
60
61 /**
62 * tcw_get_tsb - return pointer to tsb associated with tcw
63 * @tcw: pointer to the tcw
64 *
65 * Return pointer to the tsb associated with this tcw.
66 */
67 struct tsb *tcw_get_tsb(struct tcw *tcw)
68 {
69 return (struct tsb *) ((addr_t) tcw->tsb);
70 }
71 EXPORT_SYMBOL(tcw_get_tsb);
72
73 /**
74 * tcw_init - initialize tcw data structure
75 * @tcw: pointer to the tcw to be initialized
76 * @r: initial value of the r-bit
77 * @w: initial value of the w-bit
78 *
79 * Initialize all fields of the specified tcw data structure with zero and
80 * fill in the format, flags, r and w fields.
81 */
82 void tcw_init(struct tcw *tcw, int r, int w)
83 {
84 memset(tcw, 0, sizeof(struct tcw));
85 tcw->format = TCW_FORMAT_DEFAULT;
86 tcw->flags = TCW_FLAGS_TIDAW_FORMAT(TCW_TIDAW_FORMAT_DEFAULT);
87 if (r)
88 tcw->r = 1;
89 if (w)
90 tcw->w = 1;
91 }
92 EXPORT_SYMBOL(tcw_init);
93
94 static inline size_t tca_size(struct tccb *tccb)
95 {
96 return tccb->tcah.tcal - 12;
97 }
98
99 static u32 calc_dcw_count(struct tccb *tccb)
100 {
101 int offset;
102 struct dcw *dcw;
103 u32 count = 0;
104 size_t size;
105
106 size = tca_size(tccb);
107 for (offset = 0; offset < size;) {
108 dcw = (struct dcw *) &tccb->tca[offset];
109 count += dcw->count;
110 if (!(dcw->flags & DCW_FLAGS_CC))
111 break;
112 offset += sizeof(struct dcw) + ALIGN((int) dcw->cd_count, 4);
113 }
114 return count;
115 }
116
117 static u32 calc_cbc_size(struct tidaw *tidaw, int num)
118 {
119 int i;
120 u32 cbc_data;
121 u32 cbc_count = 0;
122 u64 data_count = 0;
123
124 for (i = 0; i < num; i++) {
125 if (tidaw[i].flags & TIDAW_FLAGS_LAST)
126 break;
127 /* TODO: find out if padding applies to total of data
128 * transferred or data transferred by this tidaw. Assumption:
129 * applies to total. */
130 data_count += tidaw[i].count;
131 if (tidaw[i].flags & TIDAW_FLAGS_INSERT_CBC) {
132 cbc_data = 4 + ALIGN(data_count, 4) - data_count;
133 cbc_count += cbc_data;
134 data_count += cbc_data;
135 }
136 }
137 return cbc_count;
138 }
139
140 /**
141 * tcw_finalize - finalize tcw length fields and tidaw list
142 * @tcw: pointer to the tcw
143 * @num_tidaws: the number of tidaws used to address input/output data or zero
144 * if no tida is used
145 *
146 * Calculate the input-/output-count and tccbl field in the tcw, add a
147 * tcat the tccb and terminate the data tidaw list if used.
148 *
149 * Note: in case input- or output-tida is used, the tidaw-list must be stored
150 * in contiguous storage (no ttic). The tcal field in the tccb must be
151 * up-to-date.
152 */
153 void tcw_finalize(struct tcw *tcw, int num_tidaws)
154 {
155 struct tidaw *tidaw;
156 struct tccb *tccb;
157 struct tccb_tcat *tcat;
158 u32 count;
159
160 /* Terminate tidaw list. */
161 tidaw = tcw_get_data(tcw);
162 if (num_tidaws > 0)
163 tidaw[num_tidaws - 1].flags |= TIDAW_FLAGS_LAST;
164 /* Add tcat to tccb. */
165 tccb = tcw_get_tccb(tcw);
166 tcat = (struct tccb_tcat *) &tccb->tca[tca_size(tccb)];
167 memset(tcat, 0, sizeof(*tcat));
168 /* Calculate tcw input/output count and tcat transport count. */
169 count = calc_dcw_count(tccb);
170 if (tcw->w && (tcw->flags & TCW_FLAGS_OUTPUT_TIDA))
171 count += calc_cbc_size(tidaw, num_tidaws);
172 if (tcw->r)
173 tcw->input_count = count;
174 else if (tcw->w)
175 tcw->output_count = count;
176 tcat->count = ALIGN(count, 4) + 4;
177 /* Calculate tccbl. */
178 tcw->tccbl = (sizeof(struct tccb) + tca_size(tccb) +
179 sizeof(struct tccb_tcat) - 20) >> 2;
180 }
181 EXPORT_SYMBOL(tcw_finalize);
182
183 /**
184 * tcw_set_intrg - set the interrogate tcw address of a tcw
185 * @tcw: the tcw address
186 * @intrg_tcw: the address of the interrogate tcw
187 *
188 * Set the address of the interrogate tcw in the specified tcw.
189 */
190 void tcw_set_intrg(struct tcw *tcw, struct tcw *intrg_tcw)
191 {
192 tcw->intrg = (u32) ((addr_t) intrg_tcw);
193 }
194 EXPORT_SYMBOL(tcw_set_intrg);
195
196 /**
197 * tcw_set_data - set data address and tida flag of a tcw
198 * @tcw: the tcw address
199 * @data: the data address
200 * @use_tidal: zero of the data address specifies a contiguous block of data,
201 * non-zero if it specifies a list if tidaws.
202 *
203 * Set the input/output data address of a tcw (depending on the value of the
204 * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
205 * is set as well.
206 */
207 void tcw_set_data(struct tcw *tcw, void *data, int use_tidal)
208 {
209 if (tcw->r) {
210 tcw->input = (u64) ((addr_t) data);
211 if (use_tidal)
212 tcw->flags |= TCW_FLAGS_INPUT_TIDA;
213 } else if (tcw->w) {
214 tcw->output = (u64) ((addr_t) data);
215 if (use_tidal)
216 tcw->flags |= TCW_FLAGS_OUTPUT_TIDA;
217 }
218 }
219 EXPORT_SYMBOL(tcw_set_data);
220
221 /**
222 * tcw_set_tccb - set tccb address of a tcw
223 * @tcw: the tcw address
224 * @tccb: the tccb address
225 *
226 * Set the address of the tccb in the specified tcw.
227 */
228 void tcw_set_tccb(struct tcw *tcw, struct tccb *tccb)
229 {
230 tcw->tccb = (u64) ((addr_t) tccb);
231 }
232 EXPORT_SYMBOL(tcw_set_tccb);
233
234 /**
235 * tcw_set_tsb - set tsb address of a tcw
236 * @tcw: the tcw address
237 * @tsb: the tsb address
238 *
239 * Set the address of the tsb in the specified tcw.
240 */
241 void tcw_set_tsb(struct tcw *tcw, struct tsb *tsb)
242 {
243 tcw->tsb = (u64) ((addr_t) tsb);
244 }
245 EXPORT_SYMBOL(tcw_set_tsb);
246
247 /**
248 * tccb_init - initialize tccb
249 * @tccb: the tccb address
250 * @size: the maximum size of the tccb
251 * @sac: the service-action-code to be user
252 *
253 * Initialize the header of the specified tccb by resetting all values to zero
254 * and filling in defaults for format, sac and initial tcal fields.
255 */
256 void tccb_init(struct tccb *tccb, size_t size, u32 sac)
257 {
258 memset(tccb, 0, size);
259 tccb->tcah.format = TCCB_FORMAT_DEFAULT;
260 tccb->tcah.sac = sac;
261 tccb->tcah.tcal = 12;
262 }
263 EXPORT_SYMBOL(tccb_init);
264
265 /**
266 * tsb_init - initialize tsb
267 * @tsb: the tsb address
268 *
269 * Initialize the specified tsb by resetting all values to zero.
270 */
271 void tsb_init(struct tsb *tsb)
272 {
273 memset(tsb, 0, sizeof(*tsb));
274 }
275 EXPORT_SYMBOL(tsb_init);
276
277 /**
278 * tccb_add_dcw - add a dcw to the tccb
279 * @tccb: the tccb address
280 * @tccb_size: the maximum tccb size
281 * @cmd: the dcw command
282 * @flags: flags for the dcw
283 * @cd: pointer to control data for this dcw or NULL if none is required
284 * @cd_count: number of control data bytes for this dcw
285 * @count: number of data bytes for this dcw
286 *
287 * Add a new dcw to the specified tccb by writing the dcw information specified
288 * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
289 * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
290 * would exceed the available space as defined by @tccb_size.
291 *
292 * Note: the tcal field of the tccb header will be updates to reflect added
293 * content.
294 */
295 struct dcw *tccb_add_dcw(struct tccb *tccb, size_t tccb_size, u8 cmd, u8 flags,
296 void *cd, u8 cd_count, u32 count)
297 {
298 struct dcw *dcw;
299 int size;
300 int tca_offset;
301
302 /* Check for space. */
303 tca_offset = tca_size(tccb);
304 size = ALIGN(sizeof(struct dcw) + cd_count, 4);
305 if (sizeof(struct tccb_tcah) + tca_offset + size +
306 sizeof(struct tccb_tcat) > tccb_size)
307 return ERR_PTR(-ENOSPC);
308 /* Add dcw to tca. */
309 dcw = (struct dcw *) &tccb->tca[tca_offset];
310 memset(dcw, 0, size);
311 dcw->cmd = cmd;
312 dcw->flags = flags;
313 dcw->count = count;
314 dcw->cd_count = cd_count;
315 if (cd)
316 memcpy(&dcw->cd[0], cd, cd_count);
317 tccb->tcah.tcal += size;
318 return dcw;
319 }
320 EXPORT_SYMBOL(tccb_add_dcw);
321
322 /**
323 * tcw_add_tidaw - add a tidaw to a tcw
324 * @tcw: the tcw address
325 * @num_tidaws: the current number of tidaws
326 * @flags: flags for the new tidaw
327 * @addr: address value for the new tidaw
328 * @count: count value for the new tidaw
329 *
330 * Add a new tidaw to the input/output data tidaw-list of the specified tcw
331 * (depending on the value of the r-flag and w-flag) and return a pointer to
332 * the new tidaw.
333 *
334 * Note: the tidaw-list is assumed to be contiguous with no ttics. The caller
335 * must ensure that there is enough space for the new tidaw. The last-tidaw
336 * flag for the last tidaw in the list will be set by tcw_finalize.
337 */
338 struct tidaw *tcw_add_tidaw(struct tcw *tcw, int num_tidaws, u8 flags,
339 void *addr, u32 count)
340 {
341 struct tidaw *tidaw;
342
343 /* Add tidaw to tidaw-list. */
344 tidaw = ((struct tidaw *) tcw_get_data(tcw)) + num_tidaws;
345 memset(tidaw, 0, sizeof(struct tidaw));
346 tidaw->flags = flags;
347 tidaw->count = count;
348 tidaw->addr = (u64) ((addr_t) addr);
349 return tidaw;
350 }
351 EXPORT_SYMBOL(tcw_add_tidaw);