Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

9 files changed, 196 insertions, 33 deletions

diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index 91c6028d7b74..16e4a25596e7 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -27,6 +27,7 @@
 #define KMSG_COMPONENT "ap"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/delay.h>
@@ -154,14 +155,7 @@ static inline int ap_instructions_available(void)
  */
 static int ap_interrupts_available(void)
 {
-        unsigned long long facility_bits[2];
-
-        if (stfle(facility_bits, 2) <= 1)
-                return 0;
-        if (!(facility_bits[0] & (1ULL << 61)) ||
-            !(facility_bits[1] & (1ULL << 62)))
-                return 0;
-        return 1;
+        return test_facility(2) && test_facility(65);
 }
 
 /**
@@ -228,6 +222,69 @@ ap_queue_interruption_control(ap_qid_t qid, void *ind)
 }
 #endif
 
+static inline struct ap_queue_status __ap_4096_commands_available(ap_qid_t qid,
+                                                                  int *support)
+{
+        register unsigned long reg0 asm ("0") = 0UL | qid | (1UL << 23);
+        register struct ap_queue_status reg1 asm ("1");
+        register unsigned long reg2 asm ("2") = 0UL;
+
+        asm volatile(
+                ".long 0xb2af0000\n"
+                "0: la    %1,0\n"
+                "1:\n"
+                EX_TABLE(0b, 1b)
+                : "+d" (reg0), "=d" (reg1), "=d" (reg2)
+                :
+                : "cc");
+
+        if (reg2 & 0x6000000000000000ULL)
+                *support = 1;
+        else
+                *support = 0;
+
+        return reg1;
+}
+
+/**
+ * ap_4096_commands_availablen(): Check for availability of 4096 bit RSA
+ * support.
+ * @qid: The AP queue number
+ *
+ * Returns 1 if 4096 bit RSA keys are support fo the AP, returns 0 if not.
+ */
+int ap_4096_commands_available(ap_qid_t qid)
+{
+        struct ap_queue_status status;
+        int i, support = 0;
+        status = __ap_4096_commands_available(qid, &support);
+
+        for (i = 0; i < AP_MAX_RESET; i++) {
+                switch (status.response_code) {
+                case AP_RESPONSE_NORMAL:
+                        return support;
+                case AP_RESPONSE_RESET_IN_PROGRESS:
+                case AP_RESPONSE_BUSY:
+                        break;
+                case AP_RESPONSE_Q_NOT_AVAIL:
+                case AP_RESPONSE_DECONFIGURED:
+                case AP_RESPONSE_CHECKSTOPPED:
+                case AP_RESPONSE_INVALID_ADDRESS:
+                        return 0;
+                case AP_RESPONSE_OTHERWISE_CHANGED:
+                        break;
+                default:
+                        break;
+                }
+                if (i < AP_MAX_RESET - 1) {
+                        udelay(5);
+                        status = __ap_4096_commands_available(qid, &support);
+                }
+        }
+        return support;
+}
+EXPORT_SYMBOL(ap_4096_commands_available);
+
 /**
  * ap_queue_enable_interruption(): Enable interruption on an AP.
  * @qid: The AP queue number
@@ -1049,6 +1106,7 @@ out:
 
 static void ap_interrupt_handler(void *unused1, void *unused2)
 {
+        kstat_cpu(smp_processor_id()).irqs[IOINT_APB]++;
         tasklet_schedule(&ap_tasklet);
 }
 
@@ -1125,8 +1183,12 @@ 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 (device_type == 0)
-                        ap_probe_device_type(ap_dev);
+                if (device_type == 0) {
+                        if (ap_probe_device_type(ap_dev)) {
+                                kfree(ap_dev);
+                                continue;
+                        }
+                }
                 else
                         ap_dev->device_type = device_type;
 
diff --git a/drivers/s390/crypto/ap_bus.h b/drivers/s390/crypto/ap_bus.h
index 4785d07cd447..08b9738285b4 100644
--- a/drivers/s390/crypto/ap_bus.h
+++ b/drivers/s390/crypto/ap_bus.h
@@ -196,4 +196,6 @@ void ap_flush_queue(struct ap_device *ap_dev);
 int ap_module_init(void);
 void ap_module_exit(void);
 
+int ap_4096_commands_available(ap_qid_t qid);
+
 #endif /* _AP_BUS_H_ */
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index 41e0aaefafd5..8e65447f76b7 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -35,7 +35,6 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/compat.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
@@ -397,8 +396,15 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
                         if (copied == 0) {
                                 unsigned int len;
                                 spin_unlock_bh(&zcrypt_device_lock);
-                                /* len is max 256 / 2 - 120 = 8 */
-                                len = crt->inputdatalength / 2 - 120;
+                                /* len is max 256 / 2 - 120 = 8
+                                 * For bigger device just assume len of leading
+                                 * 0s is 8 as stated in the requirements for
+                                 * ica_rsa_modexpo_crt struct in zcrypt.h.
+                                 */
+                                if (crt->inputdatalength <= 256)
+                                        len = crt->inputdatalength / 2 - 120;
+                                else
+                                        len = 8;
                                 if (len > sizeof(z1))
                                         return -EFAULT;
                                 z1 = z2 = z3 = 0;
@@ -406,6 +412,7 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
                                     copy_from_user(&z2, crt->bp_key, len) ||
                                     copy_from_user(&z3, crt->u_mult_inv, len))
                                         return -EFAULT;
