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