[S390] zcrypt PCICC, PCIXCC coprocessor card ap bus drivers.

/*

 *  linux/drivers/s390/crypto/zcrypt_cca_key.h

 *

 *  zcrypt 2.0.0

 *

 *  Copyright (C)  2001, 2006 IBM Corporation

 *  Author(s): Robert Burroughs

 *	       Eric Rossman (edrossma@us.ibm.com)

 *

 *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)

 *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#ifndef _ZCRYPT_CCA_KEY_H_

#define _ZCRYPT_CCA_KEY_H_

struct T6_keyBlock_hdr {

	unsigned short blen;

	unsigned short ulen;

	unsigned short flags;

};

/**

 * mapping for the cca private ME key token.

 * Three parts of interest here: the header, the private section and

 * the public section.

 *

 * mapping for the cca key token header

 */

struct cca_token_hdr {

	unsigned char  token_identifier;

	unsigned char  version;

	unsigned short token_length;

	unsigned char  reserved[4];

} __attribute__((packed));

#define CCA_TKN_HDR_ID_EXT 0x1E

/**

 * mapping for the cca private ME section

 */

struct cca_private_ext_ME_sec {

	unsigned char  section_identifier;

	unsigned char  version;

	unsigned short section_length;

	unsigned char  private_key_hash[20];

	unsigned char  reserved1[4];

	unsigned char  key_format;

	unsigned char  reserved2;

	unsigned char  key_name_hash[20];

	unsigned char  key_use_flags[4];

	unsigned char  reserved3[6];

	unsigned char  reserved4[24];

	unsigned char  confounder[24];

	unsigned char  exponent[128];

	unsigned char  modulus[128];

} __attribute__((packed));

#define CCA_PVT_USAGE_ALL 0x80

/**

 * mapping for the cca public section

 * In a private key, the modulus doesn't appear in the public

 * section. So, an arbitrary public exponent of 0x010001 will be

 * used, for a section length of 0x0F always.

 */

struct cca_public_sec {

	unsigned char  section_identifier;

	unsigned char  version;

	unsigned short section_length;

	unsigned char  reserved[2];

	unsigned short exponent_len;

	unsigned short modulus_bit_len;

	unsigned short modulus_byte_len;    /* In a private key, this is 0 */

} __attribute__((packed));

/**

 * mapping for the cca private CRT key 'token'

 * The first three parts (the only parts considered in this release)

 * are: the header, the private section and the public section.

 * The header and public section are the same as for the

 * struct cca_private_ext_ME

 *

 * Following the structure are the quantities p, q, dp, dq, u, pad,

 * and modulus, in that order, where pad_len is the modulo 8

 * complement of the residue modulo 8 of the sum of

 * (p_len + q_len + dp_len + dq_len + u_len).

 */

struct cca_pvt_ext_CRT_sec {

	unsigned char  section_identifier;

	unsigned char  version;

	unsigned short section_length;

	unsigned char  private_key_hash[20];

	unsigned char  reserved1[4];

	unsigned char  key_format;

	unsigned char  reserved2;

	unsigned char  key_name_hash[20];

	unsigned char  key_use_flags[4];

	unsigned short p_len;

	unsigned short q_len;

	unsigned short dp_len;

	unsigned short dq_len;

	unsigned short u_len;

	unsigned short mod_len;

	unsigned char  reserved3[4];

	unsigned short pad_len;

	unsigned char  reserved4[52];

	unsigned char  confounder[8];

} __attribute__((packed));

#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08

#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40

/**

 * Set up private key fields of a type6 MEX message.

 * Note that all numerics in the key token are big-endian,

 * while the entries in the key block header are little-endian.

 *

 * @mex: pointer to user input data

 * @p: pointer to memory area for the key

 *

 * Returns the size of the key area or -EFAULT

 */

static inline int zcrypt_type6_mex_key_de(struct ica_rsa_modexpo *mex,

					  void *p, int big_endian)

