drivers/s390/crypto/zcrypt_cex4.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright IBM Corp. 2012, 2019
   4  *  Author(s): Holger Dengler <hd@linux.vnet.ibm.com>
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/slab.h>
   9 #include <linux/init.h>
  10 #include <linux/err.h>
  11 #include <linux/atomic.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/mod_devicetable.h>
  14
  15 #include "ap_bus.h"
  16 #include "zcrypt_api.h"
  17 #include "zcrypt_msgtype6.h"
  18 #include "zcrypt_msgtype50.h"
  19 #include "zcrypt_error.h"
  20 #include "zcrypt_cex4.h"
  21 #include "zcrypt_ccamisc.h"
  22 #include "zcrypt_ep11misc.h"
  23
  24 #define CEX4A_MIN_MOD_SIZE        1     /*    8 bits    */
  25 #define CEX4A_MAX_MOD_SIZE_2K   256     /* 2048 bits    */
  26 #define CEX4A_MAX_MOD_SIZE_4K   512     /* 4096 bits    */
  27
  28 #define CEX4C_MIN_MOD_SIZE       16     /*  256 bits    */
  29 #define CEX4C_MAX_MOD_SIZE      512     /* 4096 bits    */
  30
  31 #define CEX4A_MAX_MESSAGE_SIZE  MSGTYPE50_CRB3_MAX_MSG_SIZE
  32 #define CEX4C_MAX_MESSAGE_SIZE  MSGTYPE06_MAX_MSG_SIZE
  33
  34 /* Waiting time for requests to be processed.
  35  * Currently there are some types of request which are not deterministic.
  36  * But the maximum time limit managed by the stomper code is set to 60sec.
  37  * Hence we have to wait at least that time period.
  38  */
  39 #define CEX4_CLEANUP_TIME       (900*HZ)
  40
  41 MODULE_AUTHOR("IBM Corporation");
  42 MODULE_DESCRIPTION("CEX4/CEX5/CEX6/CEX7 Cryptographic Card device driver, " \
  43                    "Copyright IBM Corp. 2019");
  44 MODULE_LICENSE("GPL");
  45
  46 static struct ap_device_id zcrypt_cex4_card_ids[] = {
  47         { .dev_type = AP_DEVICE_TYPE_CEX4,
  48           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  49         { .dev_type = AP_DEVICE_TYPE_CEX5,
  50           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  51         { .dev_type = AP_DEVICE_TYPE_CEX6,
  52           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  53         { .dev_type = AP_DEVICE_TYPE_CEX7,
  54           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  55         { /* end of list */ },
  56 };
  57
  58 MODULE_DEVICE_TABLE(ap, zcrypt_cex4_card_ids);
  59
  60 static struct ap_device_id zcrypt_cex4_queue_ids[] = {
  61         { .dev_type = AP_DEVICE_TYPE_CEX4,
  62           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  63         { .dev_type = AP_DEVICE_TYPE_CEX5,
  64           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  65         { .dev_type = AP_DEVICE_TYPE_CEX6,
  66           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  67         { .dev_type = AP_DEVICE_TYPE_CEX7,
  68           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  69         { /* end of list */ },
  70 };
  71
  72 MODULE_DEVICE_TABLE(ap, zcrypt_cex4_queue_ids);
  73
  74 /*
  75  * CCA card additional device attributes
  76  */
  77 static ssize_t cca_serialnr_show(struct device *dev,
  78                                  struct device_attribute *attr,
  79                                  char *buf)
  80 {
  81         struct cca_info ci;
  82         struct ap_card *ac = to_ap_card(dev);
  83         struct zcrypt_card *zc = ac->private;
  84
  85         memset(&ci, 0, sizeof(ci));
  86
  87         if (ap_domain_index >= 0)
  88                 cca_get_info(ac->id, ap_domain_index, &ci, zc->online);
  89
  90         return scnprintf(buf, PAGE_SIZE, "%s\n", ci.serial);
  91 }
  92
  93 static struct device_attribute dev_attr_cca_serialnr =
  94         __ATTR(serialnr, 0444, cca_serialnr_show, NULL);
  95
  96 static struct attribute *cca_card_attrs[] = {
  97         &dev_attr_cca_serialnr.attr,
  98         NULL,
  99 };
 100
 101 static const struct attribute_group cca_card_attr_grp = {
 102         .attrs = cca_card_attrs,
 103 };
 104
 105  /*
 106   * CCA queue additional device attributes
 107   */
 108 static ssize_t cca_mkvps_show(struct device *dev,
 109                               struct device_attribute *attr,
 110                               char *buf)
 111 {
 112         int n = 0;
 113         struct cca_info ci;
 114         struct zcrypt_queue *zq = to_ap_queue(dev)->private;
 115         static const char * const cao_state[] = { "invalid", "valid" };
 116         static const char * const new_state[] = { "empty", "partial", "full" };
 117
 118         memset(&ci, 0, sizeof(ci));
 119
 120         cca_get_info(AP_QID_CARD(zq->queue->qid),
 121                      AP_QID_QUEUE(zq->queue->qid),
 122                      &ci, zq->online);
 123
 124         if (ci.new_aes_mk_state >= '1' && ci.new_aes_mk_state <= '3')
 125                 n = scnprintf(buf, PAGE_SIZE, "AES NEW: %s 0x%016llx\n",
 126                               new_state[ci.new_aes_mk_state - '1'],
 127                               ci.new_aes_mkvp);
 128         else
 129                 n = scnprintf(buf, PAGE_SIZE, "AES NEW: - -\n");
 130
 131         if (ci.cur_aes_mk_state >= '1' && ci.cur_aes_mk_state <= '2')
 132                 n += scnprintf(buf + n, PAGE_SIZE - n,
 133                                "AES CUR: %s 0x%016llx\n",
 134                                cao_state[ci.cur_aes_mk_state - '1'],
 135                                ci.cur_aes_mkvp);
 136         else
 137                 n += scnprintf(buf + n, PAGE_SIZE - n, "AES CUR: - -\n");
 138
 139         if (ci.old_aes_mk_state >= '1' && ci.old_aes_mk_state <= '2')
 140                 n += scnprintf(buf + n, PAGE_SIZE - n,
 141                                "AES OLD: %s 0x%016llx\n",
 142                                cao_state[ci.old_aes_mk_state - '1'],
 143                                ci.old_aes_mkvp);
 144         else
 145                 n += scnprintf(buf + n, PAGE_SIZE - n, "AES OLD: - -\n");
 146
 147         if (ci.new_apka_mk_state >= '1' && ci.new_apka_mk_state <= '3')
 148                 n += scnprintf(buf + n, PAGE_SIZE - n,
 149                                "APKA NEW: %s 0x%016llx\n",
 150                                new_state[ci.new_apka_mk_state - '1'],
 151                                ci.new_apka_mkvp);
 152         else
 153                 n += scnprintf(buf + n, PAGE_SIZE - n, "APKA NEW: - -\n");
 154
 155         if (ci.cur_apka_mk_state >= '1' && ci.cur_apka_mk_state <= '2')
 156                 n += scnprintf(buf + n, PAGE_SIZE - n,
 157                                "APKA CUR: %s 0x%016llx\n",
 158                                cao_state[ci.cur_apka_mk_state - '1'],
 159                                ci.cur_apka_mkvp);
 160         else
 161                 n += scnprintf(buf + n, PAGE_SIZE - n, "APKA CUR: - -\n");
 162
 163         if (ci.old_apka_mk_state >= '1' && ci.old_apka_mk_state <= '2')
 164                 n += scnprintf(buf + n, PAGE_SIZE - n,
 165                                "APKA OLD: %s 0x%016llx\n",
 166                                cao_state[ci.old_apka_mk_state - '1'],
 167                                ci.old_apka_mkvp);
 168         else
 169                 n += scnprintf(buf + n, PAGE_SIZE - n, "APKA OLD: - -\n");
 170
 171         return n;
 172 }
 173
 174 static struct device_attribute dev_attr_cca_mkvps =
 175         __ATTR(mkvps, 0444, cca_mkvps_show, NULL);
 176
 177 static struct attribute *cca_queue_attrs[] = {
 178         &dev_attr_cca_mkvps.attr,
 179         NULL,
 180 };
 181
 182 static const struct attribute_group cca_queue_attr_grp = {
 183         .attrs = cca_queue_attrs,
 184 };
 185
 186 /*
 187  * EP11 card additional device attributes
 188  */
 189 static ssize_t ep11_api_ordinalnr_show(struct device *dev,
 190                                        struct device_attribute *attr,
 191                                        char *buf)
 192 {
 193         struct ep11_card_info ci;
 194         struct ap_card *ac = to_ap_card(dev);
 195         struct zcrypt_card *zc = ac->private;
 196
 197         memset(&ci, 0, sizeof(ci));
 198
 199         ep11_get_card_info(ac->id, &ci, zc->online);
 200
 201         if (ci.API_ord_nr > 0)
 202                 return scnprintf(buf, PAGE_SIZE, "%u\n", ci.API_ord_nr);
 203         else
 204                 return scnprintf(buf, PAGE_SIZE, "\n");
 205 }
 206
 207 static struct device_attribute dev_attr_ep11_api_ordinalnr =
 208         __ATTR(API_ordinalnr, 0444, ep11_api_ordinalnr_show, NULL);
 209
 210 static ssize_t ep11_fw_version_show(struct device *dev,
 211                                     struct device_attribute *attr,
 212                                     char *buf)
 213 {
 214         struct ep11_card_info ci;
 215         struct ap_card *ac = to_ap_card(dev);
 216         struct zcrypt_card *zc = ac->private;
 217
 218         memset(&ci, 0, sizeof(ci));
 219
 220         ep11_get_card_info(ac->id, &ci, zc->online);
 221
 222         if (ci.FW_version > 0)
 223                 return scnprintf(buf, PAGE_SIZE, "%d.%d\n",
 224                                  (int)(ci.FW_version >> 8),
 225                                  (int)(ci.FW_version & 0xFF));
 226         else
 227                 return scnprintf(buf, PAGE_SIZE, "\n");
 228 }
 229
 230 static struct device_attribute dev_attr_ep11_fw_version =
 231         __ATTR(FW_version, 0444, ep11_fw_version_show, NULL);
 232
 233 static ssize_t ep11_serialnr_show(struct device *dev,
 234                                   struct device_attribute *attr,
 235                                   char *buf)
 236 {
 237         struct ep11_card_info ci;
 238         struct ap_card *ac = to_ap_card(dev);
 239         struct zcrypt_card *zc = ac->private;
 240
 241         memset(&ci, 0, sizeof(ci));
 242
 243         ep11_get_card_info(ac->id, &ci, zc->online);
 244
 245         if (ci.serial[0])
 246                 return scnprintf(buf, PAGE_SIZE, "%16.16s\n", ci.serial);
 247         else
 248                 return scnprintf(buf, PAGE_SIZE, "\n");
 249 }
 250
 251 static struct device_attribute dev_attr_ep11_serialnr =
 252         __ATTR(serialnr, 0444, ep11_serialnr_show, NULL);
 253
 254 static const struct {
 255         int         mode_bit;
 256         const char *mode_txt;
 257 } ep11_op_modes[] = {
 258         { 0, "FIPS2009" },
 259         { 1, "BSI2009" },
 260         { 2, "FIPS2011" },
 261         { 3, "BSI2011" },
 262         { 6, "BSICC2017" },
 263         { 0, NULL }
 264 };
 265
 266 static ssize_t ep11_card_op_modes_show(struct device *dev,
 267                                        struct device_attribute *attr,
 268                                        char *buf)
 269 {
 270         int i, n = 0;
 271         struct ep11_card_info ci;
 272         struct ap_card *ac = to_ap_card(dev);
 273         struct zcrypt_card *zc = ac->private;
 274
 275         memset(&ci, 0, sizeof(ci));
 276
 277         ep11_get_card_info(ac->id, &ci, zc->online);
 278
 279         for (i = 0; ep11_op_modes[i].mode_txt; i++) {
 280                 if (ci.op_mode & (1ULL << ep11_op_modes[i].mode_bit)) {
 281                         if (n > 0)
 282                                 buf[n++] = ' ';
 283                         n += scnprintf(buf + n, PAGE_SIZE - n,
 284                                        "%s", ep11_op_modes[i].mode_txt);
 285                 }
 286         }
 287         n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
 288
 289         return n;
 290 }
 291
 292 static struct device_attribute dev_attr_ep11_card_op_modes =
 293         __ATTR(op_modes, 0444, ep11_card_op_modes_show, NULL);
 294
 295 static struct attribute *ep11_card_attrs[] = {
 296         &dev_attr_ep11_api_ordinalnr.attr,
 297         &dev_attr_ep11_fw_version.attr,
 298         &dev_attr_ep11_serialnr.attr,
 299         &dev_attr_ep11_card_op_modes.attr,
 300         NULL,
 301 };
 302
 303 static const struct attribute_group ep11_card_attr_grp = {
 304         .attrs = ep11_card_attrs,
 305 };
 306
 307 /*
 308  * EP11 queue additional device attributes
 309  */
 310
 311 static ssize_t ep11_mkvps_show(struct device *dev,
 312                                struct device_attribute *attr,
 313                                char *buf)
 314 {
 315         int n = 0;
 316         struct ep11_domain_info di;
 317         struct zcrypt_queue *zq = to_ap_queue(dev)->private;
 318         static const char * const cwk_state[] = { "invalid", "valid" };
 319         static const char * const nwk_state[] = { "empty", "uncommitted",
 320                                                   "committed" };
 321
 322         memset(&di, 0, sizeof(di));
 323
 324         if (zq->online)
 325                 ep11_get_domain_info(AP_QID_CARD(zq->queue->qid),
 326                                      AP_QID_QUEUE(zq->queue->qid),
 327                                      &di);
 328
 329         if (di.cur_wk_state == '0') {
 330                 n = scnprintf(buf, PAGE_SIZE, "WK CUR: %s -\n",
 331                               cwk_state[di.cur_wk_state - '0']);
 332         } else if (di.cur_wk_state == '1') {
 333                 n = scnprintf(buf, PAGE_SIZE, "WK CUR: %s 0x",
 334                               cwk_state[di.cur_wk_state - '0']);
 335                 bin2hex(buf + n, di.cur_wkvp, sizeof(di.cur_wkvp));
 336                 n += 2 * sizeof(di.cur_wkvp);
 337                 n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
 338         } else
 339                 n = scnprintf(buf, PAGE_SIZE, "WK CUR: - -\n");
 340
 341         if (di.new_wk_state == '0') {
 342                 n += scnprintf(buf + n, PAGE_SIZE - n, "WK NEW: %s -\n",
 343                                nwk_state[di.new_wk_state - '0']);
 344         } else if (di.new_wk_state >= '1' && di.new_wk_state <= '2') {
 345                 n += scnprintf(buf + n, PAGE_SIZE - n, "WK NEW: %s 0x",
 346                                nwk_state[di.new_wk_state - '0']);
 347                 bin2hex(buf + n, di.new_wkvp, sizeof(di.new_wkvp));
 348                 n += 2 * sizeof(di.new_wkvp);
 349                 n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
 350         } else
 351                 n += scnprintf(buf + n, PAGE_SIZE - n, "WK NEW: - -\n");
 352
 353         return n;
 354 }
 355
 356 static struct device_attribute dev_attr_ep11_mkvps =
 357         __ATTR(mkvps, 0444, ep11_mkvps_show, NULL);
 358
 359 static ssize_t ep11_queue_op_modes_show(struct device *dev,
 360                                         struct device_attribute *attr,
 361                                         char *buf)
 362 {
 363         int i, n = 0;
 364         struct ep11_domain_info di;
 365         struct zcrypt_queue *zq = to_ap_queue(dev)->private;
 366
 367         memset(&di, 0, sizeof(di));
 368
 369         if (zq->online)
 370                 ep11_get_domain_info(AP_QID_CARD(zq->queue->qid),
 371                                      AP_QID_QUEUE(zq->queue->qid),
 372                                      &di);
 373
 374         for (i = 0; ep11_op_modes[i].mode_txt; i++) {
 375                 if (di.op_mode & (1ULL << ep11_op_modes[i].mode_bit)) {
 376                         if (n > 0)
 377                                 buf[n++] = ' ';
 378                         n += scnprintf(buf + n, PAGE_SIZE - n,
 379                                        "%s", ep11_op_modes[i].mode_txt);
 380                 }
 381         }
 382         n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
 383
 384         return n;
 385 }
 386
 387 static struct device_attribute dev_attr_ep11_queue_op_modes =
 388         __ATTR(op_modes, 0444, ep11_queue_op_modes_show, NULL);
 389
 390 static struct attribute *ep11_queue_attrs[] = {
 391         &dev_attr_ep11_mkvps.attr,
 392         &dev_attr_ep11_queue_op_modes.attr,
 393         NULL,
 394 };
 395
 396 static const struct attribute_group ep11_queue_attr_grp = {
 397         .attrs = ep11_queue_attrs,
 398 };
 399
 400 /**
 401  * Probe function for CEX4/CEX5/CEX6/CEX7 card device. It always
 402  * accepts the AP device since the bus_match already checked
 403  * the hardware type.
 404  * @ap_dev: pointer to the AP device.
 405  */
 406 static int zcrypt_cex4_card_probe(struct ap_device *ap_dev)
 407 {
 408         /*
 409          * Normalized speed ratings per crypto adapter
 410          * MEX_1k, MEX_2k, MEX_4k, CRT_1k, CRT_2k, CRT_4k, RNG, SECKEY
 411          */
 412         static const int CEX4A_SPEED_IDX[NUM_OPS] = {
 413                  14,  19, 249, 42, 228, 1458, 0, 0};
 414         static const int CEX5A_SPEED_IDX[NUM_OPS] = {
 415                   8,   9,  20, 18,  66,  458, 0, 0};
 416         static const int CEX6A_SPEED_IDX[NUM_OPS] = {
 417                   6,   9,  20, 17,  65,  438, 0, 0};
 418         static const int CEX7A_SPEED_IDX[NUM_OPS] = {
 419                   6,   8,  17, 15,  54,  362, 0, 0};
 420
 421         static const int CEX4C_SPEED_IDX[NUM_OPS] = {
 422                  59,  69, 308, 83, 278, 2204, 209, 40};
 423         static const int CEX5C_SPEED_IDX[] = {
 424                  24,  31,  50, 37,  90,  479,  27, 10};
 425         static const int CEX6C_SPEED_IDX[NUM_OPS] = {
 426                  16,  20,  32, 27,  77,  455,  24,  9};
 427         static const int CEX7C_SPEED_IDX[NUM_OPS] = {
 428                  14,  16,  26, 23,  64,  376,  23,  8};
 429
 430         static const int CEX4P_SPEED_IDX[NUM_OPS] = {
 431                   0,   0,   0,   0,   0,   0,   0,  50};
 432         static const int CEX5P_SPEED_IDX[NUM_OPS] = {
 433                   0,   0,   0,   0,   0,   0,   0,  10};
 434         static const int CEX6P_SPEED_IDX[NUM_OPS] = {
 435                   0,   0,   0,   0,   0,   0,   0,   9};
 436         static const int CEX7P_SPEED_IDX[NUM_OPS] = {
 437                   0,   0,   0,   0,   0,   0,   0,   8};
 438
 439         struct ap_card *ac = to_ap_card(&ap_dev->device);
 440         struct zcrypt_card *zc;
 441         int rc = 0;
 442
 443         zc = zcrypt_card_alloc();
 444         if (!zc)
 445                 return -ENOMEM;
 446         zc->card = ac;
 447         ac->private = zc;
 448         if (ap_test_bit(&ac->functions, AP_FUNC_ACCEL)) {
 449                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 450                         zc->type_string = "CEX4A";
 451                         zc->user_space_type = ZCRYPT_CEX4;
 452                         zc->speed_rating = CEX4A_SPEED_IDX;
 453                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 454                         zc->type_string = "CEX5A";
 455                         zc->user_space_type = ZCRYPT_CEX5;
 456                         zc->speed_rating = CEX5A_SPEED_IDX;
 457                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 458                         zc->type_string = "CEX6A";
 459                         zc->user_space_type = ZCRYPT_CEX6;
 460                         zc->speed_rating = CEX6A_SPEED_IDX;
 461                 } else {
 462                         zc->type_string = "CEX7A";
 463                         /* wrong user space type, just for compatibility
 464                          * with the ZCRYPT_STATUS_MASK ioctl.
 465                          */
 466                         zc->user_space_type = ZCRYPT_CEX6;
 467                         zc->speed_rating = CEX7A_SPEED_IDX;
 468                 }
 469                 zc->min_mod_size = CEX4A_MIN_MOD_SIZE;
 470                 if (ap_test_bit(&ac->functions, AP_FUNC_MEX4K) &&
 471                     ap_test_bit(&ac->functions, AP_FUNC_CRT4K)) {
 472                         zc->max_mod_size = CEX4A_MAX_MOD_SIZE_4K;
 473                         zc->max_exp_bit_length =
 474                                 CEX4A_MAX_MOD_SIZE_4K;
 475                 } else {
 476                         zc->max_mod_size = CEX4A_MAX_MOD_SIZE_2K;
 477                         zc->max_exp_bit_length =
 478                                 CEX4A_MAX_MOD_SIZE_2K;
 479                 }
 480         } else if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
 481                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 482                         zc->type_string = "CEX4C";
 483                         /* wrong user space type, must be CEX4
 484                          * just keep it for cca compatibility
 485                          */
 486                         zc->user_space_type = ZCRYPT_CEX3C;
 487                         zc->speed_rating = CEX4C_SPEED_IDX;
 488                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 489                         zc->type_string = "CEX5C";
 490                         /* wrong user space type, must be CEX5
 491                          * just keep it for cca compatibility
 492                          */
 493                         zc->user_space_type = ZCRYPT_CEX3C;
 494                         zc->speed_rating = CEX5C_SPEED_IDX;
 495                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 496                         zc->type_string = "CEX6C";
 497                         /* wrong user space type, must be CEX6
 498                          * just keep it for cca compatibility
 499                          */
 500                         zc->user_space_type = ZCRYPT_CEX3C;
 501                         zc->speed_rating = CEX6C_SPEED_IDX;
 502                 } else {
 503                         zc->type_string = "CEX7C";
 504                         /* wrong user space type, must be CEX7
 505                          * just keep it for cca compatibility
 506                          */
 507                         zc->user_space_type = ZCRYPT_CEX3C;
 508                         zc->speed_rating = CEX7C_SPEED_IDX;
 509                 }
 510                 zc->min_mod_size = CEX4C_MIN_MOD_SIZE;
 511                 zc->max_mod_size = CEX4C_MAX_MOD_SIZE;
 512                 zc->max_exp_bit_length = CEX4C_MAX_MOD_SIZE;
 513         } else if (ap_test_bit(&ac->functions, AP_FUNC_EP11)) {
 514                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 515                         zc->type_string = "CEX4P";
 516                         zc->user_space_type = ZCRYPT_CEX4;
 517                         zc->speed_rating = CEX4P_SPEED_IDX;
 518                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 519                         zc->type_string = "CEX5P";
 520                         zc->user_space_type = ZCRYPT_CEX5;
 521                         zc->speed_rating = CEX5P_SPEED_IDX;
 522                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 523                         zc->type_string = "CEX6P";
 524                         zc->user_space_type = ZCRYPT_CEX6;
 525                         zc->speed_rating = CEX6P_SPEED_IDX;
 526                 } else {
 527                         zc->type_string = "CEX7P";
 528                         /* wrong user space type, just for compatibility
 529                          * with the ZCRYPT_STATUS_MASK ioctl.
 530                          */
 531                         zc->user_space_type = ZCRYPT_CEX6;
 532                         zc->speed_rating = CEX7P_SPEED_IDX;
 533                 }
 534                 zc->min_mod_size = CEX4C_MIN_MOD_SIZE;
 535                 zc->max_mod_size = CEX4C_MAX_MOD_SIZE;
 536                 zc->max_exp_bit_length = CEX4C_MAX_MOD_SIZE;
 537         } else {
 538                 zcrypt_card_free(zc);
 539                 return -ENODEV;
 540         }
 541         zc->online = 1;
 542
 543         rc = zcrypt_card_register(zc);
 544         if (rc) {
 545                 ac->private = NULL;
 546                 zcrypt_card_free(zc);
 547                 return rc;
 548         }
 549
 550         if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
 551                 rc = sysfs_create_group(&ap_dev->device.kobj,
 552                                         &cca_card_attr_grp);
 553                 if (rc) {
 554                         zcrypt_card_unregister(zc);
 555                         ac->private = NULL;
 556                         zcrypt_card_free(zc);
 557                 }
 558         } else if (ap_test_bit(&ac->functions, AP_FUNC_EP11)) {
 559                 rc = sysfs_create_group(&ap_dev->device.kobj,
 560                                         &ep11_card_attr_grp);
 561                 if (rc) {
 562                         zcrypt_card_unregister(zc);
 563                         ac->private = NULL;
 564                         zcrypt_card_free(zc);
 565                 }
 566         }
 567
 568         return rc;
 569 }
 570
 571 /**
 572  * This is called to remove the CEX4/CEX5/CEX6/CEX7 card driver
 573  * information if an AP card device is removed.
 574  */
 575 static void zcrypt_cex4_card_remove(struct ap_device *ap_dev)
 576 {
 577         struct ap_card *ac = to_ap_card(&ap_dev->device);
 578         struct zcrypt_card *zc = ac->private;
 579
 580         if (ap_test_bit(&ac->functions, AP_FUNC_COPRO))
 581                 sysfs_remove_group(&ap_dev->device.kobj, &cca_card_attr_grp);
 582         else if (ap_test_bit(&ac->functions, AP_FUNC_EP11))
 583                 sysfs_remove_group(&ap_dev->device.kobj, &ep11_card_attr_grp);
 584         if (zc)
 585                 zcrypt_card_unregister(zc);
 586 }
 587
 588 static struct ap_driver zcrypt_cex4_card_driver = {
 589         .probe = zcrypt_cex4_card_probe,
 590         .remove = zcrypt_cex4_card_remove,
 591         .ids = zcrypt_cex4_card_ids,
 592         .flags = AP_DRIVER_FLAG_DEFAULT,
 593 };
 594
 595 /**
 596  * Probe function for CEX4/CEX5/CEX6/CEX7 queue device. It always
 597  * accepts the AP device since the bus_match already checked
 598  * the hardware type.
 599  * @ap_dev: pointer to the AP device.
 600  */
 601 static int zcrypt_cex4_queue_probe(struct ap_device *ap_dev)
 602 {
 603         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 604         struct zcrypt_queue *zq;
 605         int rc;
 606
 607         if (ap_test_bit(&aq->card->functions, AP_FUNC_ACCEL)) {
 608                 zq = zcrypt_queue_alloc(CEX4A_MAX_MESSAGE_SIZE);
 609                 if (!zq)
 610                         return -ENOMEM;
 611                 zq->ops = zcrypt_msgtype(MSGTYPE50_NAME,
 612                                          MSGTYPE50_VARIANT_DEFAULT);
 613         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
 614                 zq = zcrypt_queue_alloc(CEX4C_MAX_MESSAGE_SIZE);
 615                 if (!zq)
 616                         return -ENOMEM;
 617                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 618                                          MSGTYPE06_VARIANT_DEFAULT);
 619         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11)) {
 620                 zq = zcrypt_queue_alloc(CEX4C_MAX_MESSAGE_SIZE);
 621                 if (!zq)
 622                         return -ENOMEM;
 623                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 624                                          MSGTYPE06_VARIANT_EP11);
 625         } else {
 626                 return -ENODEV;
 627         }
 628
 629         zq->queue = aq;
 630         zq->online = 1;
 631         atomic_set(&zq->load, 0);
 632         ap_queue_init_state(aq);
 633         ap_queue_init_reply(aq, &zq->reply);
 634         aq->request_timeout = CEX4_CLEANUP_TIME;
 635         aq->private = zq;
 636         rc = zcrypt_queue_register(zq);
 637         if (rc) {
 638                 aq->private = NULL;
 639                 zcrypt_queue_free(zq);
 640                 return rc;
 641         }
 642
 643         if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
 644                 rc = sysfs_create_group(&ap_dev->device.kobj,
 645                                         &cca_queue_attr_grp);
 646                 if (rc) {
 647                         zcrypt_queue_unregister(zq);
 648                         aq->private = NULL;
 649                         zcrypt_queue_free(zq);
 650                 }
 651         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11)) {
 652                 rc = sysfs_create_group(&ap_dev->device.kobj,
 653                                         &ep11_queue_attr_grp);
 654                 if (rc) {
 655                         zcrypt_queue_unregister(zq);
 656                         aq->private = NULL;
 657                         zcrypt_queue_free(zq);
 658                 }
 659         }
 660
 661         return rc;
 662 }
 663
 664 /**
 665  * This is called to remove the CEX4/CEX5/CEX6/CEX7 queue driver
 666  * information if an AP queue device is removed.
 667  */
 668 static void zcrypt_cex4_queue_remove(struct ap_device *ap_dev)
 669 {
 670         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 671         struct zcrypt_queue *zq = aq->private;
 672
 673         if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO))
 674                 sysfs_remove_group(&ap_dev->device.kobj, &cca_queue_attr_grp);
 675         else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11))
 676                 sysfs_remove_group(&ap_dev->device.kobj, &ep11_queue_attr_grp);
 677         if (zq)
 678                 zcrypt_queue_unregister(zq);
 679 }
 680
 681 static struct ap_driver zcrypt_cex4_queue_driver = {
 682         .probe = zcrypt_cex4_queue_probe,
 683         .remove = zcrypt_cex4_queue_remove,
 684         .ids = zcrypt_cex4_queue_ids,
 685         .flags = AP_DRIVER_FLAG_DEFAULT,
 686 };
 687
 688 int __init zcrypt_cex4_init(void)
 689 {
 690         int rc;
 691
 692         rc = ap_driver_register(&zcrypt_cex4_card_driver,
 693                                 THIS_MODULE, "cex4card");
 694         if (rc)
 695                 return rc;
 696
 697         rc = ap_driver_register(&zcrypt_cex4_queue_driver,
 698                                 THIS_MODULE, "cex4queue");
 699         if (rc)
 700                 ap_driver_unregister(&zcrypt_cex4_card_driver);
 701
 702         return rc;
 703 }
 704
 705 void __exit zcrypt_cex4_exit(void)
 706 {
 707         ap_driver_unregister(&zcrypt_cex4_queue_driver);
 708         ap_driver_unregister(&zcrypt_cex4_card_driver);
 709 }
 710
 711 module_init(zcrypt_cex4_init);
 712 module_exit(zcrypt_cex4_exit);