+                                z1 = z2 = z3 = 0;
                                 copied = 1;
                                 /*
                                  * We have to restart device lookup -
@@ -897,7 +904,8 @@ static const struct file_operations zcrypt_fops = {
         .compat_ioctl   = zcrypt_compat_ioctl,
 #endif
         .open           = zcrypt_open,
-        .release        = zcrypt_release
+        .release        = zcrypt_release,
+        .llseek         = no_llseek,
 };
 
 /*
diff --git a/drivers/s390/crypto/zcrypt_api.h b/drivers/s390/crypto/zcrypt_api.h
index 8e7ffbf2466c..9688f3985b07 100644
--- a/drivers/s390/crypto/zcrypt_api.h
+++ b/drivers/s390/crypto/zcrypt_api.h
@@ -76,7 +76,7 @@ struct ica_z90_status {
 
 /**
  * Large random numbers are pulled in 4096 byte chunks from the crypto cards
- * and stored in a page. Be carefull when increasing this buffer due to size
+ * and stored in a page. Be careful when increasing this buffer due to size
  * limitations for AP requests.
  */
 #define ZCRYPT_RNG_BUFFER_SIZE  4096
@@ -109,6 +109,7 @@ struct zcrypt_device {
         int request_count;              /* # current requests. */
 
         struct ap_message reply;        /* Per-device reply structure. */
+        int max_exp_bit_length;
 };
 
 struct zcrypt_device *zcrypt_device_alloc(size_t);
diff --git a/drivers/s390/crypto/zcrypt_cex2a.c b/drivers/s390/crypto/zcrypt_cex2a.c
index 9c409efa1ecf..2176d00b395e 100644
--- a/drivers/s390/crypto/zcrypt_cex2a.c
+++ b/drivers/s390/crypto/zcrypt_cex2a.c
@@ -41,7 +41,7 @@
 #define CEX2A_MIN_MOD_SIZE        1     /*    8 bits    */
 #define CEX2A_MAX_MOD_SIZE      256     /* 2048 bits    */
 #define CEX3A_MIN_MOD_SIZE      CEX2A_MIN_MOD_SIZE
-#define CEX3A_MAX_MOD_SIZE      CEX2A_MAX_MOD_SIZE
+#define CEX3A_MAX_MOD_SIZE      512     /* 4096 bits    */
 
 #define CEX2A_SPEED_RATING      970
 #define CEX3A_SPEED_RATING      900 /* Fixme: Needs finetuning */
@@ -49,8 +49,10 @@
 #define CEX2A_MAX_MESSAGE_SIZE  0x390   /* sizeof(struct type50_crb2_msg)    */
 #define CEX2A_MAX_RESPONSE_SIZE 0x110   /* max outputdatalength + type80_hdr */
 
-#define CEX3A_MAX_MESSAGE_SIZE  CEX2A_MAX_MESSAGE_SIZE
-#define CEX3A_MAX_RESPONSE_SIZE CEX2A_MAX_RESPONSE_SIZE
+#define CEX3A_MAX_RESPONSE_SIZE 0x210   /* 512 bit modulus
+                                         * (max outputdatalength) +
+                                         * type80_hdr*/
+#define CEX3A_MAX_MESSAGE_SIZE  sizeof(struct type50_crb3_msg)
 
 #define CEX2A_CLEANUP_TIME      (15*HZ)
 #define CEX3A_CLEANUP_TIME      CEX2A_CLEANUP_TIME
@@ -110,7 +112,7 @@ static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device *zdev,
                 mod = meb1->modulus + sizeof(meb1->modulus) - mod_len;
                 exp = meb1->exponent + sizeof(meb1->exponent) - mod_len;
                 inp = meb1->message + sizeof(meb1->message) - mod_len;
