Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 88fbf183 authored by Eric Rossman's avatar Eric Rossman Committed by Linus Torvalds
Browse files

[PATCH] s390: add support for cex2a crypto cards 



Signed-off-by: default avatarEric Rossman <edrossma@us.ibm.com>
Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent fb6958a5

drivers/s390/crypto/z90common.h

+5 −4
Original line number Diff line number Diff line 
/*

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

 *

 *  z90crypt 1.3.2

 *  z90crypt 1.3.3

 *

 *  Copyright (C)  2001, 2004 IBM Corporation

 *  Copyright (C)  2001, 2005 IBM Corporation

 *  Author(s): Robert Burroughs (burrough@us.ibm.com)

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

 *
@@ -91,12 +91,13 @@ enum hdstat { 
#define TSQ_FATAL_ERROR 34

#define RSQ_FATAL_ERROR 35



#define Z90CRYPT_NUM_TYPES	5

#define Z90CRYPT_NUM_TYPES	6

#define PCICA		0

#define PCICC		1

#define PCIXCC_MCL2	2

#define PCIXCC_MCL3	3

#define CEX2C		4

#define CEX2A		5

#define NILDEV		-1

#define ANYDEV		-1

#define PCIXCC_UNK	-2
@@ -105,7 +106,7 @@ enum hdevice_type { 
	PCICC_HW  = 3,

	PCICA_HW  = 4,

	PCIXCC_HW = 5,

	OTHER_HW  = 6,

	CEX2A_HW  = 6,

	CEX2C_HW  = 7

};

drivers/s390/crypto/z90crypt.h

+9 −4
Original line number Diff line number Diff line 
/*

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

 *

 *  z90crypt 1.3.2

 *  z90crypt 1.3.3

 *

 *  Copyright (C)  2001, 2004 IBM Corporation

 *  Copyright (C)  2001, 2005 IBM Corporation

 *  Author(s): Robert Burroughs (burrough@us.ibm.com)

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

 *
@@ -29,11 +29,11 @@ 


#include <linux/ioctl.h>



#define VERSION_Z90CRYPT_H "$Revision: 1.11 $"

#define VERSION_Z90CRYPT_H "$Revision: 1.2.2.4 $"



#define z90crypt_VERSION 1

#define z90crypt_RELEASE 3	// 2 = PCIXCC, 3 = rewrite for coding standards

#define z90crypt_VARIANT 2	// 2 = added PCIXCC MCL3 and CEX2C support

#define z90crypt_VARIANT 3	// 3 = CEX2A support



/**

 * struct ica_rsa_modexpo
@@ -122,6 +122,9 @@ struct ica_rsa_modexpo_crt { 
 *   Z90STAT_CEX2CCOUNT

 *     Return an integer count of all CEX2Cs.

 *

 *   Z90STAT_CEX2ACOUNT

 *     Return an integer count of all CEX2As.

 *

 *   Z90STAT_REQUESTQ_COUNT

 *     Return an integer count of the number of entries waiting to be

 *     sent to a device.
@@ -144,6 +147,7 @@ struct ica_rsa_modexpo_crt { 
 *       0x03: PCIXCC_MCL2

 *       0x04: PCIXCC_MCL3

 *       0x05: CEX2C

 *       0x06: CEX2A

 *       0x0d: device is disabled via the proc filesystem

 *

 *   Z90STAT_QDEPTH_MASK
@@ -199,6 +203,7 @@ struct ica_rsa_modexpo_crt { 
#define Z90STAT_PCIXCCMCL2COUNT	_IOR(Z90_IOCTL_MAGIC, 0x4b, int)

#define Z90STAT_PCIXCCMCL3COUNT	_IOR(Z90_IOCTL_MAGIC, 0x4c, int)

#define Z90STAT_CEX2CCOUNT	_IOR(Z90_IOCTL_MAGIC, 0x4d, int)

#define Z90STAT_CEX2ACOUNT	_IOR(Z90_IOCTL_MAGIC, 0x4e, int)

#define Z90STAT_REQUESTQ_COUNT	_IOR(Z90_IOCTL_MAGIC, 0x44, int)

#define Z90STAT_PENDINGQ_COUNT	_IOR(Z90_IOCTL_MAGIC, 0x45, int)

#define Z90STAT_TOTALOPEN_COUNT _IOR(Z90_IOCTL_MAGIC, 0x46, int)

drivers/s390/crypto/z90hardware.c

+293 −8
Original line number Diff line number Diff line 
/*

 *  linux/drivers/s390/crypto/z90hardware.c

 *

 *  z90crypt 1.3.2

 *  z90crypt 1.3.3

 *

 *  Copyright (C)  2001, 2004 IBM Corporation

 *  Copyright (C)  2001, 2005 IBM Corporation

 *  Author(s): Robert Burroughs (burrough@us.ibm.com)

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

 *
@@ -648,6 +648,87 @@ static struct cca_public_sec static_cca_pub_sec = { 
#define RESPONSE_CPRB_SIZE  0x000006B8

#define RESPONSE_CPRBX_SIZE 0x00000724



struct type50_hdr {

	u8    reserved1;

	u8    msg_type_code;

	u16   msg_len;

	u8    reserved2;

	u8    ignored;

	u16   reserved3;

};



#define TYPE50_TYPE_CODE 0x50



#define TYPE50_MEB1_LEN (sizeof(struct type50_meb1_msg))

#define TYPE50_MEB2_LEN (sizeof(struct type50_meb2_msg))

#define TYPE50_CRB1_LEN (sizeof(struct type50_crb1_msg))

#define TYPE50_CRB2_LEN (sizeof(struct type50_crb2_msg))



#define TYPE50_MEB1_FMT 0x0001

#define TYPE50_MEB2_FMT 0x0002

#define TYPE50_CRB1_FMT 0x0011

#define TYPE50_CRB2_FMT 0x0012



struct type50_meb1_msg {

	struct type50_hdr	header;

	u16			keyblock_type;

	u8			reserved[6];

	u8			exponent[128];

	u8			modulus[128];

	u8			message[128];

};



struct type50_meb2_msg {

	struct type50_hdr	header;

	u16			keyblock_type;

	u8			reserved[6];

	u8			exponent[256];

	u8			modulus[256];

	u8			message[256];

};



struct type50_crb1_msg {

	struct type50_hdr	header;

	u16			keyblock_type;

	u8			reserved[6];

	u8			p[64];

	u8			q[64];

	u8			dp[64];

	u8			dq[64];

	u8			u[64];

	u8			message[128];

};



struct type50_crb2_msg {

	struct type50_hdr	header;

	u16			keyblock_type;

	u8			reserved[6];

	u8			p[128];

	u8			q[128];

	u8			dp[128];

	u8			dq[128];

	u8			u[128];

	u8			message[256];

};



union type50_msg {

	struct type50_meb1_msg meb1;

	struct type50_meb2_msg meb2;

	struct type50_crb1_msg crb1;

	struct type50_crb2_msg crb2;

};



struct type80_hdr {

	u8	reserved1;

	u8	type;

	u16	len;

	u8	code;

	u8	reserved2[3];

	u8	reserved3[8];

};



#define TYPE80_RSP_CODE 0x80



struct error_hdr {

	unsigned char reserved1;

	unsigned char type;
@@ -657,6 +738,7 @@ struct error_hdr { 
};



#define TYPE82_RSP_CODE 0x82

#define TYPE88_RSP_CODE 0x88



#define REP82_ERROR_MACHINE_FAILURE  0x10

#define REP82_ERROR_PREEMPT_FAILURE  0x12
@@ -679,6 +761,22 @@ struct error_hdr { 
#define REP82_ERROR_PACKET_TRUNCATED 0xA0

#define REP82_ERROR_ZERO_BUFFER_LEN  0xB0



#define REP88_ERROR_MODULE_FAILURE   0x10

#define REP88_ERROR_MODULE_TIMEOUT   0x11

#define REP88_ERROR_MODULE_NOTINIT   0x13

#define REP88_ERROR_MODULE_NOTAVAIL  0x14

#define REP88_ERROR_MODULE_DISABLED  0x15

#define REP88_ERROR_MODULE_IN_DIAGN  0x17

#define REP88_ERROR_FASTPATH_DISABLD 0x19

#define REP88_ERROR_MESSAGE_TYPE     0x20

#define REP88_ERROR_MESSAGE_MALFORMD 0x22

#define REP88_ERROR_MESSAGE_LENGTH   0x23

#define REP88_ERROR_RESERVED_FIELD   0x24

#define REP88_ERROR_KEY_TYPE         0x34

#define REP88_ERROR_INVALID_KEY      0x82

#define REP88_ERROR_OPERAND          0x84

#define REP88_ERROR_OPERAND_EVEN_MOD 0x85



#define CALLER_HEADER 12



static inline int
@@ -1029,10 +1127,6 @@ query_online(int deviceNr, int cdx, int resetNr, int *q_depth, int *dev_type) 
			stat = HD_ONLINE;

			*q_depth = t_depth + 1;

			switch (t_dev_type) {

			case OTHER_HW:

				stat = HD_NOT_THERE;

				*dev_type = NILDEV;

				break;

			case PCICA_HW:

				*dev_type = PCICA;

				break;
@@ -1045,6 +1139,9 @@ query_online(int deviceNr, int cdx, int resetNr, int *q_depth, int *dev_type) 
			case CEX2C_HW:

				*dev_type = CEX2C;

				break;

			case CEX2A_HW:

				*dev_type = CEX2A;

				break;

			default:

				*dev_type = NILDEV;

				break;
@@ -2029,6 +2126,177 @@ ICACRT_msg_to_type6CRT_msgX(struct ica_rsa_modexpo_crt *icaMsg_p, int cdx, 
	return 0;

}



static int

ICAMEX_msg_to_type50MEX_msg(struct ica_rsa_modexpo *icaMex_p, int *z90cMsg_l_p,

			    union type50_msg *z90cMsg_p)

{

	int mod_len, msg_size, mod_tgt_len, exp_tgt_len, inp_tgt_len;

	unsigned char *mod_tgt, *exp_tgt, *inp_tgt;

	union type50_msg *tmp_type50_msg;



	mod_len = icaMex_p->inputdatalength;



	msg_size = ((mod_len <= 128) ? TYPE50_MEB1_LEN : TYPE50_MEB2_LEN) +

		    CALLER_HEADER;



	memset(z90cMsg_p, 0, msg_size);



	tmp_type50_msg = (union type50_msg *)

		((unsigned char *) z90cMsg_p + CALLER_HEADER);



	tmp_type50_msg->meb1.header.msg_type_code = TYPE50_TYPE_CODE;



	if (mod_len <= 128) {

		tmp_type50_msg->meb1.header.msg_len = TYPE50_MEB1_LEN;

		tmp_type50_msg->meb1.keyblock_type = TYPE50_MEB1_FMT;

		mod_tgt = tmp_type50_msg->meb1.modulus;

		mod_tgt_len = sizeof(tmp_type50_msg->meb1.modulus);

		exp_tgt = tmp_type50_msg->meb1.exponent;

		exp_tgt_len = sizeof(tmp_type50_msg->meb1.exponent);

		inp_tgt = tmp_type50_msg->meb1.message;

		inp_tgt_len = sizeof(tmp_type50_msg->meb1.message);

	} else {

		tmp_type50_msg->meb2.header.msg_len = TYPE50_MEB2_LEN;

		tmp_type50_msg->meb2.keyblock_type = TYPE50_MEB2_FMT;

		mod_tgt = tmp_type50_msg->meb2.modulus;

		mod_tgt_len = sizeof(tmp_type50_msg->meb2.modulus);

		exp_tgt = tmp_type50_msg->meb2.exponent;

		exp_tgt_len = sizeof(tmp_type50_msg->meb2.exponent);

		inp_tgt = tmp_type50_msg->meb2.message;

		inp_tgt_len = sizeof(tmp_type50_msg->meb2.message);

	}



	mod_tgt += (mod_tgt_len - mod_len);

	if (copy_from_user(mod_tgt, icaMex_p->n_modulus, mod_len))

		return SEN_RELEASED;

	if (is_empty(mod_tgt, mod_len))

		return SEN_USER_ERROR;

	exp_tgt += (exp_tgt_len - mod_len);

	if (copy_from_user(exp_tgt, icaMex_p->b_key, mod_len))

		return SEN_RELEASED;

	if (is_empty(exp_tgt, mod_len))

		return SEN_USER_ERROR;

	inp_tgt += (inp_tgt_len - mod_len);

	if (copy_from_user(inp_tgt, icaMex_p->inputdata, mod_len))

		return SEN_RELEASED;

	if (is_empty(inp_tgt, mod_len))

		return SEN_USER_ERROR;



	*z90cMsg_l_p = msg_size - CALLER_HEADER;



	return 0;

}



static int

ICACRT_msg_to_type50CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p,

			    int *z90cMsg_l_p, union type50_msg *z90cMsg_p)

{

	int mod_len, short_len, long_len, tmp_size, p_tgt_len, q_tgt_len,

	    dp_tgt_len, dq_tgt_len, u_tgt_len, inp_tgt_len, long_offset;

	unsigned char *p_tgt, *q_tgt, *dp_tgt, *dq_tgt, *u_tgt, *inp_tgt,

		      temp[8];

	union type50_msg *tmp_type50_msg;



	mod_len = icaMsg_p->inputdatalength;

	short_len = mod_len / 2;

	long_len = mod_len / 2 + 8;

	long_offset = 0;



	if (long_len > 128) {

		memset(temp, 0x00, sizeof(temp));

		if (copy_from_user(temp, icaMsg_p->np_prime, long_len-128))

			return SEN_RELEASED;

		if (!is_empty(temp, 8))

			return SEN_NOT_AVAIL;

		if (copy_from_user(temp, icaMsg_p->bp_key, long_len-128))

			return SEN_RELEASED;

		if (!is_empty(temp, 8))

			return SEN_NOT_AVAIL;

		if (copy_from_user(temp, icaMsg_p->u_mult_inv, long_len-128))

			return SEN_RELEASED;

		if (!is_empty(temp, 8))

			return SEN_NOT_AVAIL;

		long_offset = long_len - 128;

		long_len = 128;

	}



	tmp_size = ((mod_len <= 128) ? TYPE50_CRB1_LEN : TYPE50_CRB2_LEN) +

		    CALLER_HEADER;



	memset(z90cMsg_p, 0, tmp_size);



	tmp_type50_msg = (union type50_msg *)

		((unsigned char *) z90cMsg_p + CALLER_HEADER);



	tmp_type50_msg->crb1.header.msg_type_code = TYPE50_TYPE_CODE;

	if (long_len <= 64) {

		tmp_type50_msg->crb1.header.msg_len = TYPE50_CRB1_LEN;

		tmp_type50_msg->crb1.keyblock_type = TYPE50_CRB1_FMT;

		p_tgt = tmp_type50_msg->crb1.p;

		p_tgt_len = sizeof(tmp_type50_msg->crb1.p);

		q_tgt = tmp_type50_msg->crb1.q;

		q_tgt_len = sizeof(tmp_type50_msg->crb1.q);

		dp_tgt = tmp_type50_msg->crb1.dp;

		dp_tgt_len = sizeof(tmp_type50_msg->crb1.dp);

		dq_tgt = tmp_type50_msg->crb1.dq;

		dq_tgt_len = sizeof(tmp_type50_msg->crb1.dq);

		u_tgt = tmp_type50_msg->crb1.u;

		u_tgt_len = sizeof(tmp_type50_msg->crb1.u);

		inp_tgt = tmp_type50_msg->crb1.message;

		inp_tgt_len = sizeof(tmp_type50_msg->crb1.message);

	} else {

		tmp_type50_msg->crb2.header.msg_len = TYPE50_CRB2_LEN;

		tmp_type50_msg->crb2.keyblock_type = TYPE50_CRB2_FMT;

		p_tgt = tmp_type50_msg->crb2.p;

		p_tgt_len = sizeof(tmp_type50_msg->crb2.p);

		q_tgt = tmp_type50_msg->crb2.q;

		q_tgt_len = sizeof(tmp_type50_msg->crb2.q);

		dp_tgt = tmp_type50_msg->crb2.dp;

		dp_tgt_len = sizeof(tmp_type50_msg->crb2.dp);

		dq_tgt = tmp_type50_msg->crb2.dq;

		dq_tgt_len = sizeof(tmp_type50_msg->crb2.dq);

		u_tgt = tmp_type50_msg->crb2.u;

		u_tgt_len = sizeof(tmp_type50_msg->crb2.u);

		inp_tgt = tmp_type50_msg->crb2.message;

		inp_tgt_len = sizeof(tmp_type50_msg->crb2.message);

	}



	p_tgt += (p_tgt_len - long_len);

	if (copy_from_user(p_tgt, icaMsg_p->np_prime + long_offset, long_len))

		return SEN_RELEASED;

	if (is_empty(p_tgt, long_len))

		return SEN_USER_ERROR;

	q_tgt += (q_tgt_len - short_len);

	if (copy_from_user(q_tgt, icaMsg_p->nq_prime, short_len))

		return SEN_RELEASED;

	if (is_empty(q_tgt, short_len))

		return SEN_USER_ERROR;

	dp_tgt += (dp_tgt_len - long_len);

	if (copy_from_user(dp_tgt, icaMsg_p->bp_key + long_offset, long_len))

		return SEN_RELEASED;

	if (is_empty(dp_tgt, long_len))

		return SEN_USER_ERROR;

	dq_tgt += (dq_tgt_len - short_len);

	if (copy_from_user(dq_tgt, icaMsg_p->bq_key, short_len))

		return SEN_RELEASED;

	if (is_empty(dq_tgt, short_len))

		return SEN_USER_ERROR;

	u_tgt += (u_tgt_len - long_len);

	if (copy_from_user(u_tgt, icaMsg_p->u_mult_inv + long_offset, long_len))

		return SEN_RELEASED;

	if (is_empty(u_tgt, long_len))

		return SEN_USER_ERROR;

	inp_tgt += (inp_tgt_len - mod_len);

	if (copy_from_user(inp_tgt, icaMsg_p->inputdata, mod_len))

		return SEN_RELEASED;

	if (is_empty(inp_tgt, mod_len))

		return SEN_USER_ERROR;



	*z90cMsg_l_p = tmp_size - CALLER_HEADER;



	return 0;

}



int

convert_request(unsigned char *buffer, int func, unsigned short function,

		int cdx, int dev_type, int *msg_l_p, unsigned char *msg_p)
@@ -2071,6 +2339,16 @@ convert_request(unsigned char *buffer, int func, unsigned short function, 
				cdx, msg_l_p, (struct type6_msg *) msg_p,

				dev_type);

	}

	if (dev_type == CEX2A) {

		if (func == ICARSACRT)

			return ICACRT_msg_to_type50CRT_msg(

				(struct ica_rsa_modexpo_crt *) buffer,

				msg_l_p, (union type50_msg *) msg_p);

		else

			return ICAMEX_msg_to_type50MEX_msg(

				(struct ica_rsa_modexpo *) buffer,

				msg_l_p, (union type50_msg *) msg_p);

	}



	return 0;

}
@@ -2081,8 +2359,8 @@ unset_ext_bitlens(void) 
{

	if (!ext_bitlens_msg_count) {

		PRINTK("Unable to use coprocessors for extended bitlengths. "

		       "Using PCICAs (if present) for extended bitlengths. "

		       "This is not an error.\n");

		       "Using PCICAs/CEX2As (if present) for extended "

		       "bitlengths. This is not an error.\n");

		ext_bitlens_msg_count++;

	}

	ext_bitlens = 0;
@@ -2094,6 +2372,7 @@ convert_response(unsigned char *response, unsigned char *buffer, 
{

	struct ica_rsa_modexpo *icaMsg_p = (struct ica_rsa_modexpo *) buffer;

	struct error_hdr *errh_p = (struct error_hdr *) response;

	struct type80_hdr *t80h_p = (struct type80_hdr *) response;

	struct type84_hdr *t84h_p = (struct type84_hdr *) response;

	struct type86_fmt2_msg *t86m_p =  (struct type86_fmt2_msg *) response;

	int reply_code, service_rc, service_rs, src_l;
@@ -2108,6 +2387,7 @@ convert_response(unsigned char *response, unsigned char *buffer, 
	src_l = 0;

	switch (errh_p->type) {

	case TYPE82_RSP_CODE:

	case TYPE88_RSP_CODE:

		reply_code = errh_p->reply_code;

		src_p = (unsigned char *)errh_p;

		PRINTK("Hardware error: Type %02X Message Header: "
@@ -2116,6 +2396,10 @@ convert_response(unsigned char *response, unsigned char *buffer, 
		       src_p[0], src_p[1], src_p[2], src_p[3],

		       src_p[4], src_p[5], src_p[6], src_p[7]);

		break;

	case TYPE80_RSP_CODE:

		src_l = icaMsg_p->outputdatalength;

		src_p = response + (int)t80h_p->len - src_l;

		break;

	case TYPE84_RSP_CODE:

		src_l = icaMsg_p->outputdatalength;

		src_p = response + (int)t84h_p->len - src_l;
@@ -2202,6 +2486,7 @@ convert_response(unsigned char *response, unsigned char *buffer, 
	if (reply_code)

		switch (reply_code) {

		case REP82_ERROR_OPERAND_INVALID:

		case REP88_ERROR_MESSAGE_MALFORMD:

			return REC_OPERAND_INV;

		case REP82_ERROR_OPERAND_SIZE:

			return REC_OPERAND_SIZE;

drivers/s390/crypto/z90main.c

+76 −35
Original line number Diff line number Diff line
@@ -228,7 +228,7 @@ struct device_x { 
 */

