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.
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.
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.
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
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
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.
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.
47 #include <linux/mutex.h>
48 #include <linux/list.h>
49 #include <linux/bitops.h>
50 #include <linux/delay.h>
51 #include "adf_accel_devices.h"
53 #include "adf_common_drv.h"
55 static LIST_HEAD(service_table
);
56 static DEFINE_MUTEX(service_lock
);
58 static void adf_service_add(struct service_hndl
*service
)
60 mutex_lock(&service_lock
);
61 list_add(&service
->list
, &service_table
);
62 mutex_unlock(&service_lock
);
66 * adf_service_register() - Register acceleration service in the accel framework
67 * @service: Pointer to the service
69 * Function adds the acceleration service to the acceleration framework.
70 * To be used by QAT device specific drivers.
72 * Return: 0 on success, error code othewise.
74 int adf_service_register(struct service_hndl
*service
)
76 service
->init_status
= 0;
77 service
->start_status
= 0;
78 adf_service_add(service
);
81 EXPORT_SYMBOL_GPL(adf_service_register
);
83 static void adf_service_remove(struct service_hndl
*service
)
85 mutex_lock(&service_lock
);
86 list_del(&service
->list
);
87 mutex_unlock(&service_lock
);
91 * adf_service_unregister() - Unregister acceleration service from the framework
92 * @service: Pointer to the service
94 * Function remove the acceleration service from the acceleration framework.
95 * To be used by QAT device specific drivers.
97 * Return: 0 on success, error code othewise.
99 int adf_service_unregister(struct service_hndl
*service
)
101 if (service
->init_status
|| service
->start_status
) {
102 pr_err("QAT: Could not remove active service\n");
105 adf_service_remove(service
);
108 EXPORT_SYMBOL_GPL(adf_service_unregister
);
111 * adf_dev_init() - Init data structures and services for the given accel device
112 * @accel_dev: Pointer to acceleration device.
114 * Initialize the ring data structures and the admin comms and arbitration
117 * Return: 0 on success, error code othewise.
119 int adf_dev_init(struct adf_accel_dev
*accel_dev
)
121 struct service_hndl
*service
;
122 struct list_head
*list_itr
;
123 struct adf_hw_device_data
*hw_data
= accel_dev
->hw_device
;
126 dev_err(&GET_DEV(accel_dev
),
127 "QAT: Failed to init device - hw_data not set\n");
131 if (!test_bit(ADF_STATUS_CONFIGURED
, &accel_dev
->status
)) {
132 pr_info("QAT: Device not configured\n");
136 if (adf_init_etr_data(accel_dev
)) {
137 dev_err(&GET_DEV(accel_dev
), "Failed initialize etr\n");
141 if (hw_data
->init_admin_comms
&& hw_data
->init_admin_comms(accel_dev
)) {
142 dev_err(&GET_DEV(accel_dev
), "Failed initialize admin comms\n");
146 if (hw_data
->init_arb
&& hw_data
->init_arb(accel_dev
)) {
147 dev_err(&GET_DEV(accel_dev
), "Failed initialize hw arbiter\n");
151 hw_data
->enable_ints(accel_dev
);
153 if (adf_ae_init(accel_dev
)) {
154 pr_err("QAT: Failed to initialise Acceleration Engine\n");
157 set_bit(ADF_STATUS_AE_INITIALISED
, &accel_dev
->status
);
159 if (adf_ae_fw_load(accel_dev
)) {
160 pr_err("QAT: Failed to load acceleration FW\n");
161 adf_ae_fw_release(accel_dev
);
164 set_bit(ADF_STATUS_AE_UCODE_LOADED
, &accel_dev
->status
);
166 if (hw_data
->alloc_irq(accel_dev
)) {
167 pr_err("QAT: Failed to allocate interrupts\n");
170 set_bit(ADF_STATUS_IRQ_ALLOCATED
, &accel_dev
->status
);
173 * Subservice initialisation is divided into two stages: init and start.
174 * This is to facilitate any ordering dependencies between services
175 * prior to starting any of the accelerators.
177 list_for_each(list_itr
, &service_table
) {
178 service
= list_entry(list_itr
, struct service_hndl
, list
);
181 if (service
->event_hld(accel_dev
, ADF_EVENT_INIT
)) {
182 pr_err("QAT: Failed to initialise service %s\n",
186 set_bit(accel_dev
->accel_id
, &service
->init_status
);
188 list_for_each(list_itr
, &service_table
) {
189 service
= list_entry(list_itr
, struct service_hndl
, list
);
192 if (service
->event_hld(accel_dev
, ADF_EVENT_INIT
)) {
193 pr_err("QAT: Failed to initialise service %s\n",
197 set_bit(accel_dev
->accel_id
, &service
->init_status
);
200 hw_data
->enable_error_correction(accel_dev
);
204 EXPORT_SYMBOL_GPL(adf_dev_init
);
207 * adf_dev_start() - Start acceleration service for the given accel device
208 * @accel_dev: Pointer to acceleration device.
210 * Function notifies all the registered services that the acceleration device
211 * is ready to be used.
212 * To be used by QAT device specific drivers.
214 * Return: 0 on success, error code othewise.
216 int adf_dev_start(struct adf_accel_dev
*accel_dev
)
218 struct service_hndl
*service
;
219 struct list_head
*list_itr
;
221 set_bit(ADF_STATUS_STARTING
, &accel_dev
->status
);
223 if (adf_ae_start(accel_dev
)) {
224 pr_err("QAT: AE Start Failed\n");
227 set_bit(ADF_STATUS_AE_STARTED
, &accel_dev
->status
);
229 list_for_each(list_itr
, &service_table
) {
230 service
= list_entry(list_itr
, struct service_hndl
, list
);
233 if (service
->event_hld(accel_dev
, ADF_EVENT_START
)) {
234 pr_err("QAT: Failed to start service %s\n",
238 set_bit(accel_dev
->accel_id
, &service
->start_status
);
240 list_for_each(list_itr
, &service_table
) {
241 service
= list_entry(list_itr
, struct service_hndl
, list
);
244 if (service
->event_hld(accel_dev
, ADF_EVENT_START
)) {
245 pr_err("QAT: Failed to start service %s\n",
249 set_bit(accel_dev
->accel_id
, &service
->start_status
);
252 clear_bit(ADF_STATUS_STARTING
, &accel_dev
->status
);
253 set_bit(ADF_STATUS_STARTED
, &accel_dev
->status
);
255 if (qat_algs_register()) {
256 pr_err("QAT: Failed to register crypto algs\n");
257 set_bit(ADF_STATUS_STARTING
, &accel_dev
->status
);
258 clear_bit(ADF_STATUS_STARTED
, &accel_dev
->status
);
263 EXPORT_SYMBOL_GPL(adf_dev_start
);
266 * adf_dev_stop() - Stop acceleration service for the given accel device
267 * @accel_dev: Pointer to acceleration device.
269 * Function notifies all the registered services that the acceleration device
271 * To be used by QAT device specific drivers.
273 * Return: 0 on success, error code othewise.
275 int adf_dev_stop(struct adf_accel_dev
*accel_dev
)
277 struct service_hndl
*service
;
278 struct list_head
*list_itr
;
282 if (!adf_dev_started(accel_dev
) &&
283 !test_bit(ADF_STATUS_STARTING
, &accel_dev
->status
)) {
286 clear_bit(ADF_STATUS_STARTING
, &accel_dev
->status
);
287 clear_bit(ADF_STATUS_STARTED
, &accel_dev
->status
);
289 if (qat_algs_unregister())
290 pr_err("QAT: Failed to unregister crypto algs\n");
292 list_for_each(list_itr
, &service_table
) {
293 service
= list_entry(list_itr
, struct service_hndl
, list
);
296 if (!test_bit(accel_dev
->accel_id
, &service
->start_status
))
298 ret
= service
->event_hld(accel_dev
, ADF_EVENT_STOP
);
300 clear_bit(accel_dev
->accel_id
, &service
->start_status
);
301 } else if (ret
== -EAGAIN
) {
303 clear_bit(accel_dev
->accel_id
, &service
->start_status
);
306 list_for_each(list_itr
, &service_table
) {
307 service
= list_entry(list_itr
, struct service_hndl
, list
);
310 if (!test_bit(accel_dev
->accel_id
, &service
->start_status
))
312 if (service
->event_hld(accel_dev
, ADF_EVENT_STOP
))
313 pr_err("QAT: Failed to shutdown service %s\n",
316 clear_bit(accel_dev
->accel_id
, &service
->start_status
);
322 if (test_bit(ADF_STATUS_AE_STARTED
, &accel_dev
->status
)) {
323 if (adf_ae_stop(accel_dev
))
324 pr_err("QAT: failed to stop AE\n");
326 clear_bit(ADF_STATUS_AE_STARTED
, &accel_dev
->status
);
331 EXPORT_SYMBOL_GPL(adf_dev_stop
);
334 * adf_dev_shutdown() - shutdown acceleration services and data strucutures
335 * @accel_dev: Pointer to acceleration device
337 * Cleanup the ring data structures and the admin comms and arbitration
340 void adf_dev_shutdown(struct adf_accel_dev
*accel_dev
)
342 struct adf_hw_device_data
*hw_data
= accel_dev
->hw_device
;
343 struct service_hndl
*service
;
344 struct list_head
*list_itr
;
347 dev_err(&GET_DEV(accel_dev
),
348 "QAT: Failed to shutdown device - hw_data not set\n");
352 if (test_bit(ADF_STATUS_AE_UCODE_LOADED
, &accel_dev
->status
)) {
353 if (adf_ae_fw_release(accel_dev
))
354 pr_err("QAT: Failed to release the ucode\n");
356 clear_bit(ADF_STATUS_AE_UCODE_LOADED
,
360 if (test_bit(ADF_STATUS_AE_INITIALISED
, &accel_dev
->status
)) {
361 if (adf_ae_shutdown(accel_dev
))
362 pr_err("QAT: Failed to shutdown Accel Engine\n");
364 clear_bit(ADF_STATUS_AE_INITIALISED
,
368 list_for_each(list_itr
, &service_table
) {
369 service
= list_entry(list_itr
, struct service_hndl
, list
);
372 if (!test_bit(accel_dev
->accel_id
, &service
->init_status
))
374 if (service
->event_hld(accel_dev
, ADF_EVENT_SHUTDOWN
))
375 pr_err("QAT: Failed to shutdown service %s\n",
378 clear_bit(accel_dev
->accel_id
, &service
->init_status
);
380 list_for_each(list_itr
, &service_table
) {
381 service
= list_entry(list_itr
, struct service_hndl
, list
);
384 if (!test_bit(accel_dev
->accel_id
, &service
->init_status
))
386 if (service
->event_hld(accel_dev
, ADF_EVENT_SHUTDOWN
))
387 pr_err("QAT: Failed to shutdown service %s\n",
390 clear_bit(accel_dev
->accel_id
, &service
->init_status
);
393 if (test_bit(ADF_STATUS_IRQ_ALLOCATED
, &accel_dev
->status
)) {
394 hw_data
->free_irq(accel_dev
);
395 clear_bit(ADF_STATUS_IRQ_ALLOCATED
, &accel_dev
->status
);
398 /* Delete configuration only if not restarting */
399 if (!test_bit(ADF_STATUS_RESTARTING
, &accel_dev
->status
))
400 adf_cfg_del_all(accel_dev
);
402 if (hw_data
->exit_arb
)
403 hw_data
->exit_arb(accel_dev
);
405 if (hw_data
->exit_admin_comms
)
406 hw_data
->exit_admin_comms(accel_dev
);
408 adf_cleanup_etr_data(accel_dev
);
410 EXPORT_SYMBOL_GPL(adf_dev_shutdown
);
412 int adf_dev_restarting_notify(struct adf_accel_dev
*accel_dev
)
414 struct service_hndl
*service
;
415 struct list_head
*list_itr
;
417 list_for_each(list_itr
, &service_table
) {
418 service
= list_entry(list_itr
, struct service_hndl
, list
);
421 if (service
->event_hld(accel_dev
, ADF_EVENT_RESTARTING
))
422 pr_err("QAT: Failed to restart service %s.\n",
425 list_for_each(list_itr
, &service_table
) {
426 service
= list_entry(list_itr
, struct service_hndl
, list
);
429 if (service
->event_hld(accel_dev
, ADF_EVENT_RESTARTING
))
430 pr_err("QAT: Failed to restart service %s.\n",
436 int adf_dev_restarted_notify(struct adf_accel_dev
*accel_dev
)
438 struct service_hndl
*service
;
439 struct list_head
*list_itr
;
441 list_for_each(list_itr
, &service_table
) {
442 service
= list_entry(list_itr
, struct service_hndl
, list
);
445 if (service
->event_hld(accel_dev
, ADF_EVENT_RESTARTED
))
446 pr_err("QAT: Failed to restart service %s.\n",
449 list_for_each(list_itr
, &service_table
) {
450 service
= list_entry(list_itr
, struct service_hndl
, list
);
453 if (service
->event_hld(accel_dev
, ADF_EVENT_RESTARTED
))
454 pr_err("QAT: Failed to restart service %s.\n",