{

	static struct cca_token_hdr static_pvt_me_hdr = {

		.token_identifier	=  0x1E,

		.token_length		=  0x0183,

	};

	static struct cca_private_ext_ME_sec static_pvt_me_sec = {

		.section_identifier	=  0x02,

		.section_length		=  0x016C,

		.key_use_flags		= {0x80,0x00,0x00,0x00},

	};

	static struct cca_public_sec static_pub_me_sec = {

		.section_identifier	=  0x04,

		.section_length		=  0x000F,

		.exponent_len		=  0x0003,

	};

	static char pk_exponent[3] = { 0x01, 0x00, 0x01 };

	struct {

		struct T6_keyBlock_hdr t6_hdr;

		struct cca_token_hdr pvtMeHdr;

		struct cca_private_ext_ME_sec pvtMeSec;

		struct cca_public_sec pubMeSec;

		char exponent[3];

	} __attribute__((packed)) *key = p;

	unsigned char *temp;

	memset(key, 0, sizeof(*key));

	if (big_endian) {

		key->t6_hdr.blen = cpu_to_be16(0x189);

		key->t6_hdr.ulen = cpu_to_be16(0x189 - 2);

	} else {

		key->t6_hdr.blen = cpu_to_le16(0x189);

		key->t6_hdr.ulen = cpu_to_le16(0x189 - 2);

	}

	key->pvtMeHdr = static_pvt_me_hdr;

	key->pvtMeSec = static_pvt_me_sec;

	key->pubMeSec = static_pub_me_sec;

	/**

	 * In a private key, the modulus doesn't appear in the public

	 * section. So, an arbitrary public exponent of 0x010001 will be

	 * used.

	 */

	memcpy(key->exponent, pk_exponent, 3);

	/* key parameter block */

	temp = key->pvtMeSec.exponent +

		sizeof(key->pvtMeSec.exponent) - mex->inputdatalength;

	if (copy_from_user(temp, mex->b_key, mex->inputdatalength))

		return -EFAULT;

	/* modulus */

	temp = key->pvtMeSec.modulus +

		sizeof(key->pvtMeSec.modulus) - mex->inputdatalength;

	if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))

		return -EFAULT;

	key->pubMeSec.modulus_bit_len = 8 * mex->inputdatalength;

	return sizeof(*key);

}

/**

 * Set up private key fields of a type6 MEX message. The _pad variant

 * strips leading zeroes from the b_key.

 * Note that all numerics in the key token are big-endian,

 * while the entries in the key block header are little-endian.

 *

 * @mex: pointer to user input data

 * @p: pointer to memory area for the key

 *

 * Returns the size of the key area or -EFAULT

 */

static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex,

					  void *p, int big_endian)

{

	static struct cca_token_hdr static_pub_hdr = {

		.token_identifier	=  0x1E,

	};

	static struct cca_public_sec static_pub_sec = {

		.section_identifier	=  0x04,

	};

	struct {

		struct T6_keyBlock_hdr t6_hdr;

		struct cca_token_hdr pubHdr;

		struct cca_public_sec pubSec;

		char exponent[0];

	} __attribute__((packed)) *key = p;

	unsigned char *temp;

	int i;

	memset(key, 0, sizeof(*key));

	key->pubHdr = static_pub_hdr;

	key->pubSec = static_pub_sec;

	/* key parameter block */

	temp = key->exponent;

	if (copy_from_user(temp, mex->b_key, mex->inputdatalength))

		return -EFAULT;

	/* Strip leading zeroes from b_key. */

	for (i = 0; i < mex->inputdatalength; i++)

		if (temp[i])

			break;

	if (i >= mex->inputdatalength)

		return -EINVAL;

	memmove(temp, temp + i, mex->inputdatalength - i);

	temp += mex->inputdatalength - i;

	/* modulus */

	if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))

		return -EFAULT;

	key->pubSec.modulus_bit_len = 8 * mex->inputdatalength;

	key->pubSec.modulus_byte_len = mex->inputdatalength;

	key->pubSec.exponent_len = mex->inputdatalength - i;

	key->pubSec.section_length = sizeof(key->pubSec) +

					2*mex->inputdatalength - i;

	key->pubHdr.token_length =

		key->pubSec.section_length + sizeof(key->pubHdr);

	if (big_endian) {

		key->t6_hdr.ulen = cpu_to_be16(key->pubHdr.token_length + 4);

		key->t6_hdr.blen = cpu_to_be16(key->pubHdr.token_length + 6);

	} else {

		key->t6_hdr.ulen = cpu_to_le16(key->pubHdr.token_length + 4);

		key->t6_hdr.blen = cpu_to_le16(key->pubHdr.token_length + 6);

	}

	return sizeof(*key) + 2*mex->inputdatalength - i;

}

/**

 * Set up private key fields of a type6 CRT message.

 * Note that all numerics in the key token are big-endian,

 * while the entries in the key block header are little-endian.

 *

 * @mex: pointer to user input data

 * @p: pointer to memory area for the key

 *

 * Returns the size of the key area or -EFAULT

 */

