[S390] cio: provide helper functions for fcx enabled I/O

# 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

/*

 *  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);

/*

 *  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 */