s390/zcrypt: remove support for PCICC and PCICA cards (b96a9e51) · Commits · 戴 / test

drivers/s390/crypto/Makefile

+2 −2

Original line number	Diff line number	Diff line
		@@ -3,6 +3,6 @@
		#

		ap-objs := ap_bus.o
		obj-$(CONFIG_ZCRYPT) += ap.o zcrypt_api.o zcrypt_pcicc.o zcrypt_pcixcc.o
		obj-$(CONFIG_ZCRYPT) += zcrypt_pcica.o zcrypt_cex2a.o zcrypt_cex4.o
		obj-$(CONFIG_ZCRYPT) += ap.o zcrypt_api.o zcrypt_pcixcc.o
		obj-$(CONFIG_ZCRYPT) += zcrypt_cex2a.o zcrypt_cex4.o
		obj-$(CONFIG_ZCRYPT) += zcrypt_msgtype6.o zcrypt_msgtype50.o

drivers/s390/crypto/ap_bus.c

+0 −103

Original line number	Diff line number	Diff line
		@@ -1590,103 +1590,6 @@ static int ap_select_domain(void)
		return -ENODEV;
		}

		/**
		* ap_probe_device_type(): Find the device type of an AP.
		* @ap_dev: pointer to the AP device.
		*
		* Find the device type if query queue returned a device type of 0.
		*/
		static int ap_probe_device_type(struct ap_device *ap_dev)
		{
		static unsigned char msg[] = {
		0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
		0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
		0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
		0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
		0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
		0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
		0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
		0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
		0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
		0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
		0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
		0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
		0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
		0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
		0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
		0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
		0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
		0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
		0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
		0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
		0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
		0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
		0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
		0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
		0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
		};
		struct ap_queue_status status;
		unsigned long long psmid;
		char *reply;
		int rc, i;

		reply = (void *) get_zeroed_page(GFP_KERNEL);
		if (!reply) {
		rc = -ENOMEM;
		goto out;
		}

		status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
		msg, sizeof(msg), 0);
		if (status.response_code != AP_RESPONSE_NORMAL) {
		rc = -ENODEV;
		goto out_free;
		}

		/* Wait for the test message to complete. */
		for (i = 0; i < 6; i++) {
		msleep(300);
		status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
		if (status.response_code == AP_RESPONSE_NORMAL &&
		psmid == 0x0102030405060708ULL)
		break;
		}
		if (i < 6) {
		/* Got an answer. */
		if (reply[0] == 0x00 && reply[1] == 0x86)
		ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
		else
		ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
		rc = 0;
		} else
		rc = -ENODEV;

		out_free:
		free_page((unsigned long) reply);
		out:
		return rc;
		}

		/**
		* __ap_scan_bus(): Scan the AP bus.
		* @dev: Pointer to device
		@@ -1750,12 +1653,6 @@ static void ap_scan_bus(struct work_struct *unused)
		INIT_LIST_HEAD(&ap_dev->list);
		setup_timer(&ap_dev->timeout, ap_request_timeout,
		(unsigned long) ap_dev);
		if (ap_dev->device_type == 0)
		/* device type probing for old cards */
		if (ap_probe_device_type(ap_dev)) {
		kfree(ap_dev);
		continue;
		}

		ap_dev->device.bus = &ap_bus_type;
		ap_dev->device.parent = ap_root_device;

drivers/s390/crypto/zcrypt_pcica.c

deleted100644 → 0

+0 −422

