mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
12 KiB
370 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Functions for incremental construction of fcx enabled I/O control blocks. |
|
* |
|
* Copyright IBM Corp. 2008 |
|
* Author(s): Peter Oberparleiter <[email protected]> |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/types.h> |
|
#include <linux/string.h> |
|
#include <linux/errno.h> |
|
#include <linux/err.h> |
|
#include <linux/module.h> |
|
#include <asm/fcx.h> |
|
#include <asm/itcw.h> |
|
|
|
/* |
|
* struct itcw - incremental tcw helper data type |
|
* |
|
* This structure serves as a handle for the incremental construction of a |
|
* tcw and associated tccb, tsb, data tidaw-list plus an optional interrogate |
|
* tcw and associated data. The data structures are contained inside a single |
|
* contiguous buffer provided by the user. |
|
* |
|
* The itcw construction functions take care of overall data integrity: |
|
* - reset unused fields to zero |
|
* - fill in required pointers |
|
* - ensure required alignment for data structures |
|
* - prevent data structures to cross 4k-byte boundary where required |
|
* - calculate tccb-related length fields |
|
* - optionally provide ready-made interrogate tcw and associated structures |
|
* |
|
* Restrictions apply to the itcws created with these construction functions: |
|
* - tida only supported for data address, not for tccb |
|
* - only contiguous tidaw-lists (no ttic) |
|
* - total number of bytes required per itcw may not exceed 4k bytes |
|
* - either read or write operation (may not work with r=0 and w=0) |
|
* |
|
* Example: |
|
* struct itcw *itcw; |
|
* void *buffer; |
|
* size_t size; |
|
* |
|
* size = itcw_calc_size(1, 2, 0); |
|
* buffer = kmalloc(size, GFP_KERNEL | GFP_DMA); |
|
* if (!buffer) |
|
* return -ENOMEM; |
|
* itcw = itcw_init(buffer, size, ITCW_OP_READ, 1, 2, 0); |
|
* if (IS_ERR(itcw)) |
|
* return PTR_ER(itcw); |
|
* itcw_add_dcw(itcw, 0x2, 0, NULL, 0, 72); |
|
* itcw_add_tidaw(itcw, 0, 0x30000, 20); |
|
* itcw_add_tidaw(itcw, 0, 0x40000, 52); |
|
* itcw_finalize(itcw); |
|
* |
|
*/ |
|
struct itcw { |
|
struct tcw *tcw; |
|
struct tcw *intrg_tcw; |
|
int num_tidaws; |
|
int max_tidaws; |
|
int intrg_num_tidaws; |
|
int intrg_max_tidaws; |
|
}; |
|
|
|
/** |
|
* itcw_get_tcw - return pointer to tcw associated with the itcw |
|
* @itcw: address of the itcw |
|
* |
|
* Return pointer to the tcw associated with the itcw. |
|
*/ |
|
struct tcw *itcw_get_tcw(struct itcw *itcw) |
|
{ |
|
return itcw->tcw; |
|
} |
|
EXPORT_SYMBOL(itcw_get_tcw); |
|
|
|
/** |
|
* itcw_calc_size - return the size of an itcw with the given parameters |
|
* @intrg: if non-zero, add an interrogate tcw |
|
* @max_tidaws: maximum number of tidaws to be used for data addressing or zero |
|
* if no tida is to be used. |
|
* @intrg_max_tidaws: maximum number of tidaws to be used for data addressing |
|
* by the interrogate tcw, if specified |
|
* |
|
* Calculate and return the number of bytes required to hold an itcw with the |
|
* given parameters and assuming tccbs with maximum size. |
|
* |
|
* Note that the resulting size also contains bytes needed for alignment |
|
* padding as well as padding to ensure that data structures don't cross a |
|
* 4k-boundary where required. |
|
*/ |
|
size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws) |
|
{ |
|
size_t len; |
|
int cross_count; |
|
|
|
/* Main data. */ |
|
len = sizeof(struct itcw); |
|
len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE + |
|
/* TSB */ sizeof(struct tsb) + |
|
/* TIDAL */ max_tidaws * sizeof(struct tidaw); |
|
/* Interrogate data. */ |
|
if (intrg) { |
|
len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE + |
|
/* TSB */ sizeof(struct tsb) + |
|
/* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw); |
|
} |
|
|
|
/* Maximum required alignment padding. */ |
|
len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7; |
|
|
|
/* TIDAW lists may not cross a 4k boundary. To cross a |
|
* boundary we need to add a TTIC TIDAW. We need to reserve |
|
* one additional TIDAW for a TTIC that we may need to add due |
|
* to the placement of the data chunk in memory, and a further |
|
* TIDAW for each page boundary that the TIDAW list may cross |
|
* due to it's own size. |
|
*/ |
|
if (max_tidaws) { |
|
cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1) |
|
>> PAGE_SHIFT); |
|
len += cross_count * sizeof(struct tidaw); |
|
} |
|
if (intrg_max_tidaws) { |
|
cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1) |
|
>> PAGE_SHIFT); |
|
len += cross_count * sizeof(struct tidaw); |
|
} |
|
return len; |
|
} |
|
EXPORT_SYMBOL(itcw_calc_size); |
|
|
|
#define CROSS4K(x, l) (((x) & ~4095) != ((x + l) & ~4095)) |
|
|
|
static inline void *fit_chunk(addr_t *start, addr_t end, size_t len, |
|
int align, int check_4k) |
|
{ |
|
addr_t addr; |
|
|
|
addr = ALIGN(*start, align); |
|
if (check_4k && CROSS4K(addr, len)) { |
|
addr = ALIGN(addr, 4096); |
|
addr = ALIGN(addr, align); |
|
} |
|
if (addr + len > end) |
|
return ERR_PTR(-ENOSPC); |
|
*start = addr + len; |
|
return (void *) addr; |
|
} |
|
|
|
/** |
|
* itcw_init - initialize incremental tcw data structure |
|
* @buffer: address of buffer to use for data structures |
|
* @size: number of bytes in buffer |
|
* @op: %ITCW_OP_READ for a read operation tcw, %ITCW_OP_WRITE for a write |
|
* operation tcw |
|
* @intrg: if non-zero, add and initialize an interrogate tcw |
|
* @max_tidaws: maximum number of tidaws to be used for data addressing or zero |
|
* if no tida is to be used. |
|
* @intrg_max_tidaws: maximum number of tidaws to be used for data addressing |
|
* by the interrogate tcw, if specified |
|
* |
|
* Prepare the specified buffer to be used as an incremental tcw, i.e. a |
|
* helper data structure that can be used to construct a valid tcw by |
|
* successive calls to other helper functions. Note: the buffer needs to be |
|
* located below the 2G address limit. The resulting tcw has the following |
|
* restrictions: |
|
* - no tccb tidal |
|
* - input/output tidal is contiguous (no ttic) |
|
* - total data should not exceed 4k |
|
* - tcw specifies either read or write operation |
|
* |
|
* On success, return pointer to the resulting incremental tcw data structure, |
|
* ERR_PTR otherwise. |
|
*/ |
|
struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg, |
|
int max_tidaws, int intrg_max_tidaws) |
|
{ |
|
struct itcw *itcw; |
|
void *chunk; |
|
addr_t start; |
|
addr_t end; |
|
int cross_count; |
|
|
|
/* Check for 2G limit. */ |
|
start = (addr_t) buffer; |
|
end = start + size; |
|
if (end > (1 << 31)) |
|
return ERR_PTR(-EINVAL); |
|
memset(buffer, 0, size); |
|
/* ITCW. */ |
|
chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
itcw = chunk; |
|
/* allow for TTIC tidaws that may be needed to cross a page boundary */ |
|
cross_count = 0; |
|
if (max_tidaws) |
|
cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1) |
|
>> PAGE_SHIFT); |
|
itcw->max_tidaws = max_tidaws + cross_count; |
|
cross_count = 0; |
|
if (intrg_max_tidaws) |
|
cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1) |
|
>> PAGE_SHIFT); |
|
itcw->intrg_max_tidaws = intrg_max_tidaws + cross_count; |
|
/* Main TCW. */ |
|
chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
itcw->tcw = chunk; |
|
tcw_init(itcw->tcw, (op == ITCW_OP_READ) ? 1 : 0, |
|
(op == ITCW_OP_WRITE) ? 1 : 0); |
|
/* Interrogate TCW. */ |
|
if (intrg) { |
|
chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
itcw->intrg_tcw = chunk; |
|
tcw_init(itcw->intrg_tcw, 1, 0); |
|
tcw_set_intrg(itcw->tcw, itcw->intrg_tcw); |
|
} |
|
/* Data TIDAL. */ |
|
if (max_tidaws > 0) { |
|
chunk = fit_chunk(&start, end, sizeof(struct tidaw) * |
|
itcw->max_tidaws, 16, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tcw_set_data(itcw->tcw, chunk, 1); |
|
} |
|
/* Interrogate data TIDAL. */ |
|
if (intrg && (intrg_max_tidaws > 0)) { |
|
chunk = fit_chunk(&start, end, sizeof(struct tidaw) * |
|
itcw->intrg_max_tidaws, 16, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tcw_set_data(itcw->intrg_tcw, chunk, 1); |
|
} |
|
/* TSB. */ |
|
chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tsb_init(chunk); |
|
tcw_set_tsb(itcw->tcw, chunk); |
|
/* Interrogate TSB. */ |
|
if (intrg) { |
|
chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tsb_init(chunk); |
|
tcw_set_tsb(itcw->intrg_tcw, chunk); |
|
} |
|
/* TCCB. */ |
|
chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT); |
|
tcw_set_tccb(itcw->tcw, chunk); |
|
/* Interrogate TCCB. */ |
|
if (intrg) { |
|
chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0); |
|
if (IS_ERR(chunk)) |
|
return chunk; |
|
tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG); |
|
tcw_set_tccb(itcw->intrg_tcw, chunk); |
|
tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL, |
|
sizeof(struct dcw_intrg_data), 0); |
|
tcw_finalize(itcw->intrg_tcw, 0); |
|
} |
|
return itcw; |
|
} |
|
EXPORT_SYMBOL(itcw_init); |
|
|
|
/** |
|
* itcw_add_dcw - add a dcw to the itcw |
|
* @itcw: address of the itcw |
|
* @cmd: the dcw command |
|
* @flags: flags for the dcw |
|
* @cd: address of control data for this dcw or NULL if none is required |
|
* @cd_count: number of control data bytes for this dcw |
|
* @count: number of data bytes for this dcw |
|
* |
|
* Add a new dcw to the specified itcw by writing the dcw information specified |
|
* by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return |
|
* a pointer to the newly added dcw on success or -%ENOSPC if the new dcw |
|
* would exceed the available space. |
|
* |
|
* Note: the tcal field of the tccb header will be updated to reflect added |
|
* content. |
|
*/ |
|
struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd, |
|
u8 cd_count, u32 count) |
|
{ |
|
return tccb_add_dcw(tcw_get_tccb(itcw->tcw), TCCB_MAX_SIZE, cmd, |
|
flags, cd, cd_count, count); |
|
} |
|
EXPORT_SYMBOL(itcw_add_dcw); |
|
|
|
/** |
|
* itcw_add_tidaw - add a tidaw to the itcw |
|
* @itcw: address of the itcw |
|
* @flags: flags for the new tidaw |
|
* @addr: address value for the new tidaw |
|
* @count: count value for the new tidaw |
|
* |
|
* Add a new tidaw to the input/output data tidaw-list of the specified itcw |
|
* (depending on the value of the r-flag and w-flag). Return a pointer to |
|
* the new tidaw on success or -%ENOSPC if the new tidaw would exceed the |
|
* available space. |
|
* |
|
* Note: TTIC tidaws are automatically added when needed, so explicitly calling |
|
* this interface with the TTIC flag is not supported. The last-tidaw flag |
|
* for the last tidaw in the list will be set by itcw_finalize. |
|
*/ |
|
struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count) |
|
{ |
|
struct tidaw *following; |
|
|
|
if (itcw->num_tidaws >= itcw->max_tidaws) |
|
return ERR_PTR(-ENOSPC); |
|
/* |
|
* Is the tidaw, which follows the one we are about to fill, on the next |
|
* page? Then we have to insert a TTIC tidaw first, that points to the |
|
* tidaw on the new page. |
|
*/ |
|
following = ((struct tidaw *) tcw_get_data(itcw->tcw)) |
|
+ itcw->num_tidaws + 1; |
|
if (itcw->num_tidaws && !((unsigned long) following & ~PAGE_MASK)) { |
|
tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, |
|
TIDAW_FLAGS_TTIC, following, 0); |
|
if (itcw->num_tidaws >= itcw->max_tidaws) |
|
return ERR_PTR(-ENOSPC); |
|
} |
|
return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count); |
|
} |
|
EXPORT_SYMBOL(itcw_add_tidaw); |
|
|
|
/** |
|
* itcw_set_data - set data address and tida flag of the itcw |
|
* @itcw: address of the itcw |
|
* @addr: the data address |
|
* @use_tidal: zero of the data address specifies a contiguous block of data, |
|
* non-zero if it specifies a list if tidaws. |
|
* |
|
* Set the input/output data address of the itcw (depending on the value of the |
|
* r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag |
|
* is set as well. |
|
*/ |
|
void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal) |
|
{ |
|
tcw_set_data(itcw->tcw, addr, use_tidal); |
|
} |
|
EXPORT_SYMBOL(itcw_set_data); |
|
|
|
/** |
|
* itcw_finalize - calculate length and count fields of the itcw |
|
* @itcw: address of the itcw |
|
* |
|
* Calculate tcw input-/output-count and tccbl fields and add a tcat the tccb. |
|
* In case input- or output-tida is used, the tidaw-list must be stored in |
|
* continuous storage (no ttic). The tcal field in the tccb must be |
|
* up-to-date. |
|
*/ |
|
void itcw_finalize(struct itcw *itcw) |
|
{ |
|
tcw_finalize(itcw->tcw, itcw->num_tidaws); |
|
} |
|
EXPORT_SYMBOL(itcw_finalize);
|
|
|