-        } else {
+        } else if (mod_len <= 256) {
                 struct type50_meb2_msg *meb2 = ap_msg->message;
                 memset(meb2, 0, sizeof(*meb2));
                 ap_msg->length = sizeof(*meb2);
@@ -120,6 +122,17 @@ static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device *zdev,
                 mod = meb2->modulus + sizeof(meb2->modulus) - mod_len;
                 exp = meb2->exponent + sizeof(meb2->exponent) - mod_len;
                 inp = meb2->message + sizeof(meb2->message) - mod_len;
+        } else {
+                /* mod_len > 256 = 4096 bit RSA Key */
+                struct type50_meb3_msg *meb3 = ap_msg->message;
+                memset(meb3, 0, sizeof(*meb3));
+                ap_msg->length = sizeof(*meb3);
+                meb3->header.msg_type_code = TYPE50_TYPE_CODE;
+                meb3->header.msg_len = sizeof(*meb3);
+                meb3->keyblock_type = TYPE50_MEB3_FMT;
+                mod = meb3->modulus + sizeof(meb3->modulus) - mod_len;
+                exp = meb3->exponent + sizeof(meb3->exponent) - mod_len;
+                inp = meb3->message + sizeof(meb3->message) - mod_len;
         }
 
         if (copy_from_user(mod, mex->n_modulus, mod_len) ||
@@ -142,7 +155,7 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                                        struct ap_message *ap_msg,
                                        struct ica_rsa_modexpo_crt *crt)
 {
-        int mod_len, short_len, long_len, long_offset;
+        int mod_len, short_len, long_len, long_offset, limit;
         unsigned char *p, *q, *dp, *dq, *u, *inp;
 
         mod_len = crt->inputdatalength;
@@ -152,14 +165,20 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
         /*
          * CEX2A cannot handle p, dp, or U > 128 bytes.
          * If we have one of these, we need to do extra checking.
+         * For CEX3A the limit is 256 bytes.
          */
-        if (long_len > 128) {
+        if (zdev->max_mod_size == CEX3A_MAX_MOD_SIZE)
+                limit = 256;
+        else
+                limit = 128;
+
+        if (long_len > limit) {
                 /*
                  * zcrypt_rsa_crt already checked for the leading
                  * zeroes of np_prime, bp_key and u_mult_inc.
                  */
-                long_offset = long_len - 128;
-                long_len = 128;
+                long_offset = long_len - limit;
+                long_len = limit;
         } else
                 long_offset = 0;
 
@@ -180,7 +199,7 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                 dq = crb1->dq + sizeof(crb1->dq) - short_len;
                 u = crb1->u + sizeof(crb1->u) - long_len;
                 inp = crb1->message + sizeof(crb1->message) - mod_len;
-        } else {
+        } else if (long_len <= 128) {
                 struct type50_crb2_msg *crb2 = ap_msg->message;
                 memset(crb2, 0, sizeof(*crb2));
                 ap_msg->length = sizeof(*crb2);
@@ -193,6 +212,20 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                 dq = crb2->dq + sizeof(crb2->dq) - short_len;
                 u = crb2->u + sizeof(crb2->u) - long_len;
                 inp = crb2->message + sizeof(crb2->message) - mod_len;
+        } else {
+                /* long_len >= 256 */
+                struct type50_crb3_msg *crb3 = ap_msg->message;
+                memset(crb3, 0, sizeof(*crb3));
+                ap_msg->length = sizeof(*crb3);
+                crb3->header.msg_type_code = TYPE50_TYPE_CODE;
+                crb3->header.msg_len = sizeof(*crb3);
+                crb3->keyblock_type = TYPE50_CRB3_FMT;
+                p = crb3->p + sizeof(crb3->p) - long_len;
+                q = crb3->q + sizeof(crb3->q) - short_len;
+                dp = crb3->dp + sizeof(crb3->dp) - long_len;
+                dq = crb3->dq + sizeof(crb3->dq) - short_len;
+                u = crb3->u + sizeof(crb3->u) - long_len;
+                inp = crb3->message + sizeof(crb3->message) - mod_len;
         }
 
         if (copy_from_user(p, crt->np_prime + long_offset, long_len) ||
@@ -203,7 +236,6 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
             copy_from_user(inp, crt->inputdata, mod_len))
                 return -EFAULT;
 
-
         return 0;
 }
 