struct device {

	int		 dev_type;	    // PCICA, PCICC, PCIXCC_MCL2,

					    // PCIXCC_MCL3, CEX2C

					    // PCIXCC_MCL3, CEX2C, CEX2A

	enum devstat	 dev_stat;	    // current device status

	int		 dev_self_x;	    // Index in array

	int		 disabled;	    // Set when device is in error
@@ -295,26 +295,30 @@ struct caller { 
/**

 * Function prototypes from z90hardware.c

 */

enum hdstat query_online(int, int, int, int *, int *);

enum devstat reset_device(int, int, int);

enum devstat send_to_AP(int, int, int, unsigned char *);

enum devstat receive_from_AP(int, int, int, unsigned char *, unsigned char *);

int convert_request(unsigned char *, int, short, int, int, int *,

		    unsigned char *);

int convert_response(unsigned char *, unsigned char *, int *, unsigned char *);

enum hdstat query_online(int deviceNr, int cdx, int resetNr, int *q_depth,

			 int *dev_type);

enum devstat reset_device(int deviceNr, int cdx, int resetNr);

enum devstat send_to_AP(int dev_nr, int cdx, int msg_len, unsigned char *msg_ext);

enum devstat receive_from_AP(int dev_nr, int cdx, int resplen,

			     unsigned char *resp, unsigned char *psmid);

int convert_request(unsigned char *buffer, int func, unsigned short function,

		    int cdx, int dev_type, int *msg_l_p, unsigned char *msg_p);

int convert_response(unsigned char *response, unsigned char *buffer,

		     int *respbufflen_p, unsigned char *resp_buff);



/**

 * Low level function prototypes

 */

static int create_z90crypt(int *);

static int refresh_z90crypt(int *);

static int find_crypto_devices(struct status *);

static int create_crypto_device(int);

static int destroy_crypto_device(int);

static int create_z90crypt(int *cdx_p);

static int refresh_z90crypt(int *cdx_p);

static int find_crypto_devices(struct status *deviceMask);

static int create_crypto_device(int index);

static int destroy_crypto_device(int index);

static void destroy_z90crypt(void);

static int refresh_index_array(struct status *, struct device_x *);

static int probe_device_type(struct device *);

static int probe_PCIXCC_type(struct device *);

static int refresh_index_array(struct status *status_str,

			       struct device_x *index_array);

static int probe_device_type(struct device *devPtr);

static int probe_PCIXCC_type(struct device *devPtr);



/**

 * proc fs definitions
@@ -425,7 +429,7 @@ static struct miscdevice z90crypt_misc_device = { 
MODULE_AUTHOR("zSeries Linux Crypto Team: Robert H. Burroughs, Eric D. Rossman"

	      "and Jochen Roehrig");

MODULE_DESCRIPTION("zSeries Linux Cryptographic Coprocessor device driver, "

		   "Copyright 2001, 2004 IBM Corporation");

		   "Copyright 2001, 2005 IBM Corporation");

MODULE_LICENSE("GPL");

module_param(domain, int, 0);

MODULE_PARM_DESC(domain, "domain index for device");
@@ -859,6 +863,12 @@ get_status_CEX2Ccount(void) 
	return z90crypt.hdware_info->type_mask[CEX2C].st_count;

}



static inline int

get_status_CEX2Acount(void)

{

	return z90crypt.hdware_info->type_mask[CEX2A].st_count;

}



static inline int

get_status_requestq_count(void)

{
@@ -1008,11 +1018,13 @@ static inline int 
select_device_type(int *dev_type_p, int bytelength)

{

	static int count = 0;

	int PCICA_avail, PCIXCC_MCL3_avail, CEX2C_avail, index_to_use;

	int PCICA_avail, PCIXCC_MCL3_avail, CEX2C_avail, CEX2A_avail,

	    index_to_use;

	struct status *stat;

	if ((*dev_type_p != PCICC) && (*dev_type_p != PCICA) &&

	    (*dev_type_p != PCIXCC_MCL2) && (*dev_type_p != PCIXCC_MCL3) &&

	    (*dev_type_p != CEX2C) && (*dev_type_p != ANYDEV))

	    (*dev_type_p != CEX2C) && (*dev_type_p != CEX2A) &&

	    (*dev_type_p != ANYDEV))

		return -1;

	if (*dev_type_p != ANYDEV) {

		stat = &z90crypt.hdware_info->type_mask[*dev_type_p];
@@ -1022,7 +1034,13 @@ select_device_type(int *dev_type_p, int bytelength) 
		return -1;

	}



	/* Assumption: PCICA, PCIXCC_MCL3, and CEX2C are all similar in speed */

	/**

	 * Assumption: PCICA, PCIXCC_MCL3, CEX2C, and CEX2A are all similar in

	 * speed.

	 *

	 * PCICA and CEX2A do NOT co-exist, so it would be either one or the

	 * other present.

	 */

	stat = &z90crypt.hdware_info->type_mask[PCICA];

	PCICA_avail = stat->st_count -

			(stat->disabled_count + stat->user_disabled_count);
@@ -1032,29 +1050,38 @@ select_device_type(int *dev_type_p, int bytelength) 
	stat = &z90crypt.hdware_info->type_mask[CEX2C];

	CEX2C_avail = stat->st_count -

			(stat->disabled_count + stat->user_disabled_count);

	if (PCICA_avail || PCIXCC_MCL3_avail || CEX2C_avail) {

	stat = &z90crypt.hdware_info->type_mask[CEX2A];

	CEX2A_avail = stat->st_count -

			(stat->disabled_count + stat->user_disabled_count);

	if (PCICA_avail || PCIXCC_MCL3_avail || CEX2C_avail || CEX2A_avail) {

		/**

		 * bitlength is a factor, PCICA is the most capable, even with

		 * the new MCL for PCIXCC.

		 * bitlength is a factor, PCICA or CEX2A are the most capable,

		 * even with the new MCL for PCIXCC.

		 */

		if ((bytelength < PCIXCC_MIN_MOD_SIZE) ||

		    (!ext_bitlens && (bytelength < OLD_PCIXCC_MIN_MOD_SIZE))) {

			if (!PCICA_avail)

				return -1;

			else {

			if (PCICA_avail) {

				*dev_type_p = PCICA;

				return 0;

			}

			if (CEX2A_avail) {

				*dev_type_p = CEX2A;

				return 0;

			}

			return -1;

		}



		index_to_use = count % (PCICA_avail + PCIXCC_MCL3_avail +

					CEX2C_avail);

					CEX2C_avail + CEX2A_avail);

		if (index_to_use < PCICA_avail)

			*dev_type_p = PCICA;

		else if (index_to_use < (PCICA_avail + PCIXCC_MCL3_avail))

			*dev_type_p = PCIXCC_MCL3;

		else

		else if (index_to_use < (PCICA_avail + PCIXCC_MCL3_avail +

					 CEX2C_avail))

			*dev_type_p = CEX2C;

		else

			*dev_type_p = CEX2A;

		count++;

		return 0;

	}
@@ -1359,7 +1386,7 @@ build_caller(struct work_element *we_p, short function) 


	if ((we_p->devtype != PCICC) && (we_p->devtype != PCICA) &&

	    (we_p->devtype != PCIXCC_MCL2) && (we_p->devtype != PCIXCC_MCL3) &&

	    (we_p->devtype != CEX2C))

	    (we_p->devtype != CEX2C) && (we_p->devtype != CEX2A))

		return SEN_NOT_AVAIL;



	memcpy(caller_p->caller_id, we_p->caller_id,
@@ -1428,7 +1455,8 @@ get_crypto_request_buffer(struct work_element *we_p) 


	if ((we_p->devtype != PCICA) && (we_p->devtype != PCICC) &&

	    (we_p->devtype != PCIXCC_MCL2) && (we_p->devtype != PCIXCC_MCL3) &&

	    (we_p->devtype != CEX2C) && (we_p->devtype != ANYDEV)) {

	    (we_p->devtype != CEX2C) && (we_p->devtype != CEX2A) &&

	    (we_p->devtype != ANYDEV)) {

		PRINTK("invalid device type\n");

		return SEN_USER_ERROR;

	}
@@ -1503,8 +1531,9 @@ get_crypto_request_buffer(struct work_element *we_p) 


	function = PCI_FUNC_KEY_ENCRYPT;

	switch (we_p->devtype) {

	/* PCICA does everything with a simple RSA mod-expo operation */

	/* PCICA and CEX2A do everything with a simple RSA mod-expo operation */

	case PCICA:

	case CEX2A:

		function = PCI_FUNC_KEY_ENCRYPT;

		break;

	/**
@@ -1662,7 +1691,8 @@ z90crypt_rsa(struct priv_data *private_data_p, pid_t pid, 
		 * trigger a fallback to software.

		 */

		case -EINVAL:

			if (we_p->devtype != PCICA)

			if ((we_p->devtype != PCICA) &&

			    (we_p->devtype != CEX2A))

				rv = -EGETBUFF;

			break;

		case -ETIMEOUT:
@@ -1779,6 +1809,12 @@ z90crypt_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 
			ret = -EFAULT;

		break;



	case Z90STAT_CEX2ACOUNT:

		tempstat = get_status_CEX2Acount();

		if (copy_to_user((int __user *)arg, &tempstat, sizeof(int)) != 0)

			ret = -EFAULT;

		break;



	case Z90STAT_REQUESTQ_COUNT:

		tempstat = get_status_requestq_count();

		if (copy_to_user((int __user *)arg, &tempstat, sizeof(int)) != 0)
@@ -2019,6 +2055,8 @@ z90crypt_status(char *resp_buff, char **start, off_t offset, 
		get_status_PCIXCCMCL3count());

	len += sprintf(resp_buff+len, "CEX2C count: %d\n",

		get_status_CEX2Ccount());

	len += sprintf(resp_buff+len, "CEX2A count: %d\n",

		get_status_CEX2Acount());

	len += sprintf(resp_buff+len, "requestq count: %d\n",

		get_status_requestq_count());

	len += sprintf(resp_buff+len, "pendingq count: %d\n",
@@ -2026,8 +2064,8 @@ z90crypt_status(char *resp_buff, char **start, off_t offset, 
	len += sprintf(resp_buff+len, "Total open handles: %d\n\n",

		get_status_totalopen_count());

	len += sprinthx(

		"Online devices: 1: PCICA, 2: PCICC, 3: PCIXCC (MCL2), "

		"4: PCIXCC (MCL3), 5: CEX2C",

		"Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "

		"4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A",

		resp_buff+len,

		get_status_status_mask(workarea),

		Z90CRYPT_NUM_APS);
@@ -2140,6 +2178,7 @@ z90crypt_status_write(struct file *file, const char __user *buffer, 
		case '3':	// PCIXCC_MCL2

		case '4':	// PCIXCC_MCL3

		case '5':	// CEX2C

		case '6':       // CEX2A

			j++;

			break;

		case 'd':
@@ -3007,7 +3046,9 @@ create_crypto_device(int index) 
			z90crypt.hdware_info->device_type_array[index] = 4;

		else if (deviceType == CEX2C)

			z90crypt.hdware_info->device_type_array[index] = 5;

		else

		else if (deviceType == CEX2A)

			z90crypt.hdware_info->device_type_array[index] = 6;

		else // No idea how this would happen.

			z90crypt.hdware_info->device_type_array[index] = -1;

	}