diff options
Diffstat (limited to 'otherservice/event_library/library/include/other_service/ev_lib.h')
| -rw-r--r-- | otherservice/event_library/library/include/other_service/ev_lib.h | 1856 |
1 files changed, 1856 insertions, 0 deletions
diff --git a/otherservice/event_library/library/include/other_service/ev_lib.h b/otherservice/event_library/library/include/other_service/ev_lib.h new file mode 100644 index 00000000..6b87ea27 --- /dev/null +++ b/otherservice/event_library/library/include/other_service/ev_lib.h @@ -0,0 +1,1856 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file ev_lib.h + * @brief \~english Event library -- API define head file + */ + +#ifndef OTHERSERVICE_EV_LIB_H_ // NOLINT(build/header_guard) +#define OTHERSERVICE_EV_LIB_H_ // NOLINT(build/header_guard) + +#include <agl_types_obsoluted.h> +#include <agldd/ev_common.h> +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup other_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup event_library + * @ingroup other_service + * @{ + */ + +#ifndef __KERNEL__ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* Create/Delete flag and message queue */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag +/// \~english @par Brief +/// Create flag for event flag by the flag_id. +/// \~english @param [in] flag_id +/// EV_ID - Flag ID of the flag event +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist Duplication Error +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id: The ID is not created by function of EV_moduleID_to_flagID(). +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - flag_id registered in launch thread +/// - Flag corresponding to flag_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Creates flag with ID specified by the argument. +/// An error occurs if flag of the specified ID already exists. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_create_flag, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag(EV_ID flag_id); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag64 +/// \~english @par Brief +/// Create flag for event flag by the flag_id. +/// \~english @param [in] flag_id +/// EV_ID - Flag ID of the flag event +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist Duplication Error +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id: The ID is not created by function of EV_moduleID_to_flag64ID (). +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - flag_id registered in launch thread +/// - Flag corresponding to flag_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Creates flag with ID specified by the argument. +/// An error occurs if flag of the specified ID already exists. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_create_flag, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag64(EV_ID flag_id); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_queue +/// \~english @par Brief +/// Create message queue with the queue_id. +/// \~english @param [in] queue_id +/// EV_ID - queue_id of message event +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [in] length +/// UINT8 - length of message queue (Maximum accumulated number of the messages) +/// \~english @param [in] max_bytes +/// UINT16 - the maximum number of bytes per 1 message(MAX 2048) +/// \~english @param [in] type +/// EV_Message_Queue_Type - classification of the processing when the queue received more event +/// - in the queue full state. +/// \~english @par +/// EV_Message_Queue_Type +/// \~english @code +/// typedef UINT8 EV_Message_Queue_Type; +/// - EV_MESSAGE_QUEUE_TYPE_BUSY = 0 // Return error(EV_ERR_Busy) to origin of message transmission +/// - EV_MESSAGE_QUEUE_TYPE_FIFO = 1 // Delete the top message of the queue, and shift message +/// // (Delete the oldest message) +/// - EV_MESSAGE_QUEUE_TYPE_REPLACE = 2 // Overwrite the last message of the queue +/// // (Overwrite the newest message) +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist Duplication Error +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id is not created by function of EV_moduleID_to_queueID (). +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - queue_id registered in launch thread +/// - Message queue corresponding to queue_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Message queue pool is NULL +/// - Message queue generation corresponding to queue_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Creates message queue with ID specified by the argument. +/// When queue is created, a memory area corresponding to "length" x "max_bytes" is dynamically secured. +/// An error occurs if queue of the specified ID already exists. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_create_message_queue, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_queue(EV_ID queue_id, // NOLINT (readability/nolint) + UINT8 length, // NOLINT (readability/nolint) + UINT16 max_bytes, // NOLINT (readability/nolint) + EV_Message_Queue_Type type); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag_auto_id +/// \~english @par Brief +/// Automatically assign flag ID, and creates flag with flag ID. +/// \~english @param [out] flag_id +/// EV_ID* - flag_id assigned automatically +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Automatically assign flag ID, and creates flag with flag ID. +/// It is the same as "EV_create_flag" except that flag ID is automatically allocated. +/// \~english @see EV_create_flag, evk_open, evk_close, evk_ioctl, evk_create_flag, evk_alloc_flag_id, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag_auto_id(/* OUT */EV_ID *flag_id); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag64_auto_id +/// \~english @par Brief +/// Automatically assign flag ID, and creates flag with flag ID. +/// \~english @param [out] flag_id +/// EV_ID* - flag_id assigned automatically +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Automatically assign flag ID, and creates flag with flag ID. +/// It is the same as "EV_create_flag" except that flag ID is automatically allocated. +/// \~english @see EV_create_flag, evk_open, evk_close, evk_ioctl, evk_create_flag, evk_alloc_flag_id, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag64_auto_id(/* OUT */EV_ID *flag_id); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_queue_auto_id +/// \~english @par Brief +/// Automatically assign queue ID, and creates message queue with queue ID. +/// It stores queue_id assigned automatically in argument. +/// \~english @param [out] queue_id +/// EV_ID* - queue_id assigned automatically +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [in] length +/// UINT8 - length of message queue (Maximum accumulated number of the messages) +/// \~english @param [in] max_bytes +/// UINT16 - the maximum number of bytes per 1 message(MAX 2048) +/// \~english @param [in] type +/// EV_Message_Queue_Type - classification of the processing when the queue received more event +/// in the queue full state. +/// \~english @par +/// EV_Message_Queue_Type +/// \~english @code +/// typedef UINT8 EV_Message_Queue_Type; +/// - EV_MESSAGE_QUEUE_TYPE_BUSY = 0 // Return error(EV_ERR_Busy) to origin of message transmission +/// - EV_MESSAGE_QUEUE_TYPE_FIFO = 1 // Delete the top message of the queue, and shift message +/// // (Delete the oldest message) +/// - EV_MESSAGE_QUEUE_TYPE_REPLACE = 2 // Overwrite the last message of the queue +/// // (Overwrite the newest message) +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Thread is unregistered and threads started up to the maximum of event thread(16 threads) +/// - EV_ERR_Thread_Over +/// - Message queue corresponding to queue_id already exists +/// - Securing free space of thread information management table (malloc) Failure +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Message queue pool is NULL +/// - Message queue generation corresponding to queue_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Automatically assign queue id, and creates message queue with queue id, It stores queue_id +/// assigned automatically in argument. +/// It is the same as "EV_queue_flag" except that queue ID is automatically allocated. +/// \~english @see EV_create_queue, evk_open, evk_close, evk_ioctl, evk_create_message_queue, +/// evk_alloc_queueID, evk_set_poll +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_queue_auto_id(/* OUT */EV_ID *queue_id, // NOLINT (readability/nolint) + UINT8 length, // NOLINT (readability/nolint) + UINT16 max_bytes, // NOLINT (readability/nolint) + EV_Message_Queue_Type type); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_destroy_flag +/// \~english @par Brief +/// Deletes flag with ID specified by the argument. +/// \~english @param [in] flag_id +/// EV_ID - Flag ID of the flag event +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Flag corresponding to queue_id doesn't exist +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Deletes flag with ID specified by the argument. +/// The user can only delete flag created by user process. +/// Due to deletion, program waiting for this flag (poll or wait) wakes up. +/// \~english @see evk_close, evk_ioctl, evk_destroy_queue +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_destroy_flag(EV_ID queue_id); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_destroy_queue +/// \~english @par Brief +/// Delete queue for message event by the queue_id. +/// \~english @param [in] queue_id +/// EV_ID - queue_id of the message event +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Message queue corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Deletes message queue with ID specified by the argument. +/// The user can only delete message queue created by user process. +/// Due to deletion, program waiting for this message queue (poll or wait) wakes up. +/// \~english @see EV_destroy_flag, evk_close, evk_ioctl, evk_destroy_queue +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_destroy_queue(EV_ID queue_id); // NOLINT (readability/nolint) + +/* Send event */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_set_flag +/// \~english @par Brief +/// Set Event flag +/// \~english @param [in] flag_id +/// EV_ID - Flag ID of the event flag +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [in] bits +/// UINT32 - event flag bit pattern +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - Flag corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sets bit pattern specified by argument to flag of ID specified by argument. +/// When setting a plurality of bit patterns in the same flag, "only OR +/// operation result of all bit patterns" is held in flag. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_store_flag +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_set_flag(EV_ID flag_id, UINT32 bits); // NOLINT (readability/nolint) + +/* Send event */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_set_flag64 +/// \~english @par Brief +/// Set Event flag +/// \~english @param [in] flag_id +/// EV_ID - Flag ID of the event flag +/// \~english @par +/// EV_ID type parameter +/// @code + +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [in] bits +/// UINT32 - event flag bit pattern +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - Flag corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sets bit pattern specified by argument to flag of ID specified by argument. +/// When setting a plurality of bit patterns in the same flag, "only OR operation +/// result of all bit patterns" is held in flag. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_store_flag +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_set_flag64(EV_ID flag_id, UINT64 bits); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_send_message +/// \~english @par Brief +/// Send Message event +/// \~english @param [in] queue_id +/// EV_ID - Queue ID of the message destination +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [in] bytes +/// UINT16 - The bytes of the send message +/// \~english @param [in] message +/// const void * - Pointer to a transmitting byte line +/// \~english @param [in] senderInfo +/// UINT32 - Message Source(It is specified when it is used for application identification. +/// When do not use it, appoint 0.) +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Busy Queue overflow +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Message queue corresponding to queue_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Queue overflow in kernel space +/// - EV_ERR_Busy +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Invalid queue types +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sends message specified by argument to message queue of ID specified by argument. +/// An error occurs when message queue of the specified ID doesn't exist or +/// message size exceeds the specified size. +/// When message queue is FULL, the processing differs depending on the type of message queue specified +/// at the time of creation message queue. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_store_message +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_send_message(EV_ID queue_id, // NOLINT (readability/nolint) + UINT16 bytes, // NOLINT (readability/nolint) + const void *message, // NOLINT (readability/nolint) + UINT32 senderInfo); // NOLINT (readability/nolint) + +/* \~english Get events in the order of arrivals */ +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_next_event +/* \~english get events by reaching time */ +/// \~english @par Brief get the first reached event(non-block) +/// \~english @param [out] ev +/// event Structure +/// \~english @par +/// EV_Event struct +/// @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_Type; +/// typedef UINT32 EV_ID; +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// enum ev_message_queue_type { +/// EV_MESSAGE_QUEUE_TYPE_BUSY, +/// EV_MESSAGE_QUEUE_TYPE_FIFO, +/// EV_MESSAGE_QUEUE_TYPE_REPLACE, +/// }; +/// +/// typedef struct { +/// EV_ID flagID; +/// UINT32 bits; +/// } EV_Flag; +/// +/// typedef struct { +/// EV_ID flagID; +/// UINT64 bits; +/// } EV_Flag64; +/// +/// typedef struct { +/// EV_ID queueID; +/// UINT32 senderInfo; +/// UINT32 length; +/// UINT32 dummy; +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; +/// } EV_Message; +/// +/// typedef struct { +/// EV_Type type; // please reference ev_message_queue_type. +/// union { +/// EV_Flag flag; +/// EV_Flag64 flag64; +/// EV_Message message; +/// } u; +/// } EV_Event; +/// +/// @endcode + +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_Thread: unregistered thread +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - unregistered thread +/// - EV_ERR_Invalid_Thread +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Get the first reached event which occurred for +/// flags or message queues created in current process. +/// If there is no event, set ev->type to EV_EVENT_None, then return immediately. +/// The event is flag or message is decided by +/// the ev->type is EV_EVENT_Flag or EV_EVENT_Message. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_next_event(/* OUT */EV_Event *ev); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_peek_next_event +/// \~english @par Brief get the first reached event(non-destructive) +/// \~english @param [out] ev +/// event Structure +/// @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_Type; +/// typedef UINT32 EV_ID; +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// enum ev_message_queue_type { +/// EV_MESSAGE_QUEUE_TYPE_BUSY, +/// EV_MESSAGE_QUEUE_TYPE_FIFO, +/// EV_MESSAGE_QUEUE_TYPE_REPLACE, +/// }; +/// +/// typedef struct { +/// EV_ID flagID; +/// UINT32 bits; +/// } EV_Flag; +/// +/// typedef struct { +/// EV_ID flagID; +/// UINT64 bits; +/// } EV_Flag64; +/// +/// typedef struct { +/// EV_ID queueID; +/// UINT32 senderInfo; +/// UINT32 length; +/// UINT32 dummy; +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; +/// } EV_Message; +/// +/// typedef struct { +/// EV_Type type; // please reference ev_message_queue_type. +/// union { +/// EV_Flag flag; +/// EV_Flag64 flag64; +/// EV_Message message; +/// } u; +/// } EV_Event; +/// +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_Thread: unregistered thread +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - unregistered thread +/// - EV_ERR_Invalid_Thread +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Get the first reached event which occurred for +/// flags or message queues created in current process non-destructively. +/// If the event is not getted from other processes, then call the function of +/// EV_get_next_event() or EV_peek_next_event(), it will return a same event. +/// If there is no event, set ev->type to EV_EVENT_None, then return immediately. +/// The event is flag or message is decided by +/// ev->type is EV_EVENT_Flag or EV_EVENT_Message. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_peek_next_event(/* OUT */EV_Event *ev); // NOLINT (readability/nolint) + +/* Get eventflag (ID specified) */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_flag +/// \~english @par Brief +/// Get event flag(non-block) +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] flag +/// EV_Flag * - event flag structure +/// \~english @par +/// EV_Flag structure +/// \~english @code +/// typedef struct { +/// EV_ID flagID; // Flag ID +/// UINT32 bits; // event flag bit pattern +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets bit pattern specified by argument to flag of ID specified by argument. +/// The user can only get flag created by user process, and clear bit pattern of acquired flag. +/// An error occurs if flag of the specified ID doesn't exist. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_flag(EV_ID flag_id, /* OUT */EV_Flag *flag); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_wait_flag +/// \~english @par Brief +/// Get event flag(block) +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] flag +/// EV_Flag * - event flag structure +/// \~english @par +/// EV_Flag structure +/// \~english @code +/// typedef struct { +/// EV_ID flagID; // Flag ID +/// UINT32 bits; // event flag bit pattern +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Interrupted signal interrupt +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Task blocking was canceled by signal interrupt +/// - EV_ERR_Interrupted +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets bit pattern specified by argument to flag of ID specified by argument. +/// The user can only get flag created by user process, and clear bit pattern of acquired flag. +/// An error occurs if flag of the specified ID doesn't exist. +/// If bit pattern is not set in flag, block until bit pattern is set. +/// However, if a signal interrupt or corresponding flag is deleted, it will abort and return an error. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_wait_flag(EV_ID flag_id, /* OUT */EV_Flag *flag); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_peek_flag +/// \~english @par Brief get flag event(non-destructive) +/// \~english @param [in] flag_id +/// ID of message event queue +/// \~english @param [out] flag +/// flag struct +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @par +/// EV_Flag Structure +/// @code +/// typedef struct { +/// EV_ID flagID; +/// UINT32 bits; +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: The specified flag ID is not existing, +/// or it is not created in current process. +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Task blocking was canceled by signal interrupt +/// - EV_ERR_Interrupted +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Get a flag event whose ID is specified non-destructively. +/// If there is no event, just return. +/// If there is no event, set flag->flagID to EV_NO_ID. +/// You can judge that there is no event, even though flag->bits is 0. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_peek_flag(EV_ID flag_id, /* OUT */EV_Flag *flag); // NOLINT (readability/nolint) + +/* Get eventflag (ID specified) */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_flag64 +/// \~english @par Brief +/// Get event flag(non-block) +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] flag +/// EV_Flag * - event flag structure +/// \~english @par +/// EV_Flag structure +/// \~english @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_ID +/// +/// typedef struct { +/// EV_ID flagID; // Flag ID +/// UINT32 bits; // event flag bit pattern +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets bit pattern specified by argument to flag of ID specified by argument. +/// The user can only get flag created by user process, and clear bit pattern of acquired flag. +/// An error occurs if flag of the specified ID doesn't exist. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_flag64(EV_ID flag_id, /* OUT */EV_Flag64 *flag); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_wait_flag64 +/// \~english @par Brief +/// Get event flag(block) +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] flag +/// EV_Flag * - event flag structure +/// \~english @par +/// EV_Flag structure +/// \~english @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_ID +/// +/// typedef struct { +/// EV_ID flagID; // Flag ID +/// UINT32 bits; // event flag bit pattern +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Interrupted signal interrupt +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Task blocking was canceled by signal interrupt +/// - EV_ERR_Interrupted +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets bit pattern specified by argument to flag of ID specified by argument. +/// The user can only get flag created by user process, and clear bit pattern of acquired flag. +/// An error occurs if flag of the specified ID doesn't exist. +/// If bit pattern is not set in flag, block until bit pattern is set. +/// However, if a signal interrupt or corresponding flag is deleted, it will abort and return an error. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_wait_flag64(EV_ID flag_id, /* OUT */EV_Flag64 *flag); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_peek_flag64 +/// \~english @par Brief get flag event(non-destructive) +/// \~english @param [in] flag_id +/// ID of message event queue +/// \~english @param [out] flag +/// flag struct +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @par +/// EV_Flag Structure +/// @code +/// typedef struct { +/// EV_ID flagID; +/// UINT32 bits; +/// } EV_Flag; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: The specified flag ID is not existing, +/// or it is not created in current process. +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Flag corresponding to flag_id doesn't exist +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - EV_ERR_Invalid_ID +/// - Task blocking was canceled by signal interrupt +/// - EV_ERR_Interrupted +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Get a flag event whose ID is specified non-destructively. +/// If there is no event, just return. +/// If there is no event, set flag->flagID to EV_NO_ID. +/// You can judge that there is no event, even though flag->bits is 0. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_peek_flag64(EV_ID flag_id, /* OUT */EV_Flag64 *flag); // NOLINT (readability/nolint) + +/* Get Message Event (ID specified) */ +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_message +/// \~english @par Brief +/// Get message event(non-block) +/// \~english @param [in] queue_id +/// EV_ID - Message queue ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] message +/// EV_Message * - Message event structure +/// \~english @par +/// EV_Message structure +/// \~english @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_ID +/// +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// typedef struct { +/// EV_ID queueID; // ID of message queue +/// UINT32 senderInfo; // Message Source +/// UINT32 length; // length of message +/// UINT32 dummy; // dummy for padding +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; // message +/// } EV_Message; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Message queue corresponding to queue_id doesn't exist +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets 1 message specified by argument to message queue of ID specified by argument. +/// The user can only get message queue created by user process, and clear 1 message of acquired message queue. +/// An error occurs if message queue of the specified ID doesn't exist. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_message(EV_ID queue_id, /* OUT */EV_Message *message); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_wait_message +/// \~english @par Brief +/// Get message event(block) +/// \~english @param [in] queue_id +/// EV_ID - Message queue ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] message +/// EV_Message * - Message event structure +/// \~english @par +/// EV_Message structure +/// \~english @code +/// typedef unsigned int UINT32; +/// typedef UINT32 EV_ID +/// +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// typedef struct { +/// EV_ID queueID; // ID of message queue +/// UINT32 senderInfo; // Message Source +/// UINT32 length; // length of message +/// UINT32 dummy; // dummy for padding +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; // message +/// } EV_Message; +/// @endcode +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Interrupted signal interrupt +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Message queue corresponding to queue_id doesn't exist +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - EV_ERR_Invalid_ID +/// - Task blocking was canceled by signal interrupt +/// - EV_ERR_Interrupted +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets 1 message specified by argument to message queue of ID specified by argument. +/// The user can only get message queue created by user process, and clear 1 message of acquired message queue. +/// An error occurs if message queue of the specified ID doesn't exist. +/// If message is not set in message queue, block until message is sent. +/// However, if a signal interrupt or corresponding message queue is deleted, it will abort and return an error. +/// \~english @see +/// evk_ioctl, evk_get_event +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_wait_message(EV_ID queue_id, /* OUT */EV_Message *message); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_peek_message +/// \~english @par Brief get message event(non-destructive) +/// \~english @param [in] queue_id +/// ID of message event queue +/// \~english @param [out] message +/// message event queue struct +/// \~english @par +/// EV_ID define +/// @code +/// typedef UINT32 EV_ID +/// @endcode + +/// \~english @par +/// EV_Message struct +/// @code +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// typedef struct { +/// EV_ID queueID; +/// UINT32 senderInfo; +/// UINT32 length; +/// UINT32 dummy; +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; +/// } EV_Message; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: The specified queue ID is not existing, +/// or it is not created in current process. +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Message queue corresponding to queue_id doesn't exist +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Get a message event queue whose ID is specified non-destructively. +/// If there is no event, just return. +/// If there is no event, set message->queueID to EV_NO_ID. +/// It is the same with EV_get_message(), except the message is remained in the queue. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_peek_message(EV_ID queue_id, /* OUT */EV_Message *message); // NOLINT (readability/nolint) + +/* \~english Get events(with search criteria) */ + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_find_message_by_sender +/* \~english get event(with search sender infomation condition) */ +/// \~english @param [in] queue_id +/// ID of message event queue +/// \~english @param [in] senderInfo +/// sender information +/// \~english @param [out] message +/// message event struct +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @par +/// EV_Message struct +/// @code +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// typedef struct { +/// EV_ID queueID; +/// UINT32 senderInfo; +/// UINT32 length; +/// UINT32 dummy; +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; +/// } EV_Message; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: The specified queue ID is not existing, +/// or it is not created in current process. +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Not find same sender information's message according to input sender information information +/// - EV_ERR_Invalid_ID +/// - Securing free space of thread information management table (malloc) Failure +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Message queue pool is NULL +/// - Message queue generation corresponding to queue_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// If there is a event whose sender information is same with +/// any event in message event queue whose ID is specified, get the event and delete it from queue. +/// If such a message is not existing, +/// set message->queueID to EV_NO_ID, then return. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_find_message_by_sender(EV_ID queue_id, UINT32 senderInfo, EV_Message *message); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_find_message_by_content +/// \~english @par Brief get message event(search with contents) +/// \~english @param [in] queue_id +/// ID of message event queue +/// \~english @param [in] bytes +/// size of compare bytes +/// \~english @param [in] compare_bytes +/// bytes that used to campare the contents +/// \~english @param [out] message +/// message event struct +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @par +/// EV_Message struct +/// @code +/// #define EV_MAX_MESSAGE_LENGTH 2048 +/// typedef struct { +/// EV_ID queueID; +/// UINT32 senderInfo; +/// UINT32 length; +/// UINT32 dummy; +/// UINT8 message[EV_MAX_MESSAGE_LENGTH]; +/// } EV_Message; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: The specified queue ID is not existing, +/// or it is not created in current process. +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Not find contents's message according to input contents information +/// - EV_ERR_Invalid_ID +/// - Securing free space of thread information management table (malloc) Failure +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Message queue pool is NULL +/// - Message queue generation corresponding to queue_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// If the event in compare bytes is same with +/// any event in message event queue whose ID is specified, +/// get the event and delete it from queue. +/// If such a message is not existing, set message->queueID to EV_NO_ID, then return. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_find_message_by_content(EV_ID queue_id, // NOLINT (readability/nolint) + UINT16 length, // NOLINT (readability/nolint) + const void *compare_bytes, // NOLINT (readability/nolint) + /* OUT */EV_Message *message); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_flag_fd +/// \~english @par Brief +/// Obtain fd for polling flag event +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] fd +/// int * - event flag queue fd for Polling +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @par Prerequisite +/// Execute EV_create_flag(),EV_create_flag_auto_id() and flag has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - Flag corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets fd(File Descriptor) corresponding to flag of ID specified by argument. +/// The user can only get flag created by user process . +/// This fd(File Descriptor) can be used only for designation to poll / select, and operation when other +/// operations are performed is not guaranteed. +/// At the time of poll, only POLLIN can be specified, and at the time of select, +/// it is possible to check only whether it can be read. +/// Also, if flag is deleted in poll / select, it exits poll / select. * In case of poll, POLLERR is set. +/// When calling the same ID more than once, it returns the same fd(File Descriptor) +/// each time (unless destroy / create is done). +/// \~english @see +/// nothing +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_flag_fd(EV_ID flag_id, /* OUT */int *fd); // NOLINT (readability/nolint) + +///////////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_get_queue_fd +/// \~english @par Brief +/// Obtain fd for polling message event +/// \~english @param [in] flag_id +/// EV_ID - Flag ID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @param [out] fd +/// int * - Message queue fd for Polling +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error +/// - Message queue corresponding to queue_id doesn't exist +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Gets fd(File Descriptor) corresponding to message queue of ID specified by argument. +/// The user can only get message queue created by user process . +/// This fd(File Descriptor) can be used only for designation to poll / select, +/// and operation when other operations are performed is not guaranteed. +/// At the time of poll, only POLLIN can be specified, and at the time of select, +/// it is possible to check only whether it can be read. +/// Also, if message queue is deleted in poll / select, it exits poll / select. +/// * In case of poll, POLLERR is set. +/// When calling the same ID more than once, it returns the same fd(File Descriptor) +/// each time (unless destroy / create is done). +/// \~english @see +/// nothing +//////////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_get_queue_fd(EV_ID queue_id, /* OUT */int *fd); // NOLINT (readability/nolint) + +/* \~english Functions that specify the module ID (16 bits) instead of the flag ID and queue ID */ + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_moduleID_to_flag_id +/* \~english function group used to specify moduleID(16bit) instead of flag_id, queue_id */ +/// \~english @par Brief change from moduleID to flag_id +/// \~english @param [in] m_id +/// moduleID +/// \~english @retval flag_id +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - none +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of flags with one moduleID. return error:EV_ERR_Exist. +/// This function is only used for generating one event by one module ID. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ID EV_moduleID_to_flagID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_moduleID_to_flag64ID +/// \~english @par Brief change from moduleID to 64bit flag_id +/// \~english @param [in] m_id +/// moduleID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval 64bit flag_id +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - none +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of flags with one moduleID. return error:EV_ERR_Exist. +/// This function is only used for generating one event by one module ID. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ID EV_moduleID_to_flag64ID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_moduleID_to_queueID +/// \~english @par Brief change from moduleID to queue_id +/// \~english @param [in] m_id +/// moduleID +/// \~english @par +/// EV_ID type parameter +/// @code +/// typedef UINT32 EV_ID +/// @endcode +/// \~english @retval queue_id +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - none +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of queues with one moduleID. +// \~english @see none +//////////////////////////////////////////////////////////////////////////////// + +EV_ID EV_moduleID_to_queueID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag_by_mID +/// \~english @par Brief create flag(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist Duplication Error +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The ID is not created by function of EV_moduleID_to_flagID (). +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - flag_id registered in launch thread +/// - Flag corresponding to flag_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of flags with one moduleID.return error:EV_ERR_Exist. +/// This function is only used for generating one event by one module ID. +// \~english @see EV_create_flag +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag_by_mID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_flag64_by_mID +/// \~english @par Brief create 64bit flag(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist Duplication Error +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The ID is not created by function of EV_moduleID_to_flag64ID (). +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - flag_id registered in launch thread +/// - Flag corresponding to flag_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Flag pool is NULL +/// - Flag generation corresponding to flag_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of flags with one moduleID. return error:EV_ERR_Exist. +/// This function is only used for generating one event by one module ID. +// \~english @see EV_create_flag64 +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_create_flag64_by_mID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_create_queue_by_mID +/// \~english @par Brief create queue(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @param [in] length +/// length of message queue +/// \~english @param [in] max_bytes +/// one max bytes for message +/// \~english @param [in] type +/// treat type of receiving events even though the queue is full +/// \~english @par +/// ev_message_queue_type struct +/// @code +/// enum ev_message_queue_type { +/// EV_MESSAGE_QUEUE_TYPE_BUSY, +/// EV_MESSAGE_QUEUE_TYPE_FIFO, +/// EV_MESSAGE_QUEUE_TYPE_REPLACE, +/// }; +/// @endcode +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: set en invalid flag ID +/// \~english @retval EV_ERR_Thread_Over The MAX of event thread. +/// \~english @retval EV_ERR_Exist: a same flag ID is existing +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// There is no prerequisite +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - EV_ERR_Invalid_ID +/// - Startup thread upper limit (16) error +/// - EV_ERR_Thread_Over +/// - queue_id registered in launch thread +/// - Message queue corresponding to queue_id already exists +/// - EV_ERR_Exist +/// - Securing free space of thread information management table (malloc) Failure +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Message queue pool is NULL +/// - Message queue generation corresponding to queue_id failed +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of queues with one moduleID. +// \~english @see EV_create_queue +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR +EV_create_queue_by_mID(UINT16 m_id, // NOLINT (readability/nolint) + UINT8 length, // NOLINT (readability/nolint) + UINT16 max_bytes, // NOLINT (readability/nolint) + EV_Message_Queue_Type type); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_destroy_flag_by_mID +/// \~english @par Brief delete flag(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @par length [in]length of message queue +/// \~english @par max_bytes [in]one max bytes for message +/// \~english @par type [in]treat type of receiving events even though the queue is full +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: set en invalid flag ID +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// - none +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The flag_id of event/message which has not been created. +/// - Flag corresponding to queue_id doesn't exist +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// \~english You can not use this function to +/// \~english create a multiple of flags with one moduleID. return error:EV_ERR_Exist. +/// This function is only used for generating one event by one module ID. +// \~english @see EV_destroy_flag +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_destroy_flag_by_mID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_destroy_queue_by_mID +/// \~english @par Brief delete queue(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Message queue corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// You can not use this function to +/// create a multiple of queues with one moduleID +// \~english @see EV_destroy_queue +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_destroy_queue_by_mID(UINT16 m_id); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_set_flag_by_mID +/// \~english @par Brief send flag(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @param [in] bits +/// value of flag +/// \~english @retval EV_OK: normal termination +/// \~english @retval EV_ERR_Invalid_ID: set en invalid flag ID +/// \~english @retval EV_ERR_Fatal: Fatal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - Flag corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sets bit pattern specified by argument to flag of ID specified by argument. +/// When setting a plurality of bit patterns in the same flag, +/// "only OR operation result of all bit patterns" is held in flag. +// \~english @see EV_set_flag +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_set_flag_by_mID(UINT16 m_id, UINT32 bits); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_set_flag64_by_mID +/// \~english @par Brief send 64bit flag(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @param [in] bits +/// value of flag +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid flag_id +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// - none +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect flag_id) +/// --incorrect flag_id:The flag_id of event which has not been created. +/// - Flag corresponding to flag_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sets bit pattern specified by argument to flag of ID specified by argument. +/// When setting a plurality of bit patterns in the same flag, "only +/// OR operation result of all bit patterns" is held in flag. +// \~english @see EV_set_flag64 +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR EV_set_flag64_by_mID(UINT16 m_id, UINT64 bits); // NOLINT (readability/nolint) + +//////////////////////////////////////////////////////////////////////////////// +/// \ingroup EV_send_message_by_mID +/// \~english @par Brief send message(moduleID specified) +/// \~english @param [in] m_id +/// moduleID +/// \~english @param [in] bytes +/// number of send bytes +/// \~english @param [in] message +/// pointer to sender contents +/// \~english @param [in] senderInfo +/// sender information +/// \~english @retval EV_OK Successful completion +/// \~english @retval EV_ERR_Invalid_ID Invalid queue_id +/// \~english @retval EV_ERR_Busy Queue overflow +/// \~english @retval EV_ERR_Fatal Abnormal error +/// \~english @par Prerequisite +/// Execute EV_create_queue(),EV_create_queue_auto_id() and message queue has already been created. +/// \~english @par Change of internal state +/// There is no change of the internal Status +/// \~english @par Conditions of processing failure +/// - Input parameter error (specifying incorrect queue_id) +/// --incorrect queue_id:The queue_id of essage which has not been created. +/// - Message queue corresponding to queue_id doesn't exist +/// - EV_ERR_Invalid_ID +/// - Queue overflow in kernel space +/// - EV_ERR_Busy +/// - Access failed from kernel space to user space reference area +/// - Failed to copy data from user space to kernel space +/// - Invalid queue types +/// - EV_ERR_Fatal +/// \~english @par Classification +/// Public +/// \~english @par Type +/// Sync Only +/// \~english @par Detail +/// Sends message specified by argument to message moduleID specified by argument. +/// An error occurs when message queue of the specified ID doesn't exist +/// or message size exceeds the specified size. +/// When message queue is FULL, the processing differs depending on the type +/// of message queue specified at the time of creation message queue. +/// \~english @see evk_open, evk_close, evk_ioctl, evk_store_message +//////////////////////////////////////////////////////////////////////////////// + +EV_ERR +EV_send_message_by_mID(UINT16 m_id, // NOLINT (readability/nolint) + UINT16 bytes, // NOLINT (readability/nolint) + const void *message, // NOLINT (readability/nolint) + UINT32 senderInfo); // NOLINT (readability/nolint) + +/** @}*/ // end of event_library +/** @}*/ // end of other_service +/** @}*/ // end of BaseSystem +/** + * + * @brief Method to specify module IDs as flag IDs and queue IDs + * + * The function with module ID as an argument directly can be used in the case of that created only + * one flag and queue in the module, other than using macros EV_Flag_ID_Base() or EV_Queue_ID_Base(). + * @see EV_create_flag_by_mID + * @see EV_create_queue_by_mID + * @see EV_destroy_flag_by_mID + * @see EV_destroy_queue_by_mID + * @see EV_set_flag_by_mID + * @see EV_send_message_by_mID + * + * So the following API can be used to convert IDs created using above method to flag IDs or queue ID + * when pass them to other modules. + * @see EV_moduleID_to_flagID(UINT16 m_id) + * @see EV_moduleID_to_queueID(UINT16 m_id) + * + * @see EV_ID_spec + */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* !__KERNEL__ */ + +#endif // OTHERSERVICE_EV_LIB_H_ |