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);
713