gmac get mac form eeprom

hc

2024-05-10 37f49e37ab4cb5d0bc4c60eb5c6d4dd57db767bb

 kernel/drivers/crypto/caam/key_gen.c
..
..
@@ -15,15 +15,14 @@
15
15
 			   void *context)
16
16
 {
17
17
 	struct split_key_result *res = context;
18
+	int ecode = 0;
18
19
 
19
-#ifdef DEBUG
20
-	dev_err(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
21
-#endif
20
+	dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
22
21
 
23
22
 	if (err)
24
-		caam_jr_strstatus(dev, err);
23
+		ecode = caam_jr_strstatus(dev, err);
25
24
 
26
-	res->err = err;
25
+	res->err = ecode;
27
26
 
28
27
 	complete(&res->completion);
29
28
 }
..
..
@@ -48,21 +47,21 @@
48
47
 {
49
48
 	u32 *desc;
50
49
 	struct split_key_result result;
51
-	dma_addr_t dma_addr_in, dma_addr_out;
50
+	dma_addr_t dma_addr;
51
+	unsigned int local_max;
52
52
 	int ret = -ENOMEM;
53
53
 
54
54
 	adata->keylen = split_key_len(adata->algtype & OP_ALG_ALGSEL_MASK);
55
55
 	adata->keylen_pad = split_key_pad_len(adata->algtype &
56
56
 					      OP_ALG_ALGSEL_MASK);
57
+	local_max = max(keylen, adata->keylen_pad);
57
58
 
58
-#ifdef DEBUG
59
-	dev_err(jrdev, "split keylen %d split keylen padded %d\n",
59
+	dev_dbg(jrdev, "split keylen %d split keylen padded %d\n",
60
60
 		adata->keylen, adata->keylen_pad);
61
-	print_hex_dump(KERN_ERR, "ctx.key@" __stringify(__LINE__)": ",
62
-		       DUMP_PREFIX_ADDRESS, 16, 4, key_in, keylen, 1);
63
-#endif
61
+	print_hex_dump_debug("ctx.key@" __stringify(__LINE__)": ",
62
+			     DUMP_PREFIX_ADDRESS, 16, 4, key_in, keylen, 1);
64
63
 
65
-	if (adata->keylen_pad > max_keylen)
64
+	if (local_max > max_keylen)
66
65
 		return -EINVAL;
67
66
 
68
67
 	desc = kmalloc(CAAM_CMD_SZ * 6 + CAAM_PTR_SZ * 2, GFP_KERNEL | GFP_DMA);
..
..
@@ -71,22 +70,16 @@
71
70
 		return ret;
72
71
 	}
73
72
 
74
-	dma_addr_in = dma_map_single(jrdev, (void *)key_in, keylen,
75
-				     DMA_TO_DEVICE);
76
-	if (dma_mapping_error(jrdev, dma_addr_in)) {
77
-		dev_err(jrdev, "unable to map key input memory\n");
73
+	memcpy(key_out, key_in, keylen);
74
+
75
+	dma_addr = dma_map_single(jrdev, key_out, local_max, DMA_BIDIRECTIONAL);
76
+	if (dma_mapping_error(jrdev, dma_addr)) {
77
+		dev_err(jrdev, "unable to map key memory\n");
78
78
 		goto out_free;
79
79
 	}
80
80
 
81
-	dma_addr_out = dma_map_single(jrdev, key_out, adata->keylen_pad,
82
-				      DMA_FROM_DEVICE);
83
-	if (dma_mapping_error(jrdev, dma_addr_out)) {
84
-		dev_err(jrdev, "unable to map key output memory\n");
85
-		goto out_unmap_in;
86
-	}
87
-
88
81
 	init_job_desc(desc, 0);
89
-	append_key(desc, dma_addr_in, keylen, CLASS_2 | KEY_DEST_CLASS_REG);
82
+	append_key(desc, dma_addr, keylen, CLASS_2 | KEY_DEST_CLASS_REG);
90
83
 
91
84
 	/* Sets MDHA up into an HMAC-INIT */
92
85
 	append_operation(desc, (adata->algtype & OP_ALG_ALGSEL_MASK) |
..
..
@@ -104,35 +97,28 @@
104
97
 	 * FIFO_STORE with the explicit split-key content store
105
98
 	 * (0x26 output type)
106
99
 	 */
107
-	append_fifo_store(desc, dma_addr_out, adata->keylen,
100
+	append_fifo_store(desc, dma_addr, adata->keylen,
108
101
 			  LDST_CLASS_2_CCB | FIFOST_TYPE_SPLIT_KEK);
109
102
 
110
-#ifdef DEBUG
111
-	print_hex_dump(KERN_ERR, "ctx.key@"__stringify(__LINE__)": ",
112
-		       DUMP_PREFIX_ADDRESS, 16, 4, key_in, keylen, 1);
113
-	print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
114
-		       DUMP_PREFIX_ADDRESS, 16, 4, desc, desc_bytes(desc), 1);
115
-#endif
103
+	print_hex_dump_debug("jobdesc@"__stringify(__LINE__)": ",
104
+			     DUMP_PREFIX_ADDRESS, 16, 4, desc, desc_bytes(desc),
105
+			     1);
116
106
 
117
107
 	result.err = 0;
118
108
 	init_completion(&result.completion);
119
109
 
120
110
 	ret = caam_jr_enqueue(jrdev, desc, split_key_done, &result);
121
-	if (!ret) {
111
+	if (ret == -EINPROGRESS) {
122
112
 		/* in progress */
123
113
 		wait_for_completion(&result.completion);
124
114
 		ret = result.err;
125
-#ifdef DEBUG
126
-		print_hex_dump(KERN_ERR, "ctx.key@"__stringify(__LINE__)": ",
127
-			       DUMP_PREFIX_ADDRESS, 16, 4, key_out,
128
-			       adata->keylen_pad, 1);
129
-#endif
115
+
116
+		print_hex_dump_debug("ctx.key@"__stringify(__LINE__)": ",
117
+				     DUMP_PREFIX_ADDRESS, 16, 4, key_out,
118
+				     adata->keylen_pad, 1);
130
119
 	}
131
120
 
132
-	dma_unmap_single(jrdev, dma_addr_out, adata->keylen_pad,
133
-			 DMA_FROM_DEVICE);
134
-out_unmap_in:
135
-	dma_unmap_single(jrdev, dma_addr_in, keylen, DMA_TO_DEVICE);
121
+	dma_unmap_single(jrdev, dma_addr, local_max, DMA_BIDIRECTIONAL);
136
122
 out_free:
137
123
 	kfree(desc);
138
124
 	return ret;