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