static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt,

				       void *p, int big_endian)

{

	static struct cca_public_sec static_cca_pub_sec = {

		.section_identifier = 4,

		.section_length = 0x000f,

		.exponent_len = 0x0003,

	};

	static char pk_exponent[3] = { 0x01, 0x00, 0x01 };

	struct {

		struct T6_keyBlock_hdr t6_hdr;

		struct cca_token_hdr token;

		struct cca_pvt_ext_CRT_sec pvt;

		char key_parts[0];

	} __attribute__((packed)) *key = p;

	struct cca_public_sec *pub;

	int short_len, long_len, pad_len, key_len, size;

	memset(key, 0, sizeof(*key));

	short_len = crt->inputdatalength / 2;

	long_len = short_len + 8;

	pad_len = -(3*long_len + 2*short_len) & 7;

	key_len = 3*long_len + 2*short_len + pad_len + crt->inputdatalength;

	size = sizeof(*key) + key_len + sizeof(*pub) + 3;

	/* parameter block.key block */

	if (big_endian) {

		key->t6_hdr.blen = cpu_to_be16(size);

		key->t6_hdr.ulen = cpu_to_be16(size - 2);

	} else {

		key->t6_hdr.blen = cpu_to_le16(size);

		key->t6_hdr.ulen = cpu_to_le16(size - 2);

	}

	/* key token header */

	key->token.token_identifier = CCA_TKN_HDR_ID_EXT;

	key->token.token_length = size - 6;

	/* private section */

	key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;

	key->pvt.section_length = sizeof(key->pvt) + key_len;

	key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;

	key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL;

	key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len;

	key->pvt.q_len = key->pvt.dq_len = short_len;

	key->pvt.mod_len = crt->inputdatalength;

	key->pvt.pad_len = pad_len;

	/* key parts */

	if (copy_from_user(key->key_parts, crt->np_prime, long_len) ||

	    copy_from_user(key->key_parts + long_len,

					crt->nq_prime, short_len) ||

	    copy_from_user(key->key_parts + long_len + short_len,

					crt->bp_key, long_len) ||

	    copy_from_user(key->key_parts + 2*long_len + short_len,

					crt->bq_key, short_len) ||

	    copy_from_user(key->key_parts + 2*long_len + 2*short_len,

					crt->u_mult_inv, long_len))

		return -EFAULT;

	memset(key->key_parts + 3*long_len + 2*short_len + pad_len,

	       0xff, crt->inputdatalength);

	pub = (struct cca_public_sec *)(key->key_parts + key_len);

	*pub = static_cca_pub_sec;

	pub->modulus_bit_len = 8 * crt->inputdatalength;

	/**

	 * In a private key, the modulus doesn't appear in the public

	 * section. So, an arbitrary public exponent of 0x010001 will be

	 * used.

	 */

	memcpy((char *) (pub + 1), pk_exponent, 3);

	return size;

}

#endif /* _ZCRYPT_CCA_KEY_H_ */

/*

 *  linux/drivers/s390/crypto/zcrypt_pcicc.h

 *

 *  zcrypt 2.0.0

 *

 *  Copyright (C)  2001, 2006 IBM Corporation

 *  Author(s): Robert Burroughs

 *	       Eric Rossman (edrossma@us.ibm.com)

 *

 *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)

 *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#ifndef _ZCRYPT_PCICC_H_

#define _ZCRYPT_PCICC_H_

/**

 * The type 6 message family is associated with PCICC or PCIXCC cards.

 *

 * It contains a message header followed by a CPRB, both of which

 * are described below.

 *

 * Note that all reserved fields must be zeroes.

 */

struct type6_hdr {

	unsigned char reserved1;	/* 0x00				*/

	unsigned char type;		/* 0x06				*/

	unsigned char reserved2[2];	/* 0x0000			*/

	unsigned char right[4];		/* 0x00000000			*/

	unsigned char reserved3[2];	/* 0x0000			*/

	unsigned char reserved4[2];	/* 0x0000			*/

	unsigned char apfs[4];		/* 0x00000000			*/

	unsigned int  offset1;		/* 0x00000058 (offset to CPRB)	*/

	unsigned int  offset2;		/* 0x00000000			*/

	unsigned int  offset3;		/* 0x00000000			*/

	unsigned int  offset4;		/* 0x00000000			*/

	unsigned char agent_id[16];	/* PCICC:			*/

					/*    0x0100			*/

					/*    0x4343412d4150504c202020	*/

