2 * Functions for assembling fcx enabled I/O control blocks.
4 * Copyright IBM Corp. 2008
5 * Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
8 #include <linux/kernel.h>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/errno.h>
12 #include <linux/err.h>
13 #include <linux/module.h>
18 * tcw_get_intrg - return pointer to associated interrogate tcw
19 * @tcw: pointer to the original tcw
21 * Return a pointer to the interrogate tcw associated with the specified tcw
22 * or %NULL if there is no associated interrogate tcw.
24 struct tcw
*tcw_get_intrg(struct tcw
*tcw
)
26 return (struct tcw
*) ((addr_t
) tcw
->intrg
);
28 EXPORT_SYMBOL(tcw_get_intrg
);
31 * tcw_get_data - return pointer to input/output data associated with tcw
32 * @tcw: pointer to the tcw
34 * Return the input or output data address specified in the tcw depending
35 * on whether the r-bit or the w-bit is set. If neither bit is set, return
38 void *tcw_get_data(struct tcw
*tcw
)
41 return (void *) ((addr_t
) tcw
->input
);
43 return (void *) ((addr_t
) tcw
->output
);
46 EXPORT_SYMBOL(tcw_get_data
);
49 * tcw_get_tccb - return pointer to tccb associated with tcw
50 * @tcw: pointer to the tcw
52 * Return pointer to the tccb associated with this tcw.
54 struct tccb
*tcw_get_tccb(struct tcw
*tcw
)
56 return (struct tccb
*) ((addr_t
) tcw
->tccb
);
58 EXPORT_SYMBOL(tcw_get_tccb
);
61 * tcw_get_tsb - return pointer to tsb associated with tcw
62 * @tcw: pointer to the tcw
64 * Return pointer to the tsb associated with this tcw.
66 struct tsb
*tcw_get_tsb(struct tcw
*tcw
)
68 return (struct tsb
*) ((addr_t
) tcw
->tsb
);
70 EXPORT_SYMBOL(tcw_get_tsb
);
73 * tcw_init - initialize tcw data structure
74 * @tcw: pointer to the tcw to be initialized
75 * @r: initial value of the r-bit
76 * @w: initial value of the w-bit
78 * Initialize all fields of the specified tcw data structure with zero and
79 * fill in the format, flags, r and w fields.
81 void tcw_init(struct tcw
*tcw
, int r
, int w
)
83 memset(tcw
, 0, sizeof(struct tcw
));
84 tcw
->format
= TCW_FORMAT_DEFAULT
;
85 tcw
->flags
= TCW_FLAGS_TIDAW_FORMAT(TCW_TIDAW_FORMAT_DEFAULT
);
91 EXPORT_SYMBOL(tcw_init
);
93 static inline size_t tca_size(struct tccb
*tccb
)
95 return tccb
->tcah
.tcal
- 12;
98 static u32
calc_dcw_count(struct tccb
*tccb
)
105 size
= tca_size(tccb
);
106 for (offset
= 0; offset
< size
;) {
107 dcw
= (struct dcw
*) &tccb
->tca
[offset
];
109 if (!(dcw
->flags
& DCW_FLAGS_CC
))
111 offset
+= sizeof(struct dcw
) + ALIGN((int) dcw
->cd_count
, 4);
116 static u32
calc_cbc_size(struct tidaw
*tidaw
, int num
)
123 for (i
= 0; i
< num
; i
++) {
124 if (tidaw
[i
].flags
& TIDAW_FLAGS_LAST
)
126 /* TODO: find out if padding applies to total of data
127 * transferred or data transferred by this tidaw. Assumption:
128 * applies to total. */
129 data_count
+= tidaw
[i
].count
;
130 if (tidaw
[i
].flags
& TIDAW_FLAGS_INSERT_CBC
) {
131 cbc_data
= 4 + ALIGN(data_count
, 4) - data_count
;
132 cbc_count
+= cbc_data
;
133 data_count
+= cbc_data
;
140 * tcw_finalize - finalize tcw length fields and tidaw list
141 * @tcw: pointer to the tcw
142 * @num_tidaws: the number of tidaws used to address input/output data or zero
145 * Calculate the input-/output-count and tccbl field in the tcw, add a
146 * tcat the tccb and terminate the data tidaw list if used.
148 * Note: in case input- or output-tida is used, the tidaw-list must be stored
149 * in contiguous storage (no ttic). The tcal field in the tccb must be
152 void tcw_finalize(struct tcw
*tcw
, int num_tidaws
)
156 struct tccb_tcat
*tcat
;
159 /* Terminate tidaw list. */
160 tidaw
= tcw_get_data(tcw
);
162 tidaw
[num_tidaws
- 1].flags
|= TIDAW_FLAGS_LAST
;
163 /* Add tcat to tccb. */
164 tccb
= tcw_get_tccb(tcw
);
165 tcat
= (struct tccb_tcat
*) &tccb
->tca
[tca_size(tccb
)];
166 memset(tcat
, 0, sizeof(*tcat
));
167 /* Calculate tcw input/output count and tcat transport count. */
168 count
= calc_dcw_count(tccb
);
169 if (tcw
->w
&& (tcw
->flags
& TCW_FLAGS_OUTPUT_TIDA
))
170 count
+= calc_cbc_size(tidaw
, num_tidaws
);
172 tcw
->input_count
= count
;
174 tcw
->output_count
= count
;
175 tcat
->count
= ALIGN(count
, 4) + 4;
176 /* Calculate tccbl. */
177 tcw
->tccbl
= (sizeof(struct tccb
) + tca_size(tccb
) +
178 sizeof(struct tccb_tcat
) - 20) >> 2;
180 EXPORT_SYMBOL(tcw_finalize
);
183 * tcw_set_intrg - set the interrogate tcw address of a tcw
184 * @tcw: the tcw address
185 * @intrg_tcw: the address of the interrogate tcw
187 * Set the address of the interrogate tcw in the specified tcw.
189 void tcw_set_intrg(struct tcw
*tcw
, struct tcw
*intrg_tcw
)
191 tcw
->intrg
= (u32
) ((addr_t
) intrg_tcw
);
193 EXPORT_SYMBOL(tcw_set_intrg
);
196 * tcw_set_data - set data address and tida flag of a tcw
197 * @tcw: the tcw address
198 * @data: the data address
199 * @use_tidal: zero of the data address specifies a contiguous block of data,
200 * non-zero if it specifies a list if tidaws.
202 * Set the input/output data address of a tcw (depending on the value of the
203 * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
206 void tcw_set_data(struct tcw
*tcw
, void *data
, int use_tidal
)
209 tcw
->input
= (u64
) ((addr_t
) data
);
211 tcw
->flags
|= TCW_FLAGS_INPUT_TIDA
;
213 tcw
->output
= (u64
) ((addr_t
) data
);
215 tcw
->flags
|= TCW_FLAGS_OUTPUT_TIDA
;
218 EXPORT_SYMBOL(tcw_set_data
);
221 * tcw_set_tccb - set tccb address of a tcw
222 * @tcw: the tcw address
223 * @tccb: the tccb address
225 * Set the address of the tccb in the specified tcw.
227 void tcw_set_tccb(struct tcw
*tcw
, struct tccb
*tccb
)
229 tcw
->tccb
= (u64
) ((addr_t
) tccb
);
231 EXPORT_SYMBOL(tcw_set_tccb
);
234 * tcw_set_tsb - set tsb address of a tcw
235 * @tcw: the tcw address
236 * @tsb: the tsb address
238 * Set the address of the tsb in the specified tcw.
240 void tcw_set_tsb(struct tcw
*tcw
, struct tsb
*tsb
)
242 tcw
->tsb
= (u64
) ((addr_t
) tsb
);
244 EXPORT_SYMBOL(tcw_set_tsb
);
247 * tccb_init - initialize tccb
248 * @tccb: the tccb address
249 * @size: the maximum size of the tccb
250 * @sac: the service-action-code to be user
252 * Initialize the header of the specified tccb by resetting all values to zero
253 * and filling in defaults for format, sac and initial tcal fields.
255 void tccb_init(struct tccb
*tccb
, size_t size
, u32 sac
)
257 memset(tccb
, 0, size
);
258 tccb
->tcah
.format
= TCCB_FORMAT_DEFAULT
;
259 tccb
->tcah
.sac
= sac
;
260 tccb
->tcah
.tcal
= 12;
262 EXPORT_SYMBOL(tccb_init
);
265 * tsb_init - initialize tsb
266 * @tsb: the tsb address
268 * Initialize the specified tsb by resetting all values to zero.
270 void tsb_init(struct tsb
*tsb
)
272 memset(tsb
, 0, sizeof(*tsb
));
274 EXPORT_SYMBOL(tsb_init
);
277 * tccb_add_dcw - add a dcw to the tccb
278 * @tccb: the tccb address
279 * @tccb_size: the maximum tccb size
280 * @cmd: the dcw command
281 * @flags: flags for the dcw
282 * @cd: pointer to control data for this dcw or NULL if none is required
283 * @cd_count: number of control data bytes for this dcw
284 * @count: number of data bytes for this dcw
286 * Add a new dcw to the specified tccb by writing the dcw information specified
287 * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
288 * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
289 * would exceed the available space as defined by @tccb_size.
291 * Note: the tcal field of the tccb header will be updates to reflect added
294 struct dcw
*tccb_add_dcw(struct tccb
*tccb
, size_t tccb_size
, u8 cmd
, u8 flags
,
295 void *cd
, u8 cd_count
, u32 count
)
301 /* Check for space. */
302 tca_offset
= tca_size(tccb
);
303 size
= ALIGN(sizeof(struct dcw
) + cd_count
, 4);
304 if (sizeof(struct tccb_tcah
) + tca_offset
+ size
+
305 sizeof(struct tccb_tcat
) > tccb_size
)
306 return ERR_PTR(-ENOSPC
);
307 /* Add dcw to tca. */
308 dcw
= (struct dcw
*) &tccb
->tca
[tca_offset
];
309 memset(dcw
, 0, size
);
313 dcw
->cd_count
= cd_count
;
315 memcpy(&dcw
->cd
[0], cd
, cd_count
);
316 tccb
->tcah
.tcal
+= size
;
319 EXPORT_SYMBOL(tccb_add_dcw
);
322 * tcw_add_tidaw - add a tidaw to a tcw
323 * @tcw: the tcw address
324 * @num_tidaws: the current number of tidaws
325 * @flags: flags for the new tidaw
326 * @addr: address value for the new tidaw
327 * @count: count value for the new tidaw
329 * Add a new tidaw to the input/output data tidaw-list of the specified tcw
330 * (depending on the value of the r-flag and w-flag) and return a pointer to
333 * Note: the tidaw-list is assumed to be contiguous with no ttics. The caller
334 * must ensure that there is enough space for the new tidaw. The last-tidaw
335 * flag for the last tidaw in the list will be set by tcw_finalize.
337 struct tidaw
*tcw_add_tidaw(struct tcw
*tcw
, int num_tidaws
, u8 flags
,
338 void *addr
, u32 count
)
342 /* Add tidaw to tidaw-list. */
343 tidaw
= ((struct tidaw
*) tcw_get_data(tcw
)) + num_tidaws
;
344 memset(tidaw
, 0, sizeof(struct tidaw
));
345 tidaw
->flags
= flags
;
346 tidaw
->count
= count
;
347 tidaw
->addr
= (u64
) ((addr_t
) addr
);
350 EXPORT_SYMBOL(tcw_add_tidaw
);
This page took 0.037669 seconds and 6 git commands to generate.