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 snprintf(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_mk_state >= '1' && ci.new_mk_state <= '3')
 125                 n = snprintf(buf, PAGE_SIZE, "AES NEW: %s 0x%016llx\n",
 126                              new_state[ci.new_mk_state - '1'], ci.new_mkvp);
 127         else
 128                 n = snprintf(buf, PAGE_SIZE, "AES NEW: - -\n");
 129
 130         if (ci.cur_mk_state >= '1' && ci.cur_mk_state <= '2')
 131                 n += snprintf(buf + n, PAGE_SIZE - n, "AES CUR: %s 0x%016llx\n",
 132                               cao_state[ci.cur_mk_state - '1'], ci.cur_mkvp);
 133         else
 134                 n += snprintf(buf + n, PAGE_SIZE - n, "AES CUR: - -\n");
 135
 136         if (ci.old_mk_state >= '1' && ci.old_mk_state <= '2')
 137                 n += snprintf(buf + n, PAGE_SIZE - n, "AES OLD: %s 0x%016llx\n",
 138                               cao_state[ci.old_mk_state - '1'], ci.old_mkvp);
 139         else
 140                 n += snprintf(buf + n, PAGE_SIZE - n, "AES OLD: - -\n");
 141
 142         return n;
 143 }
 144
 145 static struct device_attribute dev_attr_cca_mkvps =
 146         __ATTR(mkvps, 0444, cca_mkvps_show, NULL);
 147
 148 static struct attribute *cca_queue_attrs[] = {
 149         &dev_attr_cca_mkvps.attr,
 150         NULL,
 151 };
 152
 153 static const struct attribute_group cca_queue_attr_grp = {
 154         .attrs = cca_queue_attrs,
 155 };
 156
 157 /*
 158  * EP11 card additional device attributes
 159  */
 160 static ssize_t ep11_api_ordinalnr_show(struct device *dev,
 161                                        struct device_attribute *attr,
 162                                        char *buf)
 163 {
 164         struct ep11_card_info ci;
 165         struct ap_card *ac = to_ap_card(dev);
 166         struct zcrypt_card *zc = ac->private;
 167
 168         memset(&ci, 0, sizeof(ci));
 169
 170         ep11_get_card_info(ac->id, &ci, zc->online);
 171
 172         if (ci.API_ord_nr > 0)
 173                 return snprintf(buf, PAGE_SIZE, "%u\n", ci.API_ord_nr);
 174         else
 175                 return snprintf(buf, PAGE_SIZE, "\n");
 176 }
 177
 178 static struct device_attribute dev_attr_ep11_api_ordinalnr =
 179         __ATTR(API_ordinalnr, 0444, ep11_api_ordinalnr_show, NULL);
 180
 181 static ssize_t ep11_fw_version_show(struct device *dev,
 182                                     struct device_attribute *attr,
 183                                     char *buf)
 184 {
 185         struct ep11_card_info ci;
 186         struct ap_card *ac = to_ap_card(dev);
 187         struct zcrypt_card *zc = ac->private;
 188
 189         memset(&ci, 0, sizeof(ci));
 190
 191         ep11_get_card_info(ac->id, &ci, zc->online);
 192
 193         if (ci.FW_version > 0)
 194                 return snprintf(buf, PAGE_SIZE, "%d.%d\n",
 195                                 (int)(ci.FW_version >> 8),
 196                                 (int)(ci.FW_version & 0xFF));
 197         else
 198                 return snprintf(buf, PAGE_SIZE, "\n");
 199 }
 200
 201 static struct device_attribute dev_attr_ep11_fw_version =
 202         __ATTR(FW_version, 0444, ep11_fw_version_show, NULL);
 203
 204 static ssize_t ep11_serialnr_show(struct device *dev,
 205                                   struct device_attribute *attr,
 206                                   char *buf)
 207 {
 208         struct ep11_card_info ci;
 209         struct ap_card *ac = to_ap_card(dev);
 210         struct zcrypt_card *zc = ac->private;
 211
 212         memset(&ci, 0, sizeof(ci));
 213
 214         ep11_get_card_info(ac->id, &ci, zc->online);
 215
 216         if (ci.serial[0])
 217                 return snprintf(buf, PAGE_SIZE, "%16.16s\n", ci.serial);
 218         else
 219                 return snprintf(buf, PAGE_SIZE, "\n");
 220 }
 221
 222 static struct device_attribute dev_attr_ep11_serialnr =
 223         __ATTR(serialnr, 0444, ep11_serialnr_show, NULL);
 224
 225 static const struct {
 226         int         mode_bit;
 227         const char *mode_txt;
 228 } ep11_op_modes[] = {
 229         { 0, "FIPS2009" },
 230         { 1, "BSI2009" },
 231         { 2, "FIPS2011" },
 232         { 3, "BSI2011" },
 233         { 6, "BSICC2017" },
 234         { 0, NULL }
 235 };
 236
 237 static ssize_t ep11_card_op_modes_show(struct device *dev,
 238                                        struct device_attribute *attr,
 239                                        char *buf)
 240 {
 241         int i, n = 0;
 242         struct ep11_card_info ci;
 243         struct ap_card *ac = to_ap_card(dev);
 244         struct zcrypt_card *zc = ac->private;
 245
 246         memset(&ci, 0, sizeof(ci));
 247
 248         ep11_get_card_info(ac->id, &ci, zc->online);
 249
 250         for (i = 0; ep11_op_modes[i].mode_txt; i++) {
 251                 if (ci.op_mode & (1 << ep11_op_modes[i].mode_bit)) {
 252                         if (n > 0)
 253                                 buf[n++] = ' ';
 254                         n += snprintf(buf + n, PAGE_SIZE - n,
 255                                       "%s", ep11_op_modes[i].mode_txt);
 256                 }
 257         }
 258         n += snprintf(buf + n, PAGE_SIZE - n, "\n");
 259
 260         return n;
 261 }
 262
 263 static struct device_attribute dev_attr_ep11_card_op_modes =
 264         __ATTR(op_modes, 0444, ep11_card_op_modes_show, NULL);
 265
 266 static struct attribute *ep11_card_attrs[] = {
 267         &dev_attr_ep11_api_ordinalnr.attr,
 268         &dev_attr_ep11_fw_version.attr,
 269         &dev_attr_ep11_serialnr.attr,
 270         &dev_attr_ep11_card_op_modes.attr,
 271         NULL,
 272 };
 273
 274 static const struct attribute_group ep11_card_attr_grp = {
 275         .attrs = ep11_card_attrs,
 276 };
 277
 278 /*
 279  * EP11 queue additional device attributes
 280  */
 281
 282 static ssize_t ep11_mkvps_show(struct device *dev,
 283                                struct device_attribute *attr,
 284                                char *buf)
 285 {
 286         int n = 0;
 287         struct ep11_domain_info di;
 288         struct zcrypt_queue *zq = to_ap_queue(dev)->private;
 289         static const char * const cwk_state[] = { "invalid", "valid" };
 290         static const char * const nwk_state[] = { "empty", "uncommitted",
 291                                                   "committed" };
 292
 293         memset(&di, 0, sizeof(di));
 294
 295         if (zq->online)
 296                 ep11_get_domain_info(AP_QID_CARD(zq->queue->qid),
 297                                      AP_QID_QUEUE(zq->queue->qid),
 298                                      &di);
 299
 300         if (di.cur_wk_state == '0') {
 301                 n = snprintf(buf, PAGE_SIZE, "WK CUR: %s -\n",
 302                              cwk_state[di.cur_wk_state - '0']);
 303         } else if (di.cur_wk_state == '1') {
 304                 n = snprintf(buf, PAGE_SIZE, "WK CUR: %s 0x",
 305                              cwk_state[di.cur_wk_state - '0']);
 306                 bin2hex(buf + n, di.cur_wkvp, sizeof(di.cur_wkvp));
 307                 n += 2 * sizeof(di.cur_wkvp);
 308                 n += snprintf(buf + n, PAGE_SIZE - n, "\n");
 309         } else
 310                 n = snprintf(buf, PAGE_SIZE, "WK CUR: - -\n");
 311
 312         if (di.new_wk_state == '0') {
 313                 n += snprintf(buf + n, PAGE_SIZE - n, "WK NEW: %s -\n",
 314                               nwk_state[di.new_wk_state - '0']);
 315         } else if (di.new_wk_state >= '1' && di.new_wk_state <= '2') {
 316                 n += snprintf(buf + n, PAGE_SIZE - n, "WK NEW: %s 0x",
 317                               nwk_state[di.new_wk_state - '0']);
 318                 bin2hex(buf + n, di.new_wkvp, sizeof(di.new_wkvp));
 319                 n += 2 * sizeof(di.new_wkvp);
 320                 n += snprintf(buf + n, PAGE_SIZE - n, "\n");
 321         } else
 322                 n += snprintf(buf + n, PAGE_SIZE - n, "WK NEW: - -\n");
 323
 324         return n;
 325 }
 326
 327 static struct device_attribute dev_attr_ep11_mkvps =
 328         __ATTR(mkvps, 0444, ep11_mkvps_show, NULL);
 329
 330 static ssize_t ep11_queue_op_modes_show(struct device *dev,
 331                                         struct device_attribute *attr,
 332                                         char *buf)
 333 {
 334         int i, n = 0;
 335         struct ep11_domain_info di;
 336         struct zcrypt_queue *zq = to_ap_queue(dev)->private;
 337
 338         memset(&di, 0, sizeof(di));
 339
 340         if (zq->online)
 341                 ep11_get_domain_info(AP_QID_CARD(zq->queue->qid),
 342                                      AP_QID_QUEUE(zq->queue->qid),
 343                                      &di);
 344
 345         for (i = 0; ep11_op_modes[i].mode_txt; i++) {
 346                 if (di.op_mode & (1 << ep11_op_modes[i].mode_bit)) {
 347                         if (n > 0)
 348                                 buf[n++] = ' ';
 349                         n += snprintf(buf + n, PAGE_SIZE - n,
 350                                       "%s", ep11_op_modes[i].mode_txt);
 351                 }
 352         }
 353         n += snprintf(buf + n, PAGE_SIZE - n, "\n");
 354
 355         return n;
 356 }
 357
 358 static struct device_attribute dev_attr_ep11_queue_op_modes =
 359         __ATTR(op_modes, 0444, ep11_queue_op_modes_show, NULL);
 360
 361 static struct attribute *ep11_queue_attrs[] = {
 362         &dev_attr_ep11_mkvps.attr,
 363         &dev_attr_ep11_queue_op_modes.attr,
 364         NULL,
 365 };
 366
 367 static const struct attribute_group ep11_queue_attr_grp = {
 368         .attrs = ep11_queue_attrs,
 369 };
 370
 371 /**
 372  * Probe function for CEX4/CEX5/CEX6/CEX7 card device. It always
 373  * accepts the AP device since the bus_match already checked
 374  * the hardware type.
 375  * @ap_dev: pointer to the AP device.
 376  */
 377 static int zcrypt_cex4_card_probe(struct ap_device *ap_dev)
 378 {
 379         /*
 380          * Normalized speed ratings per crypto adapter
 381          * MEX_1k, MEX_2k, MEX_4k, CRT_1k, CRT_2k, CRT_4k, RNG, SECKEY
 382          */
 383         static const int CEX4A_SPEED_IDX[] = {
 384                  14,  19, 249, 42, 228, 1458, 0, 0};
 385         static const int CEX5A_SPEED_IDX[] = {
 386                   8,   9,  20, 18,  66,  458, 0, 0};
 387         static const int CEX6A_SPEED_IDX[] = {
 388                   6,   9,  20, 17,  65,  438, 0, 0};
 389         static const int CEX7A_SPEED_IDX[] = {
 390                   6,   8,  17, 15,  54,  362, 0, 0};
 391
 392         static const int CEX4C_SPEED_IDX[] = {
 393                  59,  69, 308, 83, 278, 2204, 209, 40};
 394         static const int CEX5C_SPEED_IDX[] = {
 395                  24,  31,  50, 37,  90,  479,  27, 10};
 396         static const int CEX6C_SPEED_IDX[] = {
 397                  16,  20,  32, 27,  77,  455,  24,  9};
 398         static const int CEX7C_SPEED_IDX[] = {
 399                  14,  16,  26, 23,  64,  376,  23,  8};
 400
 401         static const int CEX4P_SPEED_IDX[] = {
 402                   0,   0,   0,   0,   0,   0,   0,  50};
 403         static const int CEX5P_SPEED_IDX[] = {
 404                   0,   0,   0,   0,   0,   0,   0,  10};
 405         static const int CEX6P_SPEED_IDX[] = {
 406                   0,   0,   0,   0,   0,   0,   0,   9};
 407         static const int CEX7P_SPEED_IDX[] = {
 408                   0,   0,   0,   0,   0,   0,   0,   8};
 409
 410         struct ap_card *ac = to_ap_card(&ap_dev->device);
 411         struct zcrypt_card *zc;
 412         int rc = 0;
 413
 414         zc = zcrypt_card_alloc();
 415         if (!zc)
 416                 return -ENOMEM;
 417         zc->card = ac;
 418         ac->private = zc;
 419         if (ap_test_bit(&ac->functions, AP_FUNC_ACCEL)) {
 420                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 421                         zc->type_string = "CEX4A";
 422                         zc->user_space_type = ZCRYPT_CEX4;
 423                         memcpy(zc->speed_rating, CEX4A_SPEED_IDX,
 424                                sizeof(CEX4A_SPEED_IDX));
 425                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 426                         zc->type_string = "CEX5A";
 427                         zc->user_space_type = ZCRYPT_CEX5;
 428                         memcpy(zc->speed_rating, CEX5A_SPEED_IDX,
 429                                sizeof(CEX5A_SPEED_IDX));
 430                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 431                         zc->type_string = "CEX6A";
 432                         zc->user_space_type = ZCRYPT_CEX6;
 433                         memcpy(zc->speed_rating, CEX6A_SPEED_IDX,
 434                                sizeof(CEX6A_SPEED_IDX));
 435                 } else {
 436                         zc->type_string = "CEX7A";
 437                         /* wrong user space type, just for compatibility
 438                          * with the ZCRYPT_STATUS_MASK ioctl.
 439                          */
 440                         zc->user_space_type = ZCRYPT_CEX6;
 441                         memcpy(zc->speed_rating, CEX7A_SPEED_IDX,
 442                                sizeof(CEX7A_SPEED_IDX));
 443                 }
 444                 zc->min_mod_size = CEX4A_MIN_MOD_SIZE;
 445                 if (ap_test_bit(&ac->functions, AP_FUNC_MEX4K) &&
 446                     ap_test_bit(&ac->functions, AP_FUNC_CRT4K)) {
 447                         zc->max_mod_size = CEX4A_MAX_MOD_SIZE_4K;
 448                         zc->max_exp_bit_length =
 449                                 CEX4A_MAX_MOD_SIZE_4K;
 450                 } else {
 451                         zc->max_mod_size = CEX4A_MAX_MOD_SIZE_2K;
 452                         zc->max_exp_bit_length =
 453                                 CEX4A_MAX_MOD_SIZE_2K;
 454                 }
 455         } else if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
 456                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 457                         zc->type_string = "CEX4C";
 458                         /* wrong user space type, must be CEX4
 459                          * just keep it for cca compatibility
 460                          */
 461                         zc->user_space_type = ZCRYPT_CEX3C;
 462                         memcpy(zc->speed_rating, CEX4C_SPEED_IDX,
 463                                sizeof(CEX4C_SPEED_IDX));
 464                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 465                         zc->type_string = "CEX5C";
 466                         /* wrong user space type, must be CEX5
 467                          * just keep it for cca compatibility
 468                          */
 469                         zc->user_space_type = ZCRYPT_CEX3C;
 470                         memcpy(zc->speed_rating, CEX5C_SPEED_IDX,
 471                                sizeof(CEX5C_SPEED_IDX));
 472                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 473                         zc->type_string = "CEX6C";
 474                         /* wrong user space type, must be CEX6
 475                          * just keep it for cca compatibility
 476                          */
 477                         zc->user_space_type = ZCRYPT_CEX3C;
 478                         memcpy(zc->speed_rating, CEX6C_SPEED_IDX,
 479                                sizeof(CEX6C_SPEED_IDX));
 480                 } else {
 481                         zc->type_string = "CEX7C";
 482                         /* wrong user space type, must be CEX7
 483                          * just keep it for cca compatibility
 484                          */
 485                         zc->user_space_type = ZCRYPT_CEX3C;
 486                         memcpy(zc->speed_rating, CEX7C_SPEED_IDX,
 487                                sizeof(CEX7C_SPEED_IDX));
 488                 }
 489                 zc->min_mod_size = CEX4C_MIN_MOD_SIZE;
 490                 zc->max_mod_size = CEX4C_MAX_MOD_SIZE;
 491                 zc->max_exp_bit_length = CEX4C_MAX_MOD_SIZE;
 492         } else if (ap_test_bit(&ac->functions, AP_FUNC_EP11)) {
 493                 if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX4) {
 494                         zc->type_string = "CEX4P";
 495                         zc->user_space_type = ZCRYPT_CEX4;
 496                         memcpy(zc->speed_rating, CEX4P_SPEED_IDX,
 497                                sizeof(CEX4P_SPEED_IDX));
 498                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX5) {
 499                         zc->type_string = "CEX5P";
 500                         zc->user_space_type = ZCRYPT_CEX5;
 501                         memcpy(zc->speed_rating, CEX5P_SPEED_IDX,
 502                                sizeof(CEX5P_SPEED_IDX));
 503                 } else if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX6) {
 504                         zc->type_string = "CEX6P";
 505                         zc->user_space_type = ZCRYPT_CEX6;
 506                         memcpy(zc->speed_rating, CEX6P_SPEED_IDX,
 507                                sizeof(CEX6P_SPEED_IDX));
 508                 } else {
 509                         zc->type_string = "CEX7P";
 510                         /* wrong user space type, just for compatibility
 511                          * with the ZCRYPT_STATUS_MASK ioctl.
 512                          */
 513                         zc->user_space_type = ZCRYPT_CEX6;
 514                         memcpy(zc->speed_rating, CEX7P_SPEED_IDX,
 515                                sizeof(CEX7P_SPEED_IDX));
 516                 }
 517                 zc->min_mod_size = CEX4C_MIN_MOD_SIZE;
 518                 zc->max_mod_size = CEX4C_MAX_MOD_SIZE;
 519                 zc->max_exp_bit_length = CEX4C_MAX_MOD_SIZE;
 520         } else {
 521                 zcrypt_card_free(zc);
 522                 return -ENODEV;
 523         }
 524         zc->online = 1;
 525
 526         rc = zcrypt_card_register(zc);
 527         if (rc) {
 528                 ac->private = NULL;
 529                 zcrypt_card_free(zc);
 530                 goto out;
 531         }
 532
 533         if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
 534                 rc = sysfs_create_group(&ap_dev->device.kobj,
 535                                         &cca_card_attr_grp);
 536                 if (rc)
 537                         zcrypt_card_unregister(zc);
 538         } else if (ap_test_bit(&ac->functions, AP_FUNC_EP11)) {
 539                 rc = sysfs_create_group(&ap_dev->device.kobj,
 540                                         &ep11_card_attr_grp);
 541                 if (rc)
 542                         zcrypt_card_unregister(zc);
 543         }
 544
 545 out:
 546         return rc;
 547 }
 548
 549 /**
 550  * This is called to remove the CEX4/CEX5/CEX6/CEX7 card driver
 551  * information if an AP card device is removed.
 552  */
 553 static void zcrypt_cex4_card_remove(struct ap_device *ap_dev)
 554 {
 555         struct ap_card *ac = to_ap_card(&ap_dev->device);
 556         struct zcrypt_card *zc = ac->private;
 557
 558         if (ap_test_bit(&ac->functions, AP_FUNC_COPRO))
 559                 sysfs_remove_group(&ap_dev->device.kobj, &cca_card_attr_grp);
 560         else if (ap_test_bit(&ac->functions, AP_FUNC_EP11))
 561                 sysfs_remove_group(&ap_dev->device.kobj, &ep11_card_attr_grp);
 562         if (zc)
 563                 zcrypt_card_unregister(zc);
 564 }
 565
 566 static struct ap_driver zcrypt_cex4_card_driver = {
 567         .probe = zcrypt_cex4_card_probe,
 568         .remove = zcrypt_cex4_card_remove,
 569         .ids = zcrypt_cex4_card_ids,
 570         .flags = AP_DRIVER_FLAG_DEFAULT,
 571 };
 572
 573 /**
 574  * Probe function for CEX4/CEX5/CEX6/CEX7 queue device. It always
 575  * accepts the AP device since the bus_match already checked
 576  * the hardware type.
 577  * @ap_dev: pointer to the AP device.
 578  */
 579 static int zcrypt_cex4_queue_probe(struct ap_device *ap_dev)
 580 {
 581         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 582         struct zcrypt_queue *zq;
 583         int rc;
 584
 585         if (ap_test_bit(&aq->card->functions, AP_FUNC_ACCEL)) {
 586                 zq = zcrypt_queue_alloc(CEX4A_MAX_MESSAGE_SIZE);
 587                 if (!zq)
 588                         return -ENOMEM;
 589                 zq->ops = zcrypt_msgtype(MSGTYPE50_NAME,
 590                                          MSGTYPE50_VARIANT_DEFAULT);
 591         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
 592                 zq = zcrypt_queue_alloc(CEX4C_MAX_MESSAGE_SIZE);
 593                 if (!zq)
 594                         return -ENOMEM;
 595                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 596                                          MSGTYPE06_VARIANT_DEFAULT);
 597         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11)) {
 598                 zq = zcrypt_queue_alloc(CEX4C_MAX_MESSAGE_SIZE);
 599                 if (!zq)
 600                         return -ENOMEM;
 601                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 602                                          MSGTYPE06_VARIANT_EP11);
 603         } else {
 604                 return -ENODEV;
 605         }
 606
 607         zq->queue = aq;
 608         zq->online = 1;
 609         atomic_set(&zq->load, 0);
 610         ap_queue_init_state(aq);
 611         ap_queue_init_reply(aq, &zq->reply);
 612         aq->request_timeout = CEX4_CLEANUP_TIME,
 613         aq->private = zq;
 614         rc = zcrypt_queue_register(zq);
 615         if (rc) {
 616                 aq->private = NULL;
 617                 zcrypt_queue_free(zq);
 618                 goto out;
 619         }
 620
 621         if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
 622                 rc = sysfs_create_group(&ap_dev->device.kobj,
 623                                         &cca_queue_attr_grp);
 624                 if (rc)
 625                         zcrypt_queue_unregister(zq);
 626         } else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11)) {
 627                 rc = sysfs_create_group(&ap_dev->device.kobj,
 628                                         &ep11_queue_attr_grp);
 629                 if (rc)
 630                         zcrypt_queue_unregister(zq);
 631         }
 632
 633 out:
 634         return rc;
 635 }
 636
 637 /**
 638  * This is called to remove the CEX4/CEX5/CEX6/CEX7 queue driver
 639  * information if an AP queue device is removed.
 640  */
 641 static void zcrypt_cex4_queue_remove(struct ap_device *ap_dev)
 642 {
 643         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 644         struct zcrypt_queue *zq = aq->private;
 645
 646         if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO))
 647                 sysfs_remove_group(&ap_dev->device.kobj, &cca_queue_attr_grp);
 648         else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11))
 649                 sysfs_remove_group(&ap_dev->device.kobj, &ep11_queue_attr_grp);
 650         if (zq)
 651                 zcrypt_queue_unregister(zq);
 652 }
 653
 654 static struct ap_driver zcrypt_cex4_queue_driver = {
 655         .probe = zcrypt_cex4_queue_probe,
 656         .remove = zcrypt_cex4_queue_remove,
 657         .suspend = ap_queue_suspend,
 658         .resume = ap_queue_resume,
 659         .ids = zcrypt_cex4_queue_ids,
 660         .flags = AP_DRIVER_FLAG_DEFAULT,
 661 };
 662
 663 int __init zcrypt_cex4_init(void)
 664 {
 665         int rc;
 666
 667         rc = ap_driver_register(&zcrypt_cex4_card_driver,
 668                                 THIS_MODULE, "cex4card");
 669         if (rc)
 670                 return rc;
 671
 672         rc = ap_driver_register(&zcrypt_cex4_queue_driver,
 673                                 THIS_MODULE, "cex4queue");
 674         if (rc)
 675                 ap_driver_unregister(&zcrypt_cex4_card_driver);
 676
 677         return rc;
 678 }
 679
 680 void __exit zcrypt_cex4_exit(void)
 681 {
 682         ap_driver_unregister(&zcrypt_cex4_queue_driver);
 683         ap_driver_unregister(&zcrypt_cex4_card_driver);
 684 }
 685
 686 module_init(zcrypt_cex4_init);
 687 module_exit(zcrypt_cex4_exit);