					/*    0x010101			*/

					/* PCIXCC:			*/

					/*    0x4341000000000000	*/

					/*    0x0000000000000000	*/

	unsigned char rqid[2];		/* rqid.  internal to 603	*/

	unsigned char reserved5[2];	/* 0x0000			*/

	unsigned char function_code[2];	/* for PKD, 0x5044 (ascii 'PD')	*/

	unsigned char reserved6[2];	/* 0x0000			*/

	unsigned int  ToCardLen1;	/* (request CPRB len + 3) & -4	*/

	unsigned int  ToCardLen2;	/* db len 0x00000000 for PKD	*/

	unsigned int  ToCardLen3;	/* 0x00000000			*/

	unsigned int  ToCardLen4;	/* 0x00000000			*/

	unsigned int  FromCardLen1;	/* response buffer length	*/

	unsigned int  FromCardLen2;	/* db len 0x00000000 for PKD	*/

	unsigned int  FromCardLen3;	/* 0x00000000			*/

	unsigned int  FromCardLen4;	/* 0x00000000			*/

} __attribute__((packed));

/**

 * CPRB

 *	  Note that all shorts, ints and longs are little-endian.

 *	  All pointer fields are 32-bits long, and mean nothing

 *

 *	  A request CPRB is followed by a request_parameter_block.

 *

 *	  The request (or reply) parameter block is organized thus:

 *	    function code

 *	    VUD block

 *	    key block

 */

struct CPRB {

	unsigned short cprb_len;	/* CPRB length			 */

	unsigned char cprb_ver_id;	/* CPRB version id.		 */

	unsigned char pad_000;		/* Alignment pad byte.		 */

	unsigned char srpi_rtcode[4];	/* SRPI return code LELONG	 */

	unsigned char srpi_verb;	/* SRPI verb type		 */

	unsigned char flags;		/* flags			 */

	unsigned char func_id[2];	/* function id			 */

	unsigned char checkpoint_flag;	/*				 */

	unsigned char resv2;		/* reserved			 */

	unsigned short req_parml;	/* request parameter buffer	 */

					/* length 16-bit little endian	 */

	unsigned char req_parmp[4];	/* request parameter buffer	 *

					 * pointer (means nothing: the	 *

					 * parameter buffer follows	 *

					 * the CPRB).			 */

	unsigned char req_datal[4];	/* request data buffer		 */

					/* length	  ULELONG	 */

	unsigned char req_datap[4];	/* request data buffer		 */

					/* pointer			 */

	unsigned short rpl_parml;	/* reply  parameter buffer	 */

					/* length 16-bit little endian	 */

	unsigned char pad_001[2];	/* Alignment pad bytes. ULESHORT */

	unsigned char rpl_parmp[4];	/* reply parameter buffer	 *

					 * pointer (means nothing: the	 *

					 * parameter buffer follows	 *

					 * the CPRB).			 */

	unsigned char rpl_datal[4];	/* reply data buffer len ULELONG */

	unsigned char rpl_datap[4];	/* reply data buffer		 */

					/* pointer			 */

	unsigned short ccp_rscode;	/* server reason code	ULESHORT */

	unsigned short ccp_rtcode;	/* server return code	ULESHORT */

	unsigned char repd_parml[2];	/* replied parameter len ULESHORT*/

	unsigned char mac_data_len[2];	/* Mac Data Length	ULESHORT */

	unsigned char repd_datal[4];	/* replied data length	ULELONG	 */

	unsigned char req_pc[2];	/* PC identifier		 */

	unsigned char res_origin[8];	/* resource origin		 */

	unsigned char mac_value[8];	/* Mac Value			 */

	unsigned char logon_id[8];	/* Logon Identifier		 */

	unsigned char usage_domain[2];	/* cdx				 */

	unsigned char resv3[18];	/* reserved for requestor	 */

	unsigned short svr_namel;	/* server name length  ULESHORT	 */

	unsigned char svr_name[8];	/* server name			 */

} __attribute__((packed));

/**

 * The type 86 message family is associated with PCICC and PCIXCC cards.

 *

 * It contains a message header followed by a CPRB.  The CPRB is

 * the same as the request CPRB, which is described above.

 *

 * If format is 1, an error condition exists and no data beyond

 * the 8-byte message header is of interest.

 *

 * The non-error message is shown below.

 *

 * Note that all reserved fields must be zeroes.

 */

struct type86_hdr {

	unsigned char reserved1;	/* 0x00				*/

	unsigned char type;		/* 0x86				*/

