mirror of
https://github.com/ARM-software/arm-trusted-firmware.git
synced 2025-04-18 02:24:18 +00:00
050a99a62f
NXP drivers header files are moved: - from: drivers/nxp/<xx>/*.h - to : include/drivers/nxp/<xx>/*.h To accommodate these changes each drivers makefiles drivers/nxp/<xx>/xx.mk, are updated. Signed-off-by: Pankaj Gupta <pankaj.gupta@nxp.com> Change-Id: I3979c509724d87e3d631a03dbafda1ee5ef07d21
178 lines
7.6 KiB
C
178 lines
7.6 KiB
C
/*
|
|
* Copyright 2017-2021 NXP
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
*/
|
|
|
|
#ifndef _JR_DRIVER_H_
|
|
#define _JR_DRIVER_H_
|
|
|
|
#include "jr_driver_config.h"
|
|
|
|
/* The maximum size of a SEC descriptor, in WORDs (32 bits). */
|
|
#define MAX_DESC_SIZE_WORDS 64
|
|
|
|
#define CAAM_TIMEOUT 200000 /* ms */
|
|
|
|
/* Return codes for JR user space driver APIs */
|
|
typedef enum sec_return_code_e {
|
|
SEC_SUCCESS = 0,
|
|
SEC_INVALID_INPUT_PARAM,
|
|
SEC_OUT_OF_MEMORY,
|
|
SEC_DESCRIPTOR_IN_FLIGHT,
|
|
SEC_LAST_DESCRIPTOR_IN_FLIGHT,
|
|
SEC_PROCESSING_ERROR,
|
|
SEC_DESC_PROCESSING_ERROR,
|
|
SEC_JR_IS_FULL,
|
|
SEC_DRIVER_RELEASE_IN_PROGRESS,
|
|
SEC_DRIVER_ALREADY_INITIALIZED,
|
|
SEC_DRIVER_NOT_INITIALIZED,
|
|
SEC_JOB_RING_RESET_IN_PROGRESS,
|
|
SEC_RESET_ENGINE_FAILED,
|
|
SEC_ENABLE_IRQS_FAILED,
|
|
SEC_DISABLE_IRQS_FAILED,
|
|
SEC_RETURN_CODE_MAX_VALUE,
|
|
} sec_return_code_t;
|
|
|
|
/* STRUCTURES AND OTHER TYPEDEFS */
|
|
|
|
/*
|
|
* @brief Function called by JR User Space driver to notify every processed
|
|
* descriptor.
|
|
*
|
|
* Callback provided by the User Application.
|
|
* Callback is invoked by JR User Space driver for each descriptor processed by
|
|
* SEC
|
|
* @param [in] status Status word indicating processing result for
|
|
* this descriptor.
|
|
* @param [in] arg Opaque data passed by User Application
|
|
* It is opaque from JR driver's point of view.
|
|
* @param [in] job_ring The job ring handle on which the processed
|
|
* descriptor word was enqueued
|
|
*/
|
|
typedef void (*user_callback) (uint32_t *desc, uint32_t status,
|
|
void *arg, void *job_ring);
|
|
|
|
/*
|
|
* Structure encompassing a job descriptor which is to be processed
|
|
* by SEC. User should also initialise this structure with the callback
|
|
* function pointer which will be called by driver after recieving proccessed
|
|
* descriptor from SEC. User data is also passed in this data structure which
|
|
* will be sent as an argument to the user callback function.
|
|
*/
|
|
struct job_descriptor {
|
|
uint32_t desc[MAX_DESC_SIZE_WORDS];
|
|
void *arg;
|
|
user_callback callback;
|
|
};
|
|
|
|
/*
|
|
* @brief Initialize the JR User Space driver.
|
|
* This function will handle initialization of sec library
|
|
* along with registering platform specific callbacks,
|
|
* as well as local data initialization.
|
|
* Call once during application startup.
|
|
* @note Global SEC initialization is done in SEC kernel driver.
|
|
* @note The hardware IDs of the initialized Job Rings are opaque to the UA.
|
|
* The exact Job Rings used by this library are decided between SEC user
|
|
* space driver and SEC kernel driver. A static partitioning of Job Rings is
|
|
* assumed, configured in DTS(device tree specification) file.
|
|
* @param [in] platform_cb Registering the platform specific
|
|
* callbacks with driver
|
|
* @retval ::0 for successful execution
|
|
* @retval ::-1 failure
|
|
*/
|
|
int sec_jr_lib_init(void);
|
|
|
|
/*
|
|
* @brief Initialize the software and hardware resources tied to a job ring.
|
|
* @param [in] jr_mode; Model to be used by SEC Driver to receive
|
|
* notifications from SEC. Can be either
|
|
* SEC_NOTIFICATION_TYPE_IRQ or
|
|
* SEC_NOTIFICATION_TYPE_POLL
|
|
* @param [in] irq_coalescing_timer This value determines the maximum
|
|
* amount of time after processing a
|
|
* descriptor before raising an interrupt.
|
|
* @param [in] irq_coalescing_count This value determines how many
|
|
* descriptors are completed before
|
|
* raising an interrupt.
|
|
* @param [in] reg_base_addr The job ring base address register
|
|
* @param [in] irq_id The job ring interrupt identification number.
|
|
* @retval job_ring_handle for successful job ring configuration
|
|
* @retval NULL on error
|
|
*/
|
|
void *init_job_ring(uint8_t jr_mode,
|
|
uint16_t irq_coalescing_timer,
|
|
uint8_t irq_coalescing_count,
|
|
void *reg_base_addr, uint32_t irq_id);
|
|
|
|
/*
|
|
* @brief Release the resources used by the JR User Space driver.
|
|
* Reset and release SEC's job rings indicated by the User Application at
|
|
* init_job_ring() and free any memory allocated internally.
|
|
* Call once during application tear down.
|
|
* @note In case there are any descriptors in-flight (descriptors received by
|
|
* JR driver for processing and for which no response was yet provided to UA),
|
|
* the descriptors are discarded without any notifications to User Application.
|
|
* @retval ::0 is returned for a successful execution
|
|
* @retval ::-1 is returned if JR driver release is in progress
|
|
*/
|
|
int sec_release(void);
|
|
|
|
/*
|
|
* @brief Submit a descriptor for SEC processing.
|
|
* This function creates a "job" which is meant to instruct SEC HW
|
|
* to perform the processing on the input buffer. The "job" is enqueued
|
|
* in the Job Ring associated. The function will return after the "job"
|
|
* enqueue is finished. The function will not wait for SEC to
|
|
* start or/and finish the "job" processing.
|
|
* After the processing is finished the SEC HW writes the processing result
|
|
* to the provided output buffer.
|
|
* The Caller must poll JR driver using jr_dequeue()
|
|
* to receive notifications of the processing completion
|
|
* status. The notifications are received by caller by means of callback
|
|
* (see ::user_callback).
|
|
* @param [in] job_ring_handle The handle of the job ring on which
|
|
* descriptor is to be enqueued
|
|
* @param [in] job_descriptor The job descriptor structure of type
|
|
* struct job_descriptor. This structure
|
|
* should be filled with job descriptor along
|
|
* with callback function to be called after
|
|
* processing of descriptor and some
|
|
* opaque data passed to be passed to the
|
|
* callback function
|
|
*
|
|
* @retval ::0 is returned for successful execution
|
|
* @retval ::-1 is returned if there is some enqueue failure
|
|
*/
|
|
int enq_jr_desc(void *job_ring_handle, struct job_descriptor *jobdescr);
|
|
|
|
/*
|
|
* @brief Polls for available descriptors processed by SEC on a specific
|
|
* Job Ring
|
|
* This function polls the SEC Job Rings and delivers processed descriptors
|
|
* Each processed descriptor has a user_callback registered.
|
|
* This user_callback is invoked for each processed descriptor.
|
|
* The polling is stopped when "limit" descriptors are notified or when
|
|
* there are no more descriptors to notify.
|
|
* @note The dequeue_jr() API cannot be called from within a user_callback
|
|
* function
|
|
* @param [in] job_ring_handle The Job Ring handle.
|
|
* @param [in] limit This value represents the maximum number
|
|
* of processed descriptors that can be
|
|
* notified API call on this Job Ring.
|
|
* Note that fewer descriptors may be notified
|
|
* if enough processed descriptors are not
|
|
* available.
|
|
* If limit has a negative value, then all
|
|
* ready descriptors will be notified.
|
|
*
|
|
* @retval :: >=0 is returned where retval is the total
|
|
* Number of descriptors notified
|
|
* during this function call.
|
|
* @retval :: -1 is returned in case of some error
|
|
*/
|
|
int dequeue_jr(void *job_ring_handle, int32_t limit);
|
|
|
|
#endif /* _JR_DRIVER_H_ */
|