Original line number	Diff line number	Diff line
		/*
		* zcrypt 2.1.0
		*
		* Copyright IBM Corp. 2001, 2006
		* 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>
		* Ralph Wuerthner <rwuerthn@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.
		*/

		#define KMSG_COMPONENT "zcrypt"
		#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

		#include <linux/module.h>
		#include <linux/slab.h>
		#include <linux/init.h>
		#include <linux/err.h>
		#include <linux/atomic.h>
		#include <asm/uaccess.h>

		#include "ap_bus.h"
		#include "zcrypt_api.h"
		#include "zcrypt_error.h"
		#include "zcrypt_pcica.h"

		#define PCICA_MIN_MOD_SIZE 1 /* 8 bits */
		#define PCICA_MAX_MOD_SIZE 256 /* 2048 bits */

		#define PCICA_SPEED_RATING 2800

		#define PCICA_MAX_MESSAGE_SIZE 0x3a0 /* sizeof(struct type4_lcr) */
		#define PCICA_MAX_RESPONSE_SIZE 0x110 /* max outputdatalength + type80_hdr */

		#define PCICA_CLEANUP_TIME (15*HZ)

		static struct ap_device_id zcrypt_pcica_ids[] = {
		{ AP_DEVICE(AP_DEVICE_TYPE_PCICA) },
		{ /* end of list */ },
		};

		MODULE_DEVICE_TABLE(ap, zcrypt_pcica_ids);
		MODULE_AUTHOR("IBM Corporation");
		MODULE_DESCRIPTION("PCICA Cryptographic Coprocessor device driver, "
		"Copyright IBM Corp. 2001, 2006");
		MODULE_LICENSE("GPL");

		static int zcrypt_pcica_probe(struct ap_device *ap_dev);
		static void zcrypt_pcica_remove(struct ap_device *ap_dev);
		static void zcrypt_pcica_receive(struct ap_device , struct ap_message ,
		struct ap_message *);

		static struct ap_driver zcrypt_pcica_driver = {
		.probe = zcrypt_pcica_probe,
		.remove = zcrypt_pcica_remove,
		.ids = zcrypt_pcica_ids,
		.request_timeout = PCICA_CLEANUP_TIME,
		};

		/**
		* Convert a ICAMEX message to a type4 MEX message.
		*
		* @zdev: crypto device pointer
		* @zreq: crypto request pointer
		* @mex: pointer to user input data
		*
		* Returns 0 on success or -EFAULT.
		*/
		static int ICAMEX_msg_to_type4MEX_msg(struct zcrypt_device *zdev,
		struct ap_message *ap_msg,
		struct ica_rsa_modexpo *mex)
		{
		unsigned char modulus, exponent, *message;
		int mod_len;

		mod_len = mex->inputdatalength;

		if (mod_len <= 128) {
		struct type4_sme *sme = ap_msg->message;
		memset(sme, 0, sizeof(*sme));
		ap_msg->length = sizeof(*sme);
		sme->header.msg_fmt = TYPE4_SME_FMT;
		sme->header.msg_len = sizeof(*sme);
		sme->header.msg_type_code = TYPE4_TYPE_CODE;
		sme->header.request_code = TYPE4_REQU_CODE;
		modulus = sme->modulus + sizeof(sme->modulus) - mod_len;
		exponent = sme->exponent + sizeof(sme->exponent) - mod_len;
		message = sme->message + sizeof(sme->message) - mod_len;
		} else {
		struct type4_lme *lme = ap_msg->message;
		memset(lme, 0, sizeof(*lme));
		ap_msg->length = sizeof(*lme);
		lme->header.msg_fmt = TYPE4_LME_FMT;
		lme->header.msg_len = sizeof(*lme);
		lme->header.msg_type_code = TYPE4_TYPE_CODE;
		lme->header.request_code = TYPE4_REQU_CODE;
		modulus = lme->modulus + sizeof(lme->modulus) - mod_len;
		exponent = lme->exponent + sizeof(lme->exponent) - mod_len;
		message = lme->message + sizeof(lme->message) - mod_len;
		}

		if (copy_from_user(modulus, mex->n_modulus, mod_len) \|\|
		copy_from_user(exponent, mex->b_key, mod_len) \|\|
		copy_from_user(message, mex->inputdata, mod_len))
		return -EFAULT;
		return 0;
		}

		/**
		* Convert a ICACRT message to a type4 CRT message.
		*
		* @zdev: crypto device pointer
		* @zreq: crypto request pointer
		* @crt: pointer to user input data
		*
		* Returns 0 on success or -EFAULT.
		*/
		static int ICACRT_msg_to_type4CRT_msg(struct zcrypt_device *zdev,
		struct ap_message *ap_msg,
		struct ica_rsa_modexpo_crt *crt)
		{
		unsigned char p, q, dp, dq, u, inp;
		int mod_len, short_len, long_len;

		mod_len = crt->inputdatalength;
		short_len = (mod_len + 1) / 2;
		long_len = mod_len / 2 + 8;

		if (mod_len <= 128) {
		struct type4_scr *scr = ap_msg->message;
		memset(scr, 0, sizeof(*scr));
		ap_msg->length = sizeof(*scr);
		scr->header.msg_type_code = TYPE4_TYPE_CODE;
		scr->header.request_code = TYPE4_REQU_CODE;
		scr->header.msg_fmt = TYPE4_SCR_FMT;
		scr->header.msg_len = sizeof(*scr);
		p = scr->p + sizeof(scr->p) - long_len;
		q = scr->q + sizeof(scr->q) - short_len;
		dp = scr->dp + sizeof(scr->dp) - long_len;
		dq = scr->dq + sizeof(scr->dq) - short_len;
		u = scr->u + sizeof(scr->u) - long_len;
		inp = scr->message + sizeof(scr->message) - mod_len;
		} else {
		struct type4_lcr *lcr = ap_msg->message;
		memset(lcr, 0, sizeof(*lcr));
		ap_msg->length = sizeof(*lcr);
		lcr->header.msg_type_code = TYPE4_TYPE_CODE;
		lcr->header.request_code = TYPE4_REQU_CODE;
		lcr->header.msg_fmt = TYPE4_LCR_FMT;
		lcr->header.msg_len = sizeof(*lcr);
		p = lcr->p + sizeof(lcr->p) - long_len;
		q = lcr->q + sizeof(lcr->q) - short_len;
		dp = lcr->dp + sizeof(lcr->dp) - long_len;
		dq = lcr->dq + sizeof(lcr->dq) - short_len;
		u = lcr->u + sizeof(lcr->u) - long_len;
		inp = lcr->message + sizeof(lcr->message) - mod_len;
		}

		if (copy_from_user(p, crt->np_prime, long_len) \|\|
		copy_from_user(q, crt->nq_prime, short_len) \|\|
		copy_from_user(dp, crt->bp_key, long_len) \|\|
		copy_from_user(dq, crt->bq_key, short_len) \|\|
		copy_from_user(u, crt->u_mult_inv, long_len) \|\|
		copy_from_user(inp, crt->inputdata, mod_len))
		return -EFAULT;
		return 0;
		}

		/**
		* Copy results from a type 84 reply message back to user space.
		*
		* @zdev: crypto device pointer
		* @reply: reply AP message.
		* @data: pointer to user output data
		* @length: size of user output data
		*
		* Returns 0 on success or -EFAULT.
		*/
		static int convert_type84(struct zcrypt_device *zdev,
		struct ap_message *reply,
		char __user *outputdata,
		unsigned int outputdatalength)
		{
		struct type84_hdr *t84h = reply->message;
		char *data;

		if (t84h->len < sizeof(*t84h) + outputdatalength) {
		/* The result is too short, the PCICA card may not do that.. */
		zdev->online = 0;
		pr_err("Cryptographic device %x failed and was set offline\n",
		zdev->ap_dev->qid);
		ZCRYPT_DBF_DEV(DBF_ERR, zdev, "dev%04xo%drc%d",
		zdev->ap_dev->qid, zdev->online, t84h->code);
		return -EAGAIN; /* repeat the request on a different device. */
		}
		BUG_ON(t84h->len > PCICA_MAX_RESPONSE_SIZE);
		data = reply->message + t84h->len - outputdatalength;
		if (copy_to_user(outputdata, data, outputdatalength))
		return -EFAULT;
		return 0;
		}

		static int convert_response(struct zcrypt_device *zdev,
		struct ap_message *reply,
		char __user *outputdata,
		unsigned int outputdatalength)
		{
		/* Response type byte is the second byte in the response. */
		switch (((unsigned char *) reply->message)[1]) {
		case TYPE82_RSP_CODE:
		case TYPE88_RSP_CODE:
		return convert_error(zdev, reply);
		case TYPE84_RSP_CODE:
		return convert_type84(zdev, reply,
		outputdata, outputdatalength);
		default: /* Unknown response type, this should NEVER EVER happen */
		zdev->online = 0;
		pr_err("Cryptographic device %x failed and was set offline\n",
		zdev->ap_dev->qid);
		ZCRYPT_DBF_DEV(DBF_ERR, zdev, "dev%04xo%dfail",
		zdev->ap_dev->qid, zdev->online);
		return -EAGAIN; /* repeat the request on a different device. */
		}
		}

		/**
		* This function is called from the AP bus code after a crypto request
		* "msg" has finished with the reply message "reply".
		* It is called from tasklet context.
		* @ap_dev: pointer to the AP device
		* @msg: pointer to the AP message
		* @reply: pointer to the AP reply message
		*/
		static void zcrypt_pcica_receive(struct ap_device *ap_dev,
		struct ap_message *msg,
		struct ap_message *reply)
		{
		static struct error_hdr error_reply = {
		.type = TYPE82_RSP_CODE,
		.reply_code = REP82_ERROR_MACHINE_FAILURE,
		};
		struct type84_hdr *t84h;
		int length;

		/* Copy the reply message to the request message buffer. */
		if (!reply)
		goto out; /* ap_msg->rc indicates the error */
		t84h = reply->message;
		if (t84h->code == TYPE84_RSP_CODE) {
		length = min(PCICA_MAX_RESPONSE_SIZE, (int) t84h->len);
		memcpy(msg->message, reply->message, length);
		} else
		memcpy(msg->message, reply->message, sizeof error_reply);
		out:
		complete((struct completion *) msg->private);
		}

		static atomic_t zcrypt_step = ATOMIC_INIT(0);

		/**
		* The request distributor calls this function if it picked the PCICA
		* device to handle a modexpo request.
		* @zdev: pointer to zcrypt_device structure that identifies the
		* PCICA device to the request distributor
		* @mex: pointer to the modexpo request buffer
		*/
		static long zcrypt_pcica_modexpo(struct zcrypt_device *zdev,
		struct ica_rsa_modexpo *mex)
		{
		struct ap_message ap_msg;
		struct completion work;
		int rc;

		ap_init_message(&ap_msg);
		ap_msg.message = kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
		if (!ap_msg.message)
		return -ENOMEM;
		ap_msg.receive = zcrypt_pcica_receive;
		ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
		atomic_inc_return(&zcrypt_step);
		ap_msg.private = &work;
		rc = ICAMEX_msg_to_type4MEX_msg(zdev, &ap_msg, mex);
		if (rc)
		goto out_free;
		init_completion(&work);
		ap_queue_message(zdev->ap_dev, &ap_msg);
		rc = wait_for_completion_interruptible(&work);
		if (rc == 0) {
		rc = ap_msg.rc;
		if (rc == 0)
		rc = convert_response(zdev, &ap_msg, mex->outputdata,
		mex->outputdatalength);
		} else
		/* Signal pending. */
		ap_cancel_message(zdev->ap_dev, &ap_msg);
		out_free:
		kfree(ap_msg.message);
		return rc;
		}

		/**
		* The request distributor calls this function if it picked the PCICA
		* device to handle a modexpo_crt request.
		* @zdev: pointer to zcrypt_device structure that identifies the
		* PCICA device to the request distributor
		* @crt: pointer to the modexpoc_crt request buffer
		*/
		static long zcrypt_pcica_modexpo_crt(struct zcrypt_device *zdev,
		struct ica_rsa_modexpo_crt *crt)
		{
		struct ap_message ap_msg;
		struct completion work;
		int rc;

		ap_init_message(&ap_msg);
		ap_msg.message = kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
		if (!ap_msg.message)
		return -ENOMEM;
		ap_msg.receive = zcrypt_pcica_receive;
		ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
		atomic_inc_return(&zcrypt_step);
		ap_msg.private = &work;
		rc = ICACRT_msg_to_type4CRT_msg(zdev, &ap_msg, crt);
		if (rc)
		goto out_free;
		init_completion(&work);
		ap_queue_message(zdev->ap_dev, &ap_msg);
		rc = wait_for_completion_interruptible(&work);
		if (rc == 0) {
		rc = ap_msg.rc;
		if (rc == 0)
		rc = convert_response(zdev, &ap_msg, crt->outputdata,
		crt->outputdatalength);
		} else
		/* Signal pending. */
		ap_cancel_message(zdev->ap_dev, &ap_msg);
		out_free:
		kfree(ap_msg.message);
		return rc;
		}

		/**
		* The crypto operations for a PCICA card.
		*/
		static struct zcrypt_ops zcrypt_pcica_ops = {
		.rsa_modexpo = zcrypt_pcica_modexpo,
		.rsa_modexpo_crt = zcrypt_pcica_modexpo_crt,
		};

		/**
		* Probe function for PCICA cards. It always accepts the AP device
		* since the bus_match already checked the hardware type.
		* @ap_dev: pointer to the AP device.
		*/
		static int zcrypt_pcica_probe(struct ap_device *ap_dev)
		{
		struct zcrypt_device *zdev;
		int rc;

		zdev = zcrypt_device_alloc(PCICA_MAX_RESPONSE_SIZE);
		if (!zdev)
		return -ENOMEM;
		zdev->ap_dev = ap_dev;
		zdev->ops = &zcrypt_pcica_ops;
		zdev->online = 1;
		zdev->user_space_type = ZCRYPT_PCICA;
		zdev->type_string = "PCICA";
		zdev->min_mod_size = PCICA_MIN_MOD_SIZE;
		zdev->max_mod_size = PCICA_MAX_MOD_SIZE;
		zdev->speed_rating = PCICA_SPEED_RATING;
		zdev->max_exp_bit_length = PCICA_MAX_MOD_SIZE;
		ap_dev->reply = &zdev->reply;
		ap_dev->private = zdev;
		rc = zcrypt_device_register(zdev);
		if (rc)
		goto out_free;
		return 0;

		out_free:
		ap_dev->private = NULL;
		zcrypt_device_free(zdev);
		return rc;
		}

		/**
		* This is called to remove the extended PCICA driver information
		* if an AP device is removed.
		*/
		static void zcrypt_pcica_remove(struct ap_device *ap_dev)
		{
		struct zcrypt_device *zdev = ap_dev->private;

		zcrypt_device_unregister(zdev);
		}

		int __init zcrypt_pcica_init(void)
		{
		return ap_driver_register(&zcrypt_pcica_driver, THIS_MODULE, "pcica");
		}

		void zcrypt_pcica_exit(void)
		{
		ap_driver_unregister(&zcrypt_pcica_driver);
		}

		module_init(zcrypt_pcica_init);
		module_exit(zcrypt_pcica_exit);