	unsigned char format;		/* 0x01 (error) or 0x02 (ok)	*/

	unsigned char reserved2;	/* 0x00				*/

	unsigned char reply_code;	/* reply code (see above)	*/

	unsigned char reserved3[3];	/* 0x000000			*/

} __attribute__((packed));

#define TYPE86_RSP_CODE 0x86

#define TYPE86_FMT2	0x02

struct type86_fmt2_ext {

	unsigned char	  reserved[4];	/* 0x00000000			*/

	unsigned char	  apfs[4];	/* final status			*/

	unsigned int	  count1;	/* length of CPRB + parameters	*/

	unsigned int	  offset1;	/* offset to CPRB		*/

	unsigned int	  count2;	/* 0x00000000			*/

	unsigned int	  offset2;	/* db offset 0x00000000 for PKD	*/

	unsigned int	  count3;	/* 0x00000000			*/

	unsigned int	  offset3;	/* 0x00000000			*/

	unsigned int	  count4;	/* 0x00000000			*/

	unsigned int	  offset4;	/* 0x00000000			*/

} __attribute__((packed));

struct function_and_rules_block {

	unsigned char function_code[2];

	unsigned short ulen;

	unsigned char only_rule[8];

} __attribute__((packed));

int zcrypt_pcicc_init(void);

void zcrypt_pcicc_exit(void);

#endif /* _ZCRYPT_PCICC_H_ */

/*

 *  linux/drivers/s390/crypto/zcrypt_pcixcc.h

 *

 *  zcrypt 2.0.0

 *

 *  Copyright (C)  2001, 2006 IBM Corporation

 *  Author(s): Robert Burroughs

 *	       Eric Rossman (edrossma@us.ibm.com)

 *

 *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)

 *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#ifndef _ZCRYPT_PCIXCC_H_

#define _ZCRYPT_PCIXCC_H_

/**

 * CPRBX

 *	  Note that all shorts and ints are big-endian.

 *	  All pointer fields are 16 bytes long, and mean nothing.

 *

 *	  A request CPRB is followed by a request_parameter_block.

 *

 *	  The request (or reply) parameter block is organized thus:

 *	    function code

 *	    VUD block

 *	    key block

 */

struct CPRBX {

	unsigned short cprb_len;	/* CPRB length	      220	 */

	unsigned char  cprb_ver_id;	/* CPRB version id.   0x02	 */

	unsigned char  pad_000[3];	/* Alignment pad bytes		 */

	unsigned char  func_id[2];	/* function id	      0x5432	 */

	unsigned char  cprb_flags[4];	/* Flags			 */

	unsigned int   req_parml;	/* request parameter buffer len	 */

	unsigned int   req_datal;	/* request data buffer		 */

	unsigned int   rpl_msgbl;	/* reply  message block length	 */

	unsigned int   rpld_parml;	/* replied parameter block len	 */

	unsigned int   rpl_datal;	/* reply data block len		 */

	unsigned int   rpld_datal;	/* replied data block len	 */

	unsigned int   req_extbl;	/* request extension block len	 */

	unsigned char  pad_001[4];	/* reserved			 */

	unsigned int   rpld_extbl;	/* replied extension block len	 */

	unsigned char  req_parmb[16];	/* request parm block 'address'	 */

	unsigned char  req_datab[16];	/* request data block 'address'	 */

	unsigned char  rpl_parmb[16];	/* reply parm block 'address'	 */

	unsigned char  rpl_datab[16];	/* reply data block 'address'	 */

	unsigned char  req_extb[16];	/* request extension block 'addr'*/

	unsigned char  rpl_extb[16];	/* reply extension block 'addres'*/

	unsigned short ccp_rtcode;	/* server return code		 */

	unsigned short ccp_rscode;	/* server reason code		 */

	unsigned int   mac_data_len;	/* Mac Data Length		 */

	unsigned char  logon_id[8];	/* Logon Identifier		 */

	unsigned char  mac_value[8];	/* Mac Value			 */

	unsigned char  mac_content_flgs;/* Mac content flag byte	 */

	unsigned char  pad_002;		/* Alignment			 */

	unsigned short domain;		/* Domain			 */

	unsigned char  pad_003[12];	/* Domain masks			 */

	unsigned char  pad_004[36];	/* reserved			 */

} __attribute__((packed));

int zcrypt_pcixcc_init(void);

void zcrypt_pcixcc_exit(void);

#endif /* _ZCRYPT_PCIXCC_H_ */