linux/drivers/s390/crypto/zcrypt_cex4.c
<<
>>
Prefs
   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
  41MODULE_AUTHOR("IBM Corporation");
  42MODULE_DESCRIPTION("CEX4/CEX5/CEX6/CEX7 Cryptographic Card device driver, " \
  43                   "Copyright IBM Corp. 2019");
  44MODULE_LICENSE("GPL");
  45
  46static 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
  58MODULE_DEVICE_TABLE(ap, zcrypt_cex4_card_ids);
  59
  60static 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
  72MODULE_DEVICE_TABLE(ap, zcrypt_cex4_queue_ids);
  73
  74/*
  75 * CCA card additional device attributes
  76 */
  77static 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
  93static struct device_attribute dev_attr_cca_serialnr =
  94        __ATTR(serialnr, 0444, cca_serialnr_show, NULL);
  95
  96static struct attribute *cca_card_attrs[] = {
  97        &dev_attr_cca_serialnr.attr,
  98        NULL,
  99};
 100
 101static const struct attribute_group cca_card_attr_grp = {
 102        .attrs = cca_card_attrs,
 103};
 104
 105 /*
 106  * CCA queue additional device attributes
 107  */
 108static 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
 174static struct device_attribute dev_attr_cca_mkvps =
 175        __ATTR(mkvps, 0444, cca_mkvps_show, NULL);
 176
 177static struct attribute *cca_queue_attrs[] = {
 178        &dev_attr_cca_mkvps.attr,
 179        NULL,
 180};
 181
 182static const struct attribute_group cca_queue_attr_grp = {
 183        .attrs = cca_queue_attrs,
 184};
 185
 186/*
 187 * EP11 card additional device attributes
 188 */
 189static 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
 207static struct device_attribute dev_attr_ep11_api_ordinalnr =
 208        __ATTR(API_ordinalnr, 0444, ep11_api_ordinalnr_show, NULL);
 209
 210static 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
 230static struct device_attribute dev_attr_ep11_fw_version =
 231        __ATTR(FW_version, 0444, ep11_fw_version_show, NULL);
 232
 233static 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
 251static struct device_attribute dev_attr_ep11_serialnr =
 252        __ATTR(serialnr, 0444, ep11_serialnr_show, NULL);
 253
 254static 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
 266static 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
 292static struct device_attribute dev_attr_ep11_card_op_modes =
 293        __ATTR(op_modes, 0444, ep11_card_op_modes_show, NULL);
 294
 295static 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
 303static const struct attribute_group ep11_card_attr_grp = {
 304        .attrs = ep11_card_attrs,
 305};
 306
 307/*
 308 * EP11 queue additional device attributes
 309 */
 310
 311static 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
 356static struct device_attribute dev_attr_ep11_mkvps =
 357        __ATTR(mkvps, 0444, ep11_mkvps_show, NULL);
 358
 359static 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
 387static struct device_attribute dev_attr_ep11_queue_op_modes =
 388        __ATTR(op_modes, 0444, ep11_queue_op_modes_show, NULL);
 389
 390static struct attribute *ep11_queue_attrs[] = {
 391        &dev_attr_ep11_mkvps.attr,
 392        &dev_attr_ep11_queue_op_modes.attr,
 393        NULL,
 394};
 395
 396static 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 */
 406static 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 */
 575static 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
 588static 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 */
 601static 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 */
 668static 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
 681static 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
 688int __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
 705void __exit zcrypt_cex4_exit(void)
 706{
 707        ap_driver_unregister(&zcrypt_cex4_queue_driver);
 708        ap_driver_unregister(&zcrypt_cex4_card_driver);
 709}
 710
 711module_init(zcrypt_cex4_init);
 712module_exit(zcrypt_cex4_exit);
 713