372 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Functions for incremental construction of fcx enabled I/O control blocks.4 *5 * Copyright IBM Corp. 20086 * 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 <asm/itcw.h>18 19/*20 * struct itcw - incremental tcw helper data type21 *22 * This structure serves as a handle for the incremental construction of a23 * tcw and associated tccb, tsb, data tidaw-list plus an optional interrogate24 * tcw and associated data. The data structures are contained inside a single25 * contiguous buffer provided by the user.26 *27 * The itcw construction functions take care of overall data integrity:28 * - reset unused fields to zero29 * - fill in required pointers30 * - ensure required alignment for data structures31 * - prevent data structures to cross 4k-byte boundary where required32 * - calculate tccb-related length fields33 * - optionally provide ready-made interrogate tcw and associated structures34 *35 * Restrictions apply to the itcws created with these construction functions:36 * - tida only supported for data address, not for tccb37 * - only contiguous tidaw-lists (no ttic)38 * - total number of bytes required per itcw may not exceed 4k bytes39 * - either read or write operation (may not work with r=0 and w=0)40 *41 * Example:42 * struct itcw *itcw;43 * void *buffer;44 * size_t size;45 *46 * size = itcw_calc_size(1, 2, 0);47 * buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);48 * if (!buffer)49 * return -ENOMEM;50 * itcw = itcw_init(buffer, size, ITCW_OP_READ, 1, 2, 0);51 * if (IS_ERR(itcw))52 * return PTR_ER(itcw);53 * itcw_add_dcw(itcw, 0x2, 0, NULL, 0, 72);54 * itcw_add_tidaw(itcw, 0, 0x30000, 20);55 * itcw_add_tidaw(itcw, 0, 0x40000, 52);56 * itcw_finalize(itcw);57 *58 */59struct itcw {60 struct tcw *tcw;61 struct tcw *intrg_tcw;62 int num_tidaws;63 int max_tidaws;64 int intrg_num_tidaws;65 int intrg_max_tidaws;66};67 68/**69 * itcw_get_tcw - return pointer to tcw associated with the itcw70 * @itcw: address of the itcw71 *72 * Return pointer to the tcw associated with the itcw.73 */74struct tcw *itcw_get_tcw(struct itcw *itcw)75{76 return itcw->tcw;77}78EXPORT_SYMBOL(itcw_get_tcw);79 80/**81 * itcw_calc_size - return the size of an itcw with the given parameters82 * @intrg: if non-zero, add an interrogate tcw83 * @max_tidaws: maximum number of tidaws to be used for data addressing or zero84 * if no tida is to be used.85 * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing86 * by the interrogate tcw, if specified87 *88 * Calculate and return the number of bytes required to hold an itcw with the89 * given parameters and assuming tccbs with maximum size.90 *91 * Note that the resulting size also contains bytes needed for alignment92 * padding as well as padding to ensure that data structures don't cross a93 * 4k-boundary where required.94 */95size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)96{97 size_t len;98 int cross_count;99 100 /* Main data. */101 len = sizeof(struct itcw);102 len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +103 /* TSB */ sizeof(struct tsb) +104 /* TIDAL */ max_tidaws * sizeof(struct tidaw);105 /* Interrogate data. */106 if (intrg) {107 len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +108 /* TSB */ sizeof(struct tsb) +109 /* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw);110 }111 112 /* Maximum required alignment padding. */113 len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7;114 115 /* TIDAW lists may not cross a 4k boundary. To cross a116 * boundary we need to add a TTIC TIDAW. We need to reserve117 * one additional TIDAW for a TTIC that we may need to add due118 * to the placement of the data chunk in memory, and a further119 * TIDAW for each page boundary that the TIDAW list may cross120 * due to it's own size.121 */122 if (max_tidaws) {123 cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)124 >> PAGE_SHIFT);125 len += cross_count * sizeof(struct tidaw);126 }127 if (intrg_max_tidaws) {128 cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)129 >> PAGE_SHIFT);130 len += cross_count * sizeof(struct tidaw);131 }132 return len;133}134EXPORT_SYMBOL(itcw_calc_size);135 136#define CROSS4K(x, l) (((x) & ~4095) != ((x + l) & ~4095))137 138static inline void *fit_chunk(addr_t *start, addr_t end, size_t len,139 int align, int check_4k)140{141 addr_t addr;142 143 addr = ALIGN(*start, align);144 if (check_4k && CROSS4K(addr, len)) {145 addr = ALIGN(addr, 4096);146 addr = ALIGN(addr, align);147 }148 if (addr + len > end)149 return ERR_PTR(-ENOSPC);150 *start = addr + len;151 return (void *) addr;152}153 154/**155 * itcw_init - initialize incremental tcw data structure156 * @buffer: address of buffer to use for data structures157 * @size: number of bytes in buffer158 * @op: %ITCW_OP_READ for a read operation tcw, %ITCW_OP_WRITE for a write159 * operation tcw160 * @intrg: if non-zero, add and initialize an interrogate tcw161 * @max_tidaws: maximum number of tidaws to be used for data addressing or zero162 * if no tida is to be used.163 * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing164 * by the interrogate tcw, if specified165 *166 * Prepare the specified buffer to be used as an incremental tcw, i.e. a167 * helper data structure that can be used to construct a valid tcw by168 * successive calls to other helper functions. Note: the buffer needs to be169 * located below the 2G address limit. The resulting tcw has the following170 * restrictions:171 * - no tccb tidal172 * - input/output tidal is contiguous (no ttic)173 * - total data should not exceed 4k174 * - tcw specifies either read or write operation175 *176 * On success, return pointer to the resulting incremental tcw data structure,177 * ERR_PTR otherwise.178 */179struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,180 int max_tidaws, int intrg_max_tidaws)181{182 struct itcw *itcw;183 void *chunk;184 addr_t start;185 addr_t end;186 int cross_count;187 188 /* Check for 2G limit. */189 start = (addr_t) buffer;190 end = start + size;191 if ((virt_to_phys(buffer) + size) > (1 << 31))192 return ERR_PTR(-EINVAL);193 memset(buffer, 0, size);194 /* ITCW. */195 chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0);196 if (IS_ERR(chunk))197 return chunk;198 itcw = chunk;199 /* allow for TTIC tidaws that may be needed to cross a page boundary */200 cross_count = 0;201 if (max_tidaws)202 cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)203 >> PAGE_SHIFT);204 itcw->max_tidaws = max_tidaws + cross_count;205 cross_count = 0;206 if (intrg_max_tidaws)207 cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)208 >> PAGE_SHIFT);209 itcw->intrg_max_tidaws = intrg_max_tidaws + cross_count;210 /* Main TCW. */211 chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);212 if (IS_ERR(chunk))213 return chunk;214 itcw->tcw = chunk;215 tcw_init(itcw->tcw, (op == ITCW_OP_READ) ? 1 : 0,216 (op == ITCW_OP_WRITE) ? 1 : 0);217 /* Interrogate TCW. */218 if (intrg) {219 chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);220 if (IS_ERR(chunk))221 return chunk;222 itcw->intrg_tcw = chunk;223 tcw_init(itcw->intrg_tcw, 1, 0);224 tcw_set_intrg(itcw->tcw, itcw->intrg_tcw);225 }226 /* Data TIDAL. */227 if (max_tidaws > 0) {228 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *229 itcw->max_tidaws, 16, 0);230 if (IS_ERR(chunk))231 return chunk;232 tcw_set_data(itcw->tcw, chunk, 1);233 }234 /* Interrogate data TIDAL. */235 if (intrg && (intrg_max_tidaws > 0)) {236 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *237 itcw->intrg_max_tidaws, 16, 0);238 if (IS_ERR(chunk))239 return chunk;240 tcw_set_data(itcw->intrg_tcw, chunk, 1);241 }242 /* TSB. */243 chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);244 if (IS_ERR(chunk))245 return chunk;246 tsb_init(chunk);247 tcw_set_tsb(itcw->tcw, chunk);248 /* Interrogate TSB. */249 if (intrg) {250 chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);251 if (IS_ERR(chunk))252 return chunk;253 tsb_init(chunk);254 tcw_set_tsb(itcw->intrg_tcw, chunk);255 }256 /* TCCB. */257 chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);258 if (IS_ERR(chunk))259 return chunk;260 tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT);261 tcw_set_tccb(itcw->tcw, chunk);262 /* Interrogate TCCB. */263 if (intrg) {264 chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);265 if (IS_ERR(chunk))266 return chunk;267 tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG);268 tcw_set_tccb(itcw->intrg_tcw, chunk);269 tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL,270 sizeof(struct dcw_intrg_data), 0);271 tcw_finalize(itcw->intrg_tcw, 0);272 }273 return itcw;274}275EXPORT_SYMBOL(itcw_init);276 277/**278 * itcw_add_dcw - add a dcw to the itcw279 * @itcw: address of the itcw280 * @cmd: the dcw command281 * @flags: flags for the dcw282 * @cd: address of control data for this dcw or NULL if none is required283 * @cd_count: number of control data bytes for this dcw284 * @count: number of data bytes for this dcw285 *286 * Add a new dcw to the specified itcw by writing the dcw information specified287 * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return288 * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw289 * would exceed the available space.290 *291 * Note: the tcal field of the tccb header will be updated to reflect added292 * content.293 */294struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd,295 u8 cd_count, u32 count)296{297 return tccb_add_dcw(tcw_get_tccb(itcw->tcw), TCCB_MAX_SIZE, cmd,298 flags, cd, cd_count, count);299}300EXPORT_SYMBOL(itcw_add_dcw);301 302/**303 * itcw_add_tidaw - add a tidaw to the itcw304 * @itcw: address of the itcw305 * @flags: flags for the new tidaw306 * @addr: address value for the new tidaw307 * @count: count value for the new tidaw308 *309 * Add a new tidaw to the input/output data tidaw-list of the specified itcw310 * (depending on the value of the r-flag and w-flag). Return a pointer to311 * the new tidaw on success or -%ENOSPC if the new tidaw would exceed the312 * available space.313 *314 * Note: TTIC tidaws are automatically added when needed, so explicitly calling315 * this interface with the TTIC flag is not supported. The last-tidaw flag316 * for the last tidaw in the list will be set by itcw_finalize.317 */318struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count)319{320 struct tidaw *following;321 322 if (itcw->num_tidaws >= itcw->max_tidaws)323 return ERR_PTR(-ENOSPC);324 /*325 * Is the tidaw, which follows the one we are about to fill, on the next326 * page? Then we have to insert a TTIC tidaw first, that points to the327 * tidaw on the new page.328 */329 following = ((struct tidaw *) tcw_get_data(itcw->tcw))330 + itcw->num_tidaws + 1;331 if (itcw->num_tidaws && !((unsigned long) following & ~PAGE_MASK)) {332 tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++,333 TIDAW_FLAGS_TTIC, following, 0);334 if (itcw->num_tidaws >= itcw->max_tidaws)335 return ERR_PTR(-ENOSPC);336 }337 return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count);338}339EXPORT_SYMBOL(itcw_add_tidaw);340 341/**342 * itcw_set_data - set data address and tida flag of the itcw343 * @itcw: address of the itcw344 * @addr: the data address345 * @use_tidal: zero of the data address specifies a contiguous block of data,346 * non-zero if it specifies a list if tidaws.347 *348 * Set the input/output data address of the itcw (depending on the value of the349 * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag350 * is set as well.351 */352void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal)353{354 tcw_set_data(itcw->tcw, addr, use_tidal);355}356EXPORT_SYMBOL(itcw_set_data);357 358/**359 * itcw_finalize - calculate length and count fields of the itcw360 * @itcw: address of the itcw361 *362 * Calculate tcw input-/output-count and tccbl fields and add a tcat the tccb.363 * In case input- or output-tida is used, the tidaw-list must be stored in364 * continuous storage (no ttic). The tcal field in the tccb must be365 * up-to-date.366 */367void itcw_finalize(struct itcw *itcw)368{369 tcw_finalize(itcw->tcw, itcw->num_tidaws);370}371EXPORT_SYMBOL(itcw_finalize);372