[S390] cio: provide helper functions for fcx enabled I/O
Provide functions which can be used to incrementally construct fcx enabled I/O control blocks. Signed-off-by: Peter Oberparleiter <peter.oberparleiter@de.ibm.com> Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com> Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
This commit is contained in:
Peter Oberparleiter
Heiko Carstens
Родитель
83262d6349
Коммит
23f6268947
|
|
@ -2,7 +2,8 @@
|
|||
# Makefile for the S/390 common i/o drivers
|
||||
#
|
||||
|
||||
obj-y += airq.o blacklist.o chsc.o cio.o css.o chp.o idset.o scsw.o fcx.o
|
||||
obj-y += airq.o blacklist.o chsc.o cio.o css.o chp.o idset.o scsw.o fcx.o \
|
||||
itcw.o
|
||||
ccw_device-objs += device.o device_fsm.o device_ops.o
|
||||
ccw_device-objs += device_id.o device_pgid.o device_status.o
|
||||
obj-y += ccw_device.o cmf.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,327 @@
|
|||
/*
|
||||
* Functions for incremental construction of fcx enabled I/O control blocks.
|
||||
*
|
||||
* Copyright IBM Corp. 2008
|
||||
* Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
|
||||
*/
|
||||
|
||||
#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_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;
|
||||
|
||||
/* 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;
|
||||
/* Maximum padding for structures that may not cross 4k boundary. */
|
||||
if ((max_tidaws > 0) || (intrg_max_tidaws > 0))
|
||||
len += max(max_tidaws, intrg_max_tidaws) *
|
||||
sizeof(struct tidaw) - 1;
|
||||
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;
|
||||
|
||||
/* 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;
|
||||
itcw->max_tidaws = max_tidaws;
|
||||
itcw->intrg_max_tidaws = intrg_max_tidaws;
|
||||
/* 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) *
|
||||
max_tidaws, 16, 1);
|
||||
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) *
|
||||
intrg_max_tidaws, 16, 1);
|
||||
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: the tidaw-list is assumed to be contiguous with no ttics. 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)
|
||||
{
|
||||
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);
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/*
|
||||
* Functions for incremental construction of fcx enabled I/O control blocks.
|
||||
*
|
||||
* Copyright IBM Corp. 2008
|
||||
* Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef _ASM_S390_ITCW_H
|
||||
#define _ASM_S390_ITCW_H _ASM_S390_ITCW_H
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <asm/fcx.h>
|
||||
|
||||
#define ITCW_OP_READ 0
|
||||
#define ITCW_OP_WRITE 1
|
||||
|
||||
struct itcw;
|
||||
|
||||
struct tcw *itcw_get_tcw(struct itcw *itcw);
|
||||
size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws);
|
||||
struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
|
||||
int max_tidaws, int intrg_max_tidaws);
|
||||
struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd,
|
||||
u8 cd_count, u32 count);
|
||||
struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr,
|
||||
u32 count);
|
||||
void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal);
|
||||
void itcw_finalize(struct itcw *itcw);
|
||||
|
||||
#endif /* _ASM_S390_ITCW_H */
|
||||
Загрузка…
Ссылка в новой задаче