forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 37f49e37ab4cb5d0bc4c60eb5c6d4dd57db767bb 
 kernel/drivers/crypto/qat/qat_common/adf_admin.c
....@@ -1,53 +1,9 @@
1
-/*
2
-  This file is provided under a dual BSD/GPLv2 license.  When using or
3
-  redistributing this file, you may do so under either license.
4
-
5
-  GPL LICENSE SUMMARY
6
-  Copyright(c) 2014 Intel Corporation.
7
-  This program is free software; you can redistribute it and/or modify
8
-  it under the terms of version 2 of the GNU General Public License as
9
-  published by the Free Software Foundation.
10
-
11
-  This program is distributed in the hope that it will be useful, but
12
-  WITHOUT ANY WARRANTY; without even the implied warranty of
13
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
-  General Public License for more details.
15
-
16
-  Contact Information:
17
-  qat-linux@intel.com
18
-
19
-  BSD LICENSE
20
-  Copyright(c) 2014 Intel Corporation.
21
-  Redistribution and use in source and binary forms, with or without
22
-  modification, are permitted provided that the following conditions
23
-  are met:
24
-
25
-    * Redistributions of source code must retain the above copyright
26
-      notice, this list of conditions and the following disclaimer.
27
-    * Redistributions in binary form must reproduce the above copyright
28
-      notice, this list of conditions and the following disclaimer in
29
-      the documentation and/or other materials provided with the
30
-      distribution.
31
-    * Neither the name of Intel Corporation nor the names of its
32
-      contributors may be used to endorse or promote products derived
33
-      from this software without specific prior written permission.
34
-
35
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
36
-  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
37
-  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
38
-  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
39
-  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40
-  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41
-  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
42
-  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
43
-  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
44
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
45
-  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
46
-*/
1
+// SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
2
+/* Copyright(c) 2014 - 2020 Intel Corporation */
473 #include <linux/types.h>
484 #include <linux/mutex.h>
495 #include <linux/slab.h>
50
-#include <linux/delay.h>
6
+#include <linux/iopoll.h>
517 #include <linux/pci.h>
528 #include <linux/dma-mapping.h>
539 #include "adf_accel_devices.h"
....@@ -60,6 +16,9 @@
6016 #define ADF_DH895XCC_MAILBOX_BASE_OFFSET 0x20970
6117 #define ADF_DH895XCC_MAILBOX_STRIDE 0x1000
6218 #define ADF_ADMINMSG_LEN 32
19
+#define ADF_CONST_TABLE_SIZE 1024
20
+#define ADF_ADMIN_POLL_DELAY_US 20
21
+#define ADF_ADMIN_POLL_TIMEOUT_US (5 * USEC_PER_SEC)
6322 
6423 static const u8 const_tab[1024] __aligned(1024) = {
6524 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
....@@ -154,11 +113,13 @@
154113 static int adf_put_admin_msg_sync(struct adf_accel_dev *accel_dev, u32 ae,
155114 				  void *in, void *out)
156115 {
116
+	int ret;
117
+	u32 status;
157118 	struct adf_admin_comms *admin = accel_dev->admin;
158119 	int offset = ae * ADF_ADMINMSG_LEN * 2;
159120 	void __iomem *mailbox = admin->mailbox_addr;
160121 	int mb_offset = ae * ADF_DH895XCC_MAILBOX_STRIDE;
161
-	int times, received;
122
+	struct icp_qat_fw_init_admin_req *request = in;
162123 
163124 	mutex_lock(&admin->lock);
164125 
....@@ -169,46 +130,72 @@
169130 
170131 	memcpy(admin->virt_addr + offset, in, ADF_ADMINMSG_LEN);
171132 	ADF_CSR_WR(mailbox, mb_offset, 1);
172
-	received = 0;
173
-	for (times = 0; times < 50; times++) {
174
-		msleep(20);
175
-		if (ADF_CSR_RD(mailbox, mb_offset) == 0) {
176
-			received = 1;
177
-			break;
178
-		}
179
-	}
180
-	if (received)
133
+
134
+	ret = read_poll_timeout(ADF_CSR_RD, status, status == 0,
135
+				ADF_ADMIN_POLL_DELAY_US,
136
+				ADF_ADMIN_POLL_TIMEOUT_US, true,
137
+				mailbox, mb_offset);
138
+	if (ret < 0) {
139
+		/* Response timeout */
140
+		dev_err(&GET_DEV(accel_dev),
141
+			"Failed to send admin msg %d to accelerator %d\n",
142
+			request->cmd_id, ae);
143
+	} else {
144
+		/* Response received from admin message, we can now
145
+		 * make response data available in "out" parameter.
146
+		 */
181147 		memcpy(out, admin->virt_addr + offset +
182148 		       ADF_ADMINMSG_LEN, ADF_ADMINMSG_LEN);
183
-	else
184
-		dev_err(&GET_DEV(accel_dev),
185
-			"Failed to send admin msg to accelerator\n");
149
+	}
186150 
187151 	mutex_unlock(&admin->lock);
188
-	return received ? 0 : -EFAULT;
152
+	return ret;
189153 }
190154 
191
-static int adf_send_admin_cmd(struct adf_accel_dev *accel_dev, int cmd)
155
+static int adf_send_admin(struct adf_accel_dev *accel_dev,
156
+			  struct icp_qat_fw_init_admin_req *req,
157
+			  struct icp_qat_fw_init_admin_resp *resp,
158
+			  const unsigned long ae_mask)
192159 {
193
-	struct adf_hw_device_data *hw_device = accel_dev->hw_device;
160
+	u32 ae;
161
+
162
+	for_each_set_bit(ae, &ae_mask, ICP_QAT_HW_AE_DELIMITER)
163
+		if (adf_put_admin_msg_sync(accel_dev, ae, req, resp) ||
164
+		    resp->status)
165
+			return -EFAULT;
166
+
167
+	return 0;
168
+}
169
+
170
+static int adf_init_me(struct adf_accel_dev *accel_dev)
171
+{
194172 	struct icp_qat_fw_init_admin_req req;
195173 	struct icp_qat_fw_init_admin_resp resp;
196
-	int i;
174
+	struct adf_hw_device_data *hw_device = accel_dev->hw_device;
175
+	u32 ae_mask = hw_device->ae_mask;
197176 
198
-	memset(&req, 0, sizeof(struct icp_qat_fw_init_admin_req));
199
-	req.init_admin_cmd_id = cmd;
177
+	memset(&req, 0, sizeof(req));
178
+	memset(&resp, 0, sizeof(resp));
179
+	req.cmd_id = ICP_QAT_FW_INIT_ME;
200180 
201
-	if (cmd == ICP_QAT_FW_CONSTANTS_CFG) {
202
-		req.init_cfg_sz = 1024;
203
-		req.init_cfg_ptr = accel_dev->admin->const_tbl_addr;
204
-	}
205
-	for (i = 0; i < hw_device->get_num_aes(hw_device); i++) {
206
-		memset(&resp, 0, sizeof(struct icp_qat_fw_init_admin_resp));
207
-		if (adf_put_admin_msg_sync(accel_dev, i, &req, &resp) ||
208
-		    resp.init_resp_hdr.status)
209
-			return -EFAULT;
210
-	}
211
-	return 0;
181
+	return adf_send_admin(accel_dev, &req, &resp, ae_mask);
182
+}
183
+
184
+static int adf_set_fw_constants(struct adf_accel_dev *accel_dev)
185
+{
186
+	struct icp_qat_fw_init_admin_req req;
187
+	struct icp_qat_fw_init_admin_resp resp;
188
+	struct adf_hw_device_data *hw_device = accel_dev->hw_device;
189
+	u32 ae_mask = hw_device->ae_mask;
190
+
191
+	memset(&req, 0, sizeof(req));
192
+	memset(&resp, 0, sizeof(resp));
193
+	req.cmd_id = ICP_QAT_FW_CONSTANTS_CFG;
194
+
195
+	req.init_cfg_sz = ADF_CONST_TABLE_SIZE;
196
+	req.init_cfg_ptr = accel_dev->admin->const_tbl_addr;
197
+
198
+	return adf_send_admin(accel_dev, &req, &resp, ae_mask);
212199 }
213200 
214201 /**
....@@ -221,11 +208,13 @@
221208  */
222209 int adf_send_admin_init(struct adf_accel_dev *accel_dev)
223210 {
224
-	int ret = adf_send_admin_cmd(accel_dev, ICP_QAT_FW_INIT_ME);
211
+	int ret;
225212 
213
+	ret = adf_init_me(accel_dev);
226214 	if (ret)
227215 		return ret;
228
-	return adf_send_admin_cmd(accel_dev, ICP_QAT_FW_CONSTANTS_CFG);
216
+
217
+	return adf_set_fw_constants(accel_dev);
229218 }
230219 EXPORT_SYMBOL_GPL(adf_send_admin_init);
231220 
....@@ -244,18 +233,18 @@
244233 			     dev_to_node(&GET_DEV(accel_dev)));
245234 	if (!admin)
246235 		return -ENOMEM;
247
-	admin->virt_addr = dma_zalloc_coherent(&GET_DEV(accel_dev), PAGE_SIZE,
248
-					       &admin->phy_addr, GFP_KERNEL);
236
+	admin->virt_addr = dma_alloc_coherent(&GET_DEV(accel_dev), PAGE_SIZE,
237
+					      &admin->phy_addr, GFP_KERNEL);
249238 	if (!admin->virt_addr) {
250239 		dev_err(&GET_DEV(accel_dev), "Failed to allocate dma buff\n");
251240 		kfree(admin);
252241 		return -ENOMEM;
253242 	}
254243 
255
-	admin->virt_tbl_addr = dma_zalloc_coherent(&GET_DEV(accel_dev),
256
-						   PAGE_SIZE,
257
-						   &admin->const_tbl_addr,
258
-						   GFP_KERNEL);
244
+	admin->virt_tbl_addr = dma_alloc_coherent(&GET_DEV(accel_dev),
245
+						  PAGE_SIZE,
246
+						  &admin->const_tbl_addr,
247
+						  GFP_KERNEL);
259248 	if (!admin->virt_tbl_addr) {
260249 		dev_err(&GET_DEV(accel_dev), "Failed to allocate const_tbl\n");
261250 		dma_free_coherent(&GET_DEV(accel_dev), PAGE_SIZE,