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