@@ -230,7 +262,10 @@ static int convert_type80(struct zcrypt_device *zdev,
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
-        BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
+        else
+                BUG_ON(t80h->len > CEX3A_MAX_RESPONSE_SIZE);
         data = reply->message + t80h->len - outputdatalength;
         if (copy_to_user(outputdata, data, outputdatalength))
                 return -EFAULT;
@@ -282,7 +317,10 @@ static void zcrypt_cex2a_receive(struct ap_device *ap_dev,
         }
         t80h = reply->message;
         if (t80h->type == TYPE80_RSP_CODE) {
-                length = min(CEX2A_MAX_RESPONSE_SIZE, (int) t80h->len);
+                if (ap_dev->device_type == AP_DEVICE_TYPE_CEX2A)
+                        length = min(CEX2A_MAX_RESPONSE_SIZE, (int) t80h->len);
+                else
+                        length = min(CEX3A_MAX_RESPONSE_SIZE, (int) t80h->len);
                 memcpy(msg->message, reply->message, length);
         } else
                 memcpy(msg->message, reply->message, sizeof error_reply);
@@ -307,7 +345,10 @@ static long zcrypt_cex2a_modexpo(struct zcrypt_device *zdev,
         int rc;
 
         ap_init_message(&ap_msg);
-        ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        else
+                ap_msg.message = kmalloc(CEX3A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
@@ -345,7 +386,10 @@ static long zcrypt_cex2a_modexpo_crt(struct zcrypt_device *zdev,
         int rc;
 
         ap_init_message(&ap_msg);
-        ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        else
+                ap_msg.message = kmalloc(CEX3A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
@@ -397,6 +441,7 @@ static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
                 zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
                 zdev->short_crt = 1;
                 zdev->speed_rating = CEX2A_SPEED_RATING;
+                zdev->max_exp_bit_length = CEX2A_MAX_MOD_SIZE;
                 break;
         case AP_DEVICE_TYPE_CEX3A:
                 zdev = zcrypt_device_alloc(CEX3A_MAX_RESPONSE_SIZE);
@@ -404,8 +449,13 @@ static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
                         return -ENOMEM;
                 zdev->user_space_type = ZCRYPT_CEX3A;
                 zdev->type_string = "CEX3A";
-                zdev->min_mod_size = CEX3A_MIN_MOD_SIZE;
-                zdev->max_mod_size = CEX3A_MAX_MOD_SIZE;
+                zdev->min_mod_size = CEX2A_MIN_MOD_SIZE;
+                zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = CEX2A_MAX_MOD_SIZE;
+                if (ap_4096_commands_available(ap_dev->qid)) {
+                        zdev->max_mod_size = CEX3A_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = CEX3A_MAX_MOD_SIZE;
+                }
                 zdev->short_crt = 1;
                 zdev->speed_rating = CEX3A_SPEED_RATING;
                 break;
diff --git a/drivers/s390/crypto/zcrypt_cex2a.h b/drivers/s390/crypto/zcrypt_cex2a.h
index 8f69d1dacab8..0350665810cf 100644
--- a/drivers/s390/crypto/zcrypt_cex2a.h
+++ b/drivers/s390/crypto/zcrypt_cex2a.h
@@ -51,8 +51,10 @@ struct type50_hdr {
 
 #define TYPE50_MEB1_FMT         0x0001
 #define TYPE50_MEB2_FMT         0x0002
+#define TYPE50_MEB3_FMT         0x0003
 #define TYPE50_CRB1_FMT         0x0011
 #define TYPE50_CRB2_FMT         0x0012
+#define TYPE50_CRB3_FMT         0x0013
 
 /* Mod-Exp, with a small modulus */
 struct type50_meb1_msg {
@@ -74,6 +76,16 @@ struct type50_meb2_msg {
         unsigned char   message[256];
 } __attribute__((packed));
 
+/* Mod-Exp, with a larger modulus */
+struct type50_meb3_msg {
+        struct type50_hdr header;
+        unsigned short  keyblock_type;  /* 0x0003 */
+        unsigned char   reserved[6];
+        unsigned char   exponent[512];
+        unsigned char   modulus[512];
+        unsigned char   message[512];
+} __attribute__((packed));
+
 /* CRT, with a small modulus */
 struct type50_crb1_msg {
         struct type50_hdr header;
@@ -100,6 +112,19 @@ struct type50_crb2_msg {
         unsigned char   message[256];
 } __attribute__((packed));
 
+/* CRT, with a larger modulus */
+struct type50_crb3_msg {
+        struct type50_hdr header;
+        unsigned short  keyblock_type;  /* 0x0013 */
+        unsigned char   reserved[6];
+        unsigned char   p[256];
+        unsigned char   q[256];
+        unsigned char   dp[256];
+        unsigned char   dq[256];
+        unsigned char   u[256];
+        unsigned char   message[512];
+} __attribute__((packed));
+
 /**
  * The type 80 response family is associated with a CEX2A card.
  *
diff --git a/drivers/s390/crypto/zcrypt_pcica.c b/drivers/s390/crypto/zcrypt_pcica.c
index 09e934b295a0..1afb69c75fea 100644
--- a/drivers/s390/crypto/zcrypt_pcica.c
+++ b/drivers/s390/crypto/zcrypt_pcica.c
@@ -373,6 +373,7 @@ static int zcrypt_pcica_probe(struct ap_device *ap_dev)
         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);
diff --git a/drivers/s390/crypto/zcrypt_pcicc.c b/drivers/s390/crypto/zcrypt_pcicc.c
index 9dec5c77cff4..aa4c050a5694 100644
--- a/drivers/s390/crypto/zcrypt_pcicc.c
+++ b/drivers/s390/crypto/zcrypt_pcicc.c
@@ -579,6 +579,7 @@ static int zcrypt_pcicc_probe(struct ap_device *ap_dev)
         zdev->min_mod_size = PCICC_MIN_MOD_SIZE;
         zdev->max_mod_size = PCICC_MAX_MOD_SIZE;
         zdev->speed_rating = PCICC_SPEED_RATING;
+        zdev->max_exp_bit_length = PCICC_MAX_MOD_SIZE;
         ap_dev->reply = &zdev->reply;
         ap_dev->private = zdev;
         rc = zcrypt_device_register(zdev);
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index 510fab4577d4..4f85eb725f4f 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -45,12 +45,12 @@
 #define PCIXCC_MIN_MOD_SIZE_OLD  64     /*  512 bits    */
 #define PCIXCC_MAX_MOD_SIZE     256     /* 2048 bits    */
 #define CEX3C_MIN_MOD_SIZE      PCIXCC_MIN_MOD_SIZE
-#define CEX3C_MAX_MOD_SIZE      PCIXCC_MAX_MOD_SIZE
+#define CEX3C_MAX_MOD_SIZE      512     /* 4096 bits    */
 
 #define PCIXCC_MCL2_SPEED_RATING        7870
 #define PCIXCC_MCL3_SPEED_RATING        7870
 #define CEX2C_SPEED_RATING              7000
-#define CEX3C_SPEED_RATING              6500    /* FIXME: needs finetuning */
+#define CEX3C_SPEED_RATING              6500
 
 #define PCIXCC_MAX_ICA_MESSAGE_SIZE 0x77c  /* max size type6 v2 crt message */
 #define PCIXCC_MAX_ICA_RESPONSE_SIZE 0x77c /* max size type86 v2 reply      */
@@ -567,6 +567,15 @@ static int convert_response_ica(struct zcrypt_device *zdev,
         case TYPE88_RSP_CODE:
                 return convert_error(zdev, reply);
         case TYPE86_RSP_CODE:
+                if (msg->cprbx.ccp_rtcode &&
+                   (msg->cprbx.ccp_rscode == 0x14f) &&
+                   (outputdatalength > 256)) {
+                        if (zdev->max_exp_bit_length <= 17) {
+                                zdev->max_exp_bit_length = 17;
+                                return -EAGAIN;
+                        } else
+                                return -EINVAL;
+                }
                 if (msg->hdr.reply_code)
                         return convert_error(zdev, reply);
                 if (msg->cprbx.cprb_ver_id == 0x02)
@@ -1052,11 +1061,13 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                         zdev->speed_rating = PCIXCC_MCL2_SPEED_RATING;
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
                         zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 } else {
                         zdev->type_string = "PCIXCC_MCL3";
                         zdev->speed_rating = PCIXCC_MCL3_SPEED_RATING;
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                         zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 }
                 break;
         case AP_DEVICE_TYPE_CEX2C:
@@ -1065,6 +1076,7 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                 zdev->speed_rating = CEX2C_SPEED_RATING;
                 zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                 zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 break;
         case AP_DEVICE_TYPE_CEX3C:
                 zdev->user_space_type = ZCRYPT_CEX3C;
@@ -1072,6 +1084,7 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                 zdev->speed_rating = CEX3C_SPEED_RATING;
                 zdev->min_mod_size = CEX3C_MIN_MOD_SIZE;
                 zdev->max_mod_size = CEX3C_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = CEX3C_MAX_MOD_SIZE;
                 break;
         default:
                 goto out_free;