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  */
tcw_get_intrg(struct tcw * tcw)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  */
tcw_get_data(struct tcw * tcw)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  */
tcw_get_tccb(struct tcw * tcw)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  */
tcw_get_tsb(struct tcw * tcw)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  */
tcw_init(struct tcw * tcw,int r,int w)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 
tca_size(struct tccb * tccb)94 static inline size_t tca_size(struct tccb *tccb)
95 {
96 	return tccb->tcah.tcal - 12;
97 }
98 
calc_dcw_count(struct tccb * tccb)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 
calc_cbc_size(struct tidaw * tidaw,int num)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  */
tcw_finalize(struct tcw * tcw,int num_tidaws)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  */
tcw_set_intrg(struct tcw * tcw,struct tcw * intrg_tcw)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  */
tcw_set_data(struct tcw * tcw,void * data,int use_tidal)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  */
tcw_set_tccb(struct tcw * tcw,struct tccb * tccb)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  */
tcw_set_tsb(struct tcw * tcw,struct tsb * tsb)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  */
tccb_init(struct tccb * tccb,size_t size,u32 sac)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  */
tsb_init(struct tsb * tsb)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  */
tccb_add_dcw(struct tccb * tccb,size_t tccb_size,u8 cmd,u8 flags,void * cd,u8 cd_count,u32 count)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  */
tcw_add_tidaw(struct tcw * tcw,int num_tidaws,u8 flags,void * addr,u32 count)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);
352