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 otherwise.
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 otherwise.
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 otherwise.
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 "Failed to init device - hw_data not set\n");
131 if (!test_bit(ADF_STATUS_CONFIGURED, &accel_dev->status)) {
132 dev_err(&GET_DEV(accel_dev), "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 dev_err(&GET_DEV(accel_dev),
155 "Failed to initialise Acceleration Engine\n");
158 set_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status);
160 if (adf_ae_fw_load(accel_dev)) {
161 dev_err(&GET_DEV(accel_dev),
162 "Failed to load acceleration FW\n");
165 set_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);
167 if (hw_data->alloc_irq(accel_dev)) {
168 dev_err(&GET_DEV(accel_dev), "Failed to allocate interrupts\n");
171 set_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);
174 * Subservice initialisation is divided into two stages: init and start.
175 * This is to facilitate any ordering dependencies between services
176 * prior to starting any of the accelerators.
178 list_for_each(list_itr, &service_table) {
179 service = list_entry(list_itr, struct service_hndl, list);
180 if (service->event_hld(accel_dev, ADF_EVENT_INIT)) {
181 dev_err(&GET_DEV(accel_dev),
182 "Failed to initialise service %s\n",
186 set_bit(accel_dev->accel_id, &service->init_status);
189 hw_data->enable_error_correction(accel_dev);
190 hw_data->enable_vf2pf_comms(accel_dev);
194 EXPORT_SYMBOL_GPL(adf_dev_init);
197 * adf_dev_start() - Start acceleration service for the given accel device
198 * @accel_dev: Pointer to acceleration device.
200 * Function notifies all the registered services that the acceleration device
201 * is ready to be used.
202 * To be used by QAT device specific drivers.
204 * Return: 0 on success, error code otherwise.
206 int adf_dev_start(struct adf_accel_dev *accel_dev)
208 struct adf_hw_device_data *hw_data = accel_dev->hw_device;
209 struct service_hndl *service;
210 struct list_head *list_itr;
212 set_bit(ADF_STATUS_STARTING, &accel_dev->status);
214 if (adf_ae_start(accel_dev)) {
215 dev_err(&GET_DEV(accel_dev), "AE Start Failed\n");
218 set_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
220 if (hw_data->send_admin_init(accel_dev)) {
221 dev_err(&GET_DEV(accel_dev), "Failed to send init message\n");
225 list_for_each(list_itr, &service_table) {
226 service = list_entry(list_itr, struct service_hndl, list);
227 if (service->event_hld(accel_dev, ADF_EVENT_START)) {
228 dev_err(&GET_DEV(accel_dev),
229 "Failed to start service %s\n",
233 set_bit(accel_dev->accel_id, &service->start_status);
236 clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
237 set_bit(ADF_STATUS_STARTED, &accel_dev->status);
239 if (!list_empty(&accel_dev->crypto_list) &&
240 (qat_algs_register() || qat_asym_algs_register())) {
241 dev_err(&GET_DEV(accel_dev),
242 "Failed to register crypto algs\n");
243 set_bit(ADF_STATUS_STARTING, &accel_dev->status);
244 clear_bit(ADF_STATUS_STARTED, &accel_dev->status);
249 EXPORT_SYMBOL_GPL(adf_dev_start);
252 * adf_dev_stop() - Stop acceleration service for the given accel device
253 * @accel_dev: Pointer to acceleration device.
255 * Function notifies all the registered services that the acceleration device
257 * To be used by QAT device specific drivers.
259 * Return: 0 on success, error code otherwise.
261 int adf_dev_stop(struct adf_accel_dev *accel_dev)
263 struct service_hndl *service;
264 struct list_head *list_itr;
268 if (!adf_dev_started(accel_dev) &&
269 !test_bit(ADF_STATUS_STARTING, &accel_dev->status)) {
272 clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
273 clear_bit(ADF_STATUS_STARTED, &accel_dev->status);
275 if (!list_empty(&accel_dev->crypto_list) && qat_algs_unregister())
276 dev_err(&GET_DEV(accel_dev),
277 "Failed to unregister crypto algs\n");
279 if (!list_empty(&accel_dev->crypto_list))
280 qat_asym_algs_unregister();
282 list_for_each(list_itr, &service_table) {
283 service = list_entry(list_itr, struct service_hndl, list);
284 if (!test_bit(accel_dev->accel_id, &service->start_status))
286 ret = service->event_hld(accel_dev, ADF_EVENT_STOP);
288 clear_bit(accel_dev->accel_id, &service->start_status);
289 } else if (ret == -EAGAIN) {
291 clear_bit(accel_dev->accel_id, &service->start_status);
298 if (test_bit(ADF_STATUS_AE_STARTED, &accel_dev->status)) {
299 if (adf_ae_stop(accel_dev))
300 dev_err(&GET_DEV(accel_dev), "failed to stop AE\n");
302 clear_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
307 EXPORT_SYMBOL_GPL(adf_dev_stop);
310 * adf_dev_shutdown() - shutdown acceleration services and data strucutures
311 * @accel_dev: Pointer to acceleration device
313 * Cleanup the ring data structures and the admin comms and arbitration
316 void adf_dev_shutdown(struct adf_accel_dev *accel_dev)
318 struct adf_hw_device_data *hw_data = accel_dev->hw_device;
319 struct service_hndl *service;
320 struct list_head *list_itr;
323 dev_err(&GET_DEV(accel_dev),
324 "QAT: Failed to shutdown device - hw_data not set\n");
328 if (test_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status)) {
329 adf_ae_fw_release(accel_dev);
330 clear_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);
333 if (test_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status)) {
334 if (adf_ae_shutdown(accel_dev))
335 dev_err(&GET_DEV(accel_dev),
336 "Failed to shutdown Accel Engine\n");
338 clear_bit(ADF_STATUS_AE_INITIALISED,
342 list_for_each(list_itr, &service_table) {
343 service = list_entry(list_itr, struct service_hndl, list);
344 if (!test_bit(accel_dev->accel_id, &service->init_status))
346 if (service->event_hld(accel_dev, ADF_EVENT_SHUTDOWN))
347 dev_err(&GET_DEV(accel_dev),
348 "Failed to shutdown service %s\n",
351 clear_bit(accel_dev->accel_id, &service->init_status);
354 if (test_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status)) {
355 hw_data->free_irq(accel_dev);
356 clear_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);
359 /* Delete configuration only if not restarting */
360 if (!test_bit(ADF_STATUS_RESTARTING, &accel_dev->status))
361 adf_cfg_del_all(accel_dev);
363 if (hw_data->exit_arb)
364 hw_data->exit_arb(accel_dev);
366 if (hw_data->exit_admin_comms)
367 hw_data->exit_admin_comms(accel_dev);
369 hw_data->disable_iov(accel_dev);
370 adf_cleanup_etr_data(accel_dev);
372 EXPORT_SYMBOL_GPL(adf_dev_shutdown);
374 int adf_dev_restarting_notify(struct adf_accel_dev *accel_dev)
376 struct service_hndl *service;
377 struct list_head *list_itr;
379 list_for_each(list_itr, &service_table) {
380 service = list_entry(list_itr, struct service_hndl, list);
381 if (service->event_hld(accel_dev, ADF_EVENT_RESTARTING))
382 dev_err(&GET_DEV(accel_dev),
383 "Failed to restart service %s.\n",
389 int adf_dev_restarted_notify(struct adf_accel_dev *accel_dev)
391 struct service_hndl *service;
392 struct list_head *list_itr;
394 list_for_each(list_itr, &service_table) {
395 service = list_entry(list_itr, struct service_hndl, list);
396 if (service->event_hld(accel_dev, ADF_EVENT_RESTARTED))
397 dev_err(&GET_DEV(accel_dev),
398 "Failed to restart service %s.\n",