drivers/s390/crypto/zcrypt_pcica.h

deleted100644 → 0

+0 −115

Original line number	Diff line number	Diff line
		/*
		* zcrypt 2.1.0
		*
		* Copyright IBM Corp. 2001, 2006
		* 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_PCICA_H_
		#define _ZCRYPT_PCICA_H_

		/**
		* The type 4 message family is associated with a PCICA card.
		*
		* The four members of the family are described below.
		*
		* Note that all unsigned char arrays are right-justified and left-padded
		* with zeroes.
		*
		* Note that all reserved fields must be zeroes.
		*/
		struct type4_hdr {
		unsigned char reserved1;
		unsigned char msg_type_code; /* 0x04 */
		unsigned short msg_len;
		unsigned char request_code; /* 0x40 */
		unsigned char msg_fmt;
		unsigned short reserved2;
		} __attribute__((packed));

		#define TYPE4_TYPE_CODE 0x04
		#define TYPE4_REQU_CODE 0x40

		#define TYPE4_SME_FMT 0x00
		#define TYPE4_LME_FMT 0x10
		#define TYPE4_SCR_FMT 0x40
		#define TYPE4_LCR_FMT 0x50

		/* Mod-Exp, with a small modulus */
		struct type4_sme {
		struct type4_hdr header;
		unsigned char message[128];
		unsigned char exponent[128];
		unsigned char modulus[128];
		} __attribute__((packed));

		/* Mod-Exp, with a large modulus */
		struct type4_lme {
		struct type4_hdr header;
		unsigned char message[256];
		unsigned char exponent[256];
		unsigned char modulus[256];
		} __attribute__((packed));

		/* CRT, with a small modulus */
		struct type4_scr {
		struct type4_hdr header;
		unsigned char message[128];
		unsigned char dp[72];
		unsigned char dq[64];
		unsigned char p[72];
		unsigned char q[64];
		unsigned char u[72];
		} __attribute__((packed));

		/* CRT, with a large modulus */
		struct type4_lcr {
		struct type4_hdr header;
		unsigned char message[256];
		unsigned char dp[136];
		unsigned char dq[128];
		unsigned char p[136];
		unsigned char q[128];
		unsigned char u[136];
		} __attribute__((packed));

		/**
		* The type 84 response family is associated with a PCICA card.
		*
		* Note that all unsigned char arrays are right-justified and left-padded
		* with zeroes.
		*
		* Note that all reserved fields must be zeroes.
		*/

		struct type84_hdr {
		unsigned char reserved1;
		unsigned char code;
		unsigned short len;
		unsigned char reserved2[4];
		} __attribute__((packed));

		#define TYPE84_RSP_CODE 0x84

		int zcrypt_pcica_init(void);
		void zcrypt_pcica_exit(void);

		#endif /* _ZCRYPT_PCICA_H_ */

drivers/s390/crypto/zcrypt_pcicc.c

deleted100644 → 0

+0 −629

File deleted.

Preview size limit exceeded, changes collapsed.

Admin message