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