From 056886f17196e925e7842db025dd17c95691ed84 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Mon, 14 Jun 2021 09:59:59 +0200 Subject: c-user: Document interrupt manager extensions Close #3269. --- c-user/interrupt/directives.rst | 2641 ++++++++++++++++++++++++++++++++++++- c-user/interrupt/introduction.rst | 145 +- 2 files changed, 2714 insertions(+), 72 deletions(-) diff --git a/c-user/interrupt/directives.rst b/c-user/interrupt/directives.rst index f3a944d..2d7dccf 100644 --- a/c-user/interrupt/directives.rst +++ b/c-user/interrupt/directives.rst @@ -1,6 +1,6 @@ .. SPDX-License-Identifier: CC-BY-SA-4.0 -.. Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) +.. Copyright (C) 2008, 2021 embedded brains GmbH (http://www.embedded-brains.de) .. Copyright (C) 1988, 2008 On-Line Applications Research Corporation (OAR) .. This file is part of the RTEMS quality process and was automatically @@ -506,70 +506,6 @@ The following constraints apply to this directive: * The directive will not cause the calling task to be preempted. -.. Generated from spec:/rtems/intr/if/cause - -.. raw:: latex - - \clearpage - -.. index:: rtems_interrupt_cause() - -.. _InterfaceRtemsInterruptCause: - -rtems_interrupt_cause() ------------------------ - -Causes the interrupt. - -.. rubric:: CALLING SEQUENCE: - -.. code-block:: c - - #define rtems_interrupt_cause( vector ) - -.. rubric:: PARAMETERS: - -``vector`` - This parameter is the vector number of the interrupt to cause. - -.. rubric:: CONSTRAINTS: - -The following constraints apply to this directive: - -* The directive is not implemented. - -.. Generated from spec:/rtems/intr/if/clear - -.. raw:: latex - - \clearpage - -.. index:: rtems_interrupt_clear() - -.. _InterfaceRtemsInterruptClear: - -rtems_interrupt_clear() ------------------------ - -Clears the interrupt. - -.. rubric:: CALLING SEQUENCE: - -.. code-block:: c - - #define rtems_interrupt_clear( vector ) - -.. rubric:: PARAMETERS: - -``vector`` - This parameter is the vector number of the interrupt to clear. - -.. rubric:: CONSTRAINTS: - -The following constraints apply to this directive: - -* The directive is not implemented. - .. Generated from spec:/rtems/intr/if/lock-initialize .. raw:: latex @@ -1108,3 +1044,2578 @@ Defines an ISR lock object reference. .. rubric:: NOTES: Do not add a ";" after this macro. + +.. Generated from spec:/rtems/intr/if/entry-initializer + +.. raw:: latex + + \clearpage + +.. index:: RTEMS_INTERRUPT_ENTRY_INITIALIZER() + +.. _InterfaceRTEMSINTERRUPTENTRYINITIALIZER: + +RTEMS_INTERRUPT_ENTRY_INITIALIZER() +----------------------------------- + +Statically initializes an interrupt entry object. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + #define RTEMS_INTERRUPT_ENTRY_INITIALIZER( routine, arg, info ) + +.. rubric:: PARAMETERS: + +``routine`` + This parameter is the interrupt handler routine for the entry. + +``arg`` + This parameter is the interrupt handler argument for the entry. + +``info`` + This parameter is the descriptive information for the entry. + +.. rubric:: NOTES: + +Alternatively, :ref:`InterfaceRtemsInterruptEntryInitialize` may be used to +dynamically initialize an interrupt entry. + +.. Generated from spec:/rtems/intr/if/entry-initialize + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_entry_initialize() + +.. _InterfaceRtemsInterruptEntryInitialize: + +rtems_interrupt_entry_initialize() +---------------------------------- + +Initializes the interrupt entry. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_entry_initialize( + rtems_interrupt_entry *entry, + rtems_interrupt_handler routine, + void *arg, + const char *info + ); + +.. rubric:: PARAMETERS: + +``entry`` + This parameter is the interrupt entry to initialize. + +``routine`` + This parameter is the interrupt handler routine for the entry. + +``arg`` + This parameter is the interrupt handler argument for the entry. + +``info`` + This parameter is the descriptive information for the entry. + +.. rubric:: NOTES: + +Alternatively, :ref:`InterfaceRTEMSINTERRUPTENTRYINITIALIZER` may be used to +statically initialize an interrupt entry. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within any runtime context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/entry-install + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_entry_install() + +.. _InterfaceRtemsInterruptEntryInstall: + +rtems_interrupt_entry_install() +------------------------------- + +Installs the interrupt entry at the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_entry_install( + rtems_vector_number vector, + rtems_option options, + rtems_interrupt_entry *entry + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``options`` + This parameter is the interrupt entry install option set. + +``entry`` + This parameter is the interrupt entry to install. + +.. rubric:: DESCRIPTION: + +One of the following mutually exclusive options + +* :c:macro:`RTEMS_INTERRUPT_UNIQUE`, and + +* :c:macro:`RTEMS_INTERRUPT_SHARED` + +shall be set in the ``options`` parameter. + +The handler routine of the entry specified by ``entry`` will be called with the +handler argument of the entry when dispatched. The order in which shared +interrupt handlers are dispatched for one vector is defined by the installation +order. The first installed handler is dispatched first. + +If the option :c:macro:`RTEMS_INTERRUPT_UNIQUE` is set, then it will be ensured +that the handler will be the only one for the interrupt vector. + +If the option :c:macro:`RTEMS_INTERRUPT_SHARED` is set, then multiple handlers +may be installed for the interrupt vector. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``entry`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INCORRECT_STATE` + The service was not initialized. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The handler routine of the entry was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +:c:macro:`RTEMS_INVALID_NUMBER` + An option specified by ``options`` was not applicable. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_UNIQUE` option was set in ``entry`` and the + interrupt vector was already occupied by a handler. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_SHARED` option was set in ``entry`` and the + interrupt vector was already occupied by a unique handler. + +:c:macro:`RTEMS_TOO_MANY` + The handler routine of the entry specified by ``entry`` was already + installed for the interrupt vector specified by ``vector`` with an argument + equal to the handler argument of the entry. + +.. rubric:: NOTES: + +When the directive call was successful, the ownership of the interrupt entry +has been transferred from the caller to the interrupt service. An installed +interrupt entry may be removed from the interrupt service by calling +:ref:`InterfaceRtemsInterruptEntryRemove`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +* The interrupt entry shall have been initialized by + :ref:`InterfaceRtemsInterruptEntryInitialize` or + :ref:`InterfaceRTEMSINTERRUPTENTRYINITIALIZER`. + +.. Generated from spec:/rtems/intr/if/entry-remove + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_entry_remove() + +.. _InterfaceRtemsInterruptEntryRemove: + +rtems_interrupt_entry_remove() +------------------------------ + +Removes the interrupt entry from the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_entry_remove( + rtems_vector_number vector, + rtems_interrupt_entry *entry + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``entry`` + This parameter is the interrupt entry to remove. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INCORRECT_STATE` + The service was not initialized. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``entry`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +:c:macro:`RTEMS_UNSATISFIED` + The entry specified by ``entry`` was not installed at the interrupt vector + specified by ``vector``. + +.. rubric:: NOTES: + +When the directive call was successful, the ownership of the interrupt entry +has been transferred from the interrupt service to the caller. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +* The interrupt entry shall have been installed by + :ref:`InterfaceRtemsInterruptEntryInstall`. + +.. Generated from spec:/rtems/intr/if/handler-install + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_handler_install() + +.. _InterfaceRtemsInterruptHandlerInstall: + +rtems_interrupt_handler_install() +--------------------------------- + +Installs the interrupt handler routine and argument at the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_handler_install( + rtems_vector_number vector, + const char *info, + rtems_option options, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``info`` + This parameter is the descriptive information of the interrupt handler to + install. + +``options`` + This parameter is the interrupt handler install option set. + +``routine`` + This parameter is the interrupt handler routine to install. + +``arg`` + This parameter is the interrupt handler argument to install. + +.. rubric:: DESCRIPTION: + +One of the following mutually exclusive options + +* :c:macro:`RTEMS_INTERRUPT_UNIQUE`, + +* :c:macro:`RTEMS_INTERRUPT_SHARED`, and + +* :c:macro:`RTEMS_INTERRUPT_REPLACE` + +shall be set in the ``options`` parameter. + +The handler routine will be called with the argument specified by ``arg`` when +dispatched. The order in which shared interrupt handlers are dispatched for +one vector is defined by the installation order. The first installed handler +is dispatched first. + +If the option :c:macro:`RTEMS_INTERRUPT_UNIQUE` is set, then it will be ensured +that the handler will be the only one for the interrupt vector. + +If the option :c:macro:`RTEMS_INTERRUPT_SHARED` is set, then multiple handler +may be installed for the interrupt vector. + +If the option :c:macro:`RTEMS_INTERRUPT_REPLACE` is set, then the handler +specified by ``routine`` will replace the first handler with the same argument +for the interrupt vector if it exists, otherwise an error status will be +returned. A second handler with the same argument for the interrupt vector +will remain unchanged. The new handler will inherit the unique or shared +options from the replaced handler. + +An informative description may be provided in ``info``. It may be used for +system debugging and diagnostic tools. The referenced string has to be +persistent as long as the handler is installed. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INCORRECT_STATE` + The service was not initialized. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``routine`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +:c:macro:`RTEMS_NO_MEMORY` + There was not enough memory available to allocate data structures to + install the handler. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_UNIQUE` option was set in ``options`` and the + interrupt vector was already occupied by a handler. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_SHARED` option was set in ``options`` and the + interrupt vector was already occupied by a unique handler. + +:c:macro:`RTEMS_TOO_MANY` + The handler specified by ``routine`` was already installed for the + interrupt vector specified by ``vector`` with an argument equal to the + argument specified by ``arg``. + +:c:macro:`RTEMS_UNSATISFIED` + The :c:macro:`RTEMS_INTERRUPT_REPLACE` option was set in ``options`` and no + handler to replace was installed. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/handler-remove + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_handler_remove() + +.. _InterfaceRtemsInterruptHandlerRemove: + +rtems_interrupt_handler_remove() +-------------------------------- + +Removes the interrupt handler routine and argument from the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_handler_remove( + rtems_vector_number vector, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``routine`` + This parameter is the interrupt handler routine to remove. + +``arg`` + This parameter is the interrupt handler argument to remove. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INCORRECT_STATE` + The service was not initialized. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``routine`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +:c:macro:`RTEMS_UNSATISFIED` + There was no handler routine and argument pair installed specified by + ``routine`` and ``arg``. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/vector-is-enabled + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_vector_is_enabled() + +.. _InterfaceRtemsInterruptVectorIsEnabled: + +rtems_interrupt_vector_is_enabled() +----------------------------------- + +Checks if the interrupt vector is enabled. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_vector_is_enabled( + rtems_vector_number vector, + bool *enabled + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``enabled`` + This parameter is the pointer to a ``bool`` object. When the directive + call is successful, the enabled status of the interrupt associated with the + interrupt vector specified by ``vector`` will be stored in this object. + When the interrupt was enabled for the processor executing the directive + call at some time point during the call, the object value will be set to + :c:macro:`true`, otherwise to :c:macro:`false`. + +.. rubric:: DESCRIPTION: + +The directive checks if the interrupt associated with the interrupt vector +specified by ``vector`` was enabled for the processor executing the directive +call at some time point during the call. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``enabled`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +.. rubric:: NOTES: + +Interrupt vectors may be enabled by :ref:`InterfaceRtemsInterruptVectorEnable` +and disabled by :ref:`InterfaceRtemsInterruptVectorDisable`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/vector-enable + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_vector_enable() + +.. _InterfaceRtemsInterruptVectorEnable: + +rtems_interrupt_vector_enable() +------------------------------- + +Enables the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_vector_enable( rtems_vector_number vector ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the number of the interrupt vector to enable. + +.. rubric:: DESCRIPTION: + +The directive enables the interrupt vector specified by ``vector``. This allows +that interrupt service requests are issued to the target processors of the +interrupt vector. Interrupt service requests for an interrupt vector may be +raised by :ref:`InterfaceRtemsInterruptRaise`, +:ref:`InterfaceRtemsInterruptRaiseOn`, external signals, or messages. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + The request to enable the interrupt vector has not been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if an interrupt vector can be enabled. Interrupt vectors may be disabled by +:ref:`InterfaceRtemsInterruptVectorDisable`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/vector-disable + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_vector_disable() + +.. _InterfaceRtemsInterruptVectorDisable: + +rtems_interrupt_vector_disable() +-------------------------------- + +Disables the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_vector_disable( rtems_vector_number vector ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the number of the interrupt vector to disable. + +.. rubric:: DESCRIPTION: + +The directive disables the interrupt vector specified by ``vector``. This +prevents that an interrupt service request is issued to the target processors +of the interrupt vector. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + The request to disable the interrupt vector has not been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if an interrupt vector can be disabled. Interrupt vectors may be enabled by +:ref:`InterfaceRtemsInterruptVectorEnable`. There may be targets on which some +interrupt vectors cannot be disabled, for example a hardware watchdog interrupt +or software generated interrupts. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/is-pending + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_is_pending() + +.. _InterfaceRtemsInterruptIsPending: + +rtems_interrupt_is_pending() +---------------------------- + +Checks if the interrupt is pending. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_is_pending( + rtems_vector_number vector, + bool *pending + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``pending`` + This parameter is the pointer to a ``bool`` object. When the directive + call is successful, the pending status of the interrupt associated with the + interrupt vector specified by ``vector`` will be stored in this object. + When the interrupt was pending for the processor executing the directive + call at some time point during the call, the object value will be set to + :c:macro:`true`, otherwise to :c:macro:`false`. + +.. rubric:: DESCRIPTION: + +The directive checks if the interrupt associated with the interrupt vector +specified by ``vector`` was pending for the processor executing the directive +call at some time point during the call. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``pending`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + The request to get the pending status has not been satisfied. + +.. rubric:: NOTES: + +Interrupts may be made pending by calling the +:ref:`InterfaceRtemsInterruptRaise` or :ref:`InterfaceRtemsInterruptRaiseOn` +directives or due to external signals or messages. The pending state may be +cleared by :ref:`InterfaceRtemsInterruptClear`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/raise + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_raise() + +.. _InterfaceRtemsInterruptRaise: + +rtems_interrupt_raise() +----------------------- + +Raises the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_raise( rtems_vector_number vector ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the number of the interrupt vector to raise. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + The request to raise the interrupt vector has not been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if an interrupt vector can be raised. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/raise-on + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_raise_on() + +.. _InterfaceRtemsInterruptRaiseOn: + +rtems_interrupt_raise_on() +-------------------------- + +Raises the interrupt vector on the processor. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_raise_on( + rtems_vector_number vector, + uint32_t cpu_index + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the number of the interrupt vector to raise. + +``cpu_index`` + This parameter is the index of the target processor of the interrupt vector + to raise. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_NOT_CONFIGURED` + The processor specified by ``cpu_index`` was not configured to be used by + the application. + +:c:macro:`RTEMS_INCORRECT_STATE` + The processor specified by ``cpu_index`` was configured to be used by the + application, however, it was not online. + +:c:macro:`RTEMS_UNSATISFIED` + The request to raise the interrupt vector has not been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if an interrupt vector can be raised on a processor. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/clear + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_clear() + +.. _InterfaceRtemsInterruptClear: + +rtems_interrupt_clear() +----------------------- + +Clears the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_clear( rtems_vector_number vector ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the number of the interrupt vector to clear. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + The request to raise the interrupt vector has not been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if an interrupt vector can be cleared. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/get-affinity + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_get_affinity() + +.. _InterfaceRtemsInterruptGetAffinity: + +rtems_interrupt_get_affinity() +------------------------------ + +Gets the processor affinity set of the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_get_affinity( + rtems_vector_number vector, + size_t affinity_size, + cpu_set_t *affinity + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``affinity_size`` + This parameter is the size of the processor set referenced by ``affinity`` + in bytes. + +``affinity`` + This parameter is the pointer to a :c:type:`cpu_set_t` object. When the + directive call is successful, the processor affinity set of the interrupt + vector will be stored in this object. A set bit in the processor set means + that the corresponding processor is in the processor affinity set of the + interrupt vector, otherwise the bit is cleared. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``affinity`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_INVALID_SIZE` + The size specified by ``affinity_size`` of the processor set was too small + for the processor affinity set of the interrupt vector. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/set-affinity + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_set_affinity() + +.. _InterfaceRtemsInterruptSetAffinity: + +rtems_interrupt_set_affinity() +------------------------------ + +Sets the processor affinity set of the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_set_affinity( + rtems_vector_number vector, + size_t affinity_size, + const cpu_set_t *affinity + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``affinity_size`` + This parameter is the size of the processor set referenced by ``affinity`` + in bytes. + +``affinity`` + This parameter is the pointer to a :c:type:`cpu_set_t` object. The + processor set defines the new processor affinity set of the interrupt + vector. A set bit in the processor set means that the corresponding + processor shall be in the processor affinity set of the interrupt vector, + otherwise the bit shall be cleared. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``affinity`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_INVALID_NUMBER` + The referenced processor set was not a valid new processor affinity set for + the interrupt vector. + +:c:macro:`RTEMS_UNSATISFIED` + The request to set the processor affinity of the interrupt vector has not + been satisfied. + +.. rubric:: NOTES: + +The :ref:`InterfaceRtemsInterruptGetAttributes` directive may be used to check +if the processor affinity of an interrupt vector can be set. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/get-attributes + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_get_attributes() + +.. _InterfaceRtemsInterruptGetAttributes: + +rtems_interrupt_get_attributes() +-------------------------------- + +Gets the attributes of the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_get_attributes( + rtems_vector_number vector, + rtems_interrupt_attributes *attributes + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``attributes`` + This parameter is the pointer to an :c:type:`rtems_interrupt_attributes` + object. When the directive call is successful, the attributes of the + interrupt vector will be stored in this object. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``attributes`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/handler-iterate + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_handler_iterate() + +.. _InterfaceRtemsInterruptHandlerIterate: + +rtems_interrupt_handler_iterate() +--------------------------------- + +Iterates over all interrupt handler installed at the interrupt vector. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_handler_iterate( + rtems_vector_number vector, + rtems_interrupt_per_handler_routine routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``vector`` + This parameter is the interrupt vector number. + +``routine`` + This parameter is the visitor routine. + +``arg`` + This parameter is the visitor argument. + +.. rubric:: DESCRIPTION: + +For each installed handler at the interrupt vector the visitor function +specified by ``routine`` will be called with the argument specified by ``arg`` +and the handler information, options, routine and argument. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INCORRECT_STATE` + The service was not initialized. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``routine`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +.. rubric:: NOTES: + +The directive is intended for system information and diagnostics. + +Never install or remove an interrupt handler within the visitor function. This +may result in a deadlock. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-initialize + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_initialize() + +.. _InterfaceRtemsInterruptServerInitialize: + +rtems_interrupt_server_initialize() +----------------------------------- + +Initializes the interrupt server tasks. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_initialize( + rtems_task_priority priority, + size_t stack_size, + rtems_mode modes, + rtems_attribute attributes, + uint32_t *server_count + ); + +.. rubric:: PARAMETERS: + +``priority`` + This parameter is the initial :term:`task priority` of the created + interrupt servers. + +``stack_size`` + This parameter is the task stack size of the created interrupt servers. + +``modes`` + This parameter is the initial mode set of the created interrupt servers. + +``attributes`` + This parameter is the attribute set of the created interrupt servers. + +``server_count`` + This parameter is the pointer to an `uint32_t + `_ object or `NULL + `_. When the pointer is not + equal to `NULL `_, the count of + successfully created interrupt servers is stored in this object regardless + of the return status. + +.. rubric:: DESCRIPTION: + +The directive tries to create an interrupt server task for each online +processor in the system. The tasks will have the initial priority specified by +``priority``, the stack size specified by ``stack_size``, the initial mode set +specified by ``modes``, and the attribute set specified by ``attributes``. The +count of successfully created server tasks will be returned in ``server_count`` +if the pointer is not equal to `NULL +`_. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INCORRECT_STATE` + The interrupt servers were already initialized. + +The directive uses :ref:`InterfaceRtemsTaskCreate`. If this directive fails, +then its error status will be returned. + +.. rubric:: NOTES: + +Interrupt handlers may be installed on an interrupt server with +:ref:`InterfaceRtemsInterruptServerHandlerInstall` and removed with +:ref:`InterfaceRtemsInterruptServerHandlerRemove` using a server index. In +case of an interrupt, the request will be forwarded to the interrupt server. +The handlers are executed within the interrupt server context. If one handler +blocks on something this may delay the processing of other handlers. + +Interrupt servers may be deleted by :ref:`InterfaceRtemsInterruptServerDelete`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-create + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_create() + +.. _InterfaceRtemsInterruptServerCreate: + +rtems_interrupt_server_create() +------------------------------- + +Creates an interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_create( + rtems_interrupt_server_control *control, + const rtems_interrupt_server_config *config, + uint32_t *server_index + ); + +.. rubric:: PARAMETERS: + +``control`` + This parameter is the pointer to an + :c:type:`rtems_interrupt_server_control` object. When the directive call + was successful, the ownership of the object was transferred from the caller + of the directive to the interrupt server management. + +``config`` + This parameter is the interrupt server configuration. + +``server_index`` + This parameter is the pointer to an `uint32_t + `_ object. When the + directive call was successful, the index of the created interrupt server + will be stored in this object. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +The directive uses :ref:`InterfaceRtemsTaskCreate`. If this directive fails, +then its error status will be returned. + +.. rubric:: NOTES: + +See also :ref:`InterfaceRtemsInterruptServerInitialize` and +:ref:`InterfaceRtemsInterruptServerDelete`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-handler-install + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_handler_install() + +.. _InterfaceRtemsInterruptServerHandlerInstall: + +rtems_interrupt_server_handler_install() +---------------------------------------- + +Installs the interrupt handler routine and argument at the interrupt vector on +the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_handler_install( + uint32_t server_index, + rtems_vector_number vector, + const char *info, + rtems_option options, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the interrupt server index. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``vector`` + This parameter is the interrupt vector number. + +``info`` + This parameter is the descriptive information of the interrupt handler to + install. + +``options`` + This parameter is the interrupt handler install option set. + +``routine`` + This parameter is the interrupt handler routine to install. + +``arg`` + This parameter is the interrupt handler argument to install. + +.. rubric:: DESCRIPTION: + +The handler routine specified by ``routine`` will be executed within the +context of the interrupt server task specified by ``server_index``. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +:c:macro:`RTEMS_CALLED_FROM_ISR` + The directive was called from within interrupt context. + +:c:macro:`RTEMS_INVALID_ADDRESS` + The ``routine`` parameter was `NULL + `_. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_INVALID_NUMBER` + An option specified by ``info`` was not applicable. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_UNIQUE` option was set in ``info`` and the + interrupt vector was already occupied by a handler. + +:c:macro:`RTEMS_RESOURCE_IN_USE` + The :c:macro:`RTEMS_INTERRUPT_SHARED` option was set in ``info`` and the + interrupt vector was already occupied by a unique handler. + +:c:macro:`RTEMS_TOO_MANY` + The handler specified by ``routine`` was already installed for the + interrupt vector specified by ``vector`` with an argument equal to the + argument specified by ``arg``. + +:c:macro:`RTEMS_UNSATISFIED` + The :c:macro:`RTEMS_INTERRUPT_REPLACE` option was set in ``info`` and no + handler to replace was installed. + +.. rubric:: NOTES: + +See also :ref:`InterfaceRtemsInterruptHandlerInstall`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-handler-remove + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_handler_remove() + +.. _InterfaceRtemsInterruptServerHandlerRemove: + +rtems_interrupt_server_handler_remove() +--------------------------------------- + +Removes the interrupt handler routine and argument from the interrupt vector +and the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_handler_remove( + uint32_t server_index, + rtems_vector_number vector, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the interrupt server index. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``vector`` + This parameter is the interrupt vector number. + +``routine`` + This parameter is the interrupt handler routine to remove. + +``arg`` + This parameter is the interrupt handler argument to remove. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +:c:macro:`RTEMS_UNSATISFIED` + There was no handler routine and argument pair installed specified by + ``routine`` and ``arg``. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +.. Generated from spec:/rtems/intr/if/server-set-affinity + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_set_affinity() + +.. _InterfaceRtemsInterruptServerSetAffinity: + +rtems_interrupt_server_set_affinity() +------------------------------------- + +Sets the processor affinity of the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_set_affinity( + uint32_t server_index, + size_t affinity_size, + const cpu_set_t *affinity, + rtems_task_priority priority + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the interrupt server index. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``affinity_size`` + This parameter is the size of the processor set referenced by ``affinity`` + in bytes. + +``affinity`` + This parameter is the pointer to a :c:type:`cpu_set_t` object. The + processor set defines the new processor affinity set of the interrupt + server. A set bit in the processor set means that the corresponding + processor shall be in the processor affinity set of the task, otherwise the + bit shall be cleared. + +``priority`` + This parameter is the new :term:`real priority` for the interrupt server. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +The directive uses :ref:`InterfaceRtemsSchedulerIdentByProcessorSet`, +:ref:`InterfaceRtemsTaskSetScheduler`, and +:ref:`InterfaceRtemsTaskSetAffinity`. If one of these directive fails, then +its error status will be returned. + +.. rubric:: NOTES: + +The scheduler is set determined by the highest numbered processor in the +affinity set specified by ``affinity``. + +This operation is only reliable in case the interrupt server was suspended via +:ref:`InterfaceRtemsInterruptServerSuspend`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may change the processor affinity of a task. This may cause + the calling task to be preempted. + +* The directive may change the priority of a task. This may cause the calling + task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-delete + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_delete() + +.. _InterfaceRtemsInterruptServerDelete: + +rtems_interrupt_server_delete() +------------------------------- + +Deletes the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_delete( uint32_t server_index ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the index of the interrupt server to delete. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the server index specified by + ``server_index``. + +.. rubric:: NOTES: + +The interrupt server deletes itself, so after the return of the directive the +interrupt server may be still in the termination process depending on the task +priorities of the system. + +See also :ref:`InterfaceRtemsInterruptServerCreate`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +.. Generated from spec:/rtems/intr/if/server-suspend + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_suspend() + +.. _InterfaceRtemsInterruptServerSuspend: + +rtems_interrupt_server_suspend() +-------------------------------- + +Suspends the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_suspend( uint32_t server_index ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the index of the interrupt server to suspend. The + constant :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify + the default interrupt server. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +.. rubric:: NOTES: + +Interrupt server may be resumed by :ref:`InterfaceRtemsInterruptServerResume`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +.. Generated from spec:/rtems/intr/if/server-resume + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_resume() + +.. _InterfaceRtemsInterruptServerResume: + +rtems_interrupt_server_resume() +------------------------------- + +Resumes the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_resume( uint32_t server_index ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the index of the interrupt server to resume. The + constant :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify + the default interrupt server. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +.. rubric:: NOTES: + +Interrupt server may be suspended by +:ref:`InterfaceRtemsInterruptServerSuspend`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +.. Generated from spec:/rtems/intr/if/server-move + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_move() + +.. _InterfaceRtemsInterruptServerMove: + +rtems_interrupt_server_move() +----------------------------- + +Moves the interrupt handlers installed at the interrupt vector and the source +interrupt server to the destination interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_move( + uint32_t source_server_index, + rtems_vector_number vector, + uint32_t destination_server_index + ); + +.. rubric:: PARAMETERS: + +``source_server_index`` + This parameter is the index of the source interrupt server. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``vector`` + This parameter is the interrupt vector number. + +``destination_server_index`` + This parameter is the index of the destination interrupt server. The + constant :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify + the default interrupt server. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``source_server_index``. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``destination_server_index``. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +.. Generated from spec:/rtems/intr/if/server-handler-iterate + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_handler_iterate() + +.. _InterfaceRtemsInterruptServerHandlerIterate: + +rtems_interrupt_server_handler_iterate() +---------------------------------------- + +Iterates over all interrupt handler installed at the interrupt vector and +interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_handler_iterate( + uint32_t server_index, + rtems_vector_number vector, + rtems_interrupt_per_handler_routine routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the index of the interrupt server. + +``vector`` + This parameter is the interrupt vector number. + +``routine`` + This parameter is the visitor routine. + +``arg`` + This parameter is the visitor argument. + +.. rubric:: DESCRIPTION: + +For each installed handler at the interrupt vector and interrupt server the +visitor function specified by ``vector`` will be called with the argument +specified by ``routine`` and the handler information, options, routine and +argument. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt vector associated with the number specified by + ``vector``. + +.. rubric:: NOTES: + +The directive is intended for system information and diagnostics. + +Never install or remove an interrupt handler within the visitor function. This +may result in a deadlock. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-entry-initialize + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_entry_initialize() + +.. _InterfaceRtemsInterruptServerEntryInitialize: + +rtems_interrupt_server_entry_initialize() +----------------------------------------- + +Initializes the interrupt server entry. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_entry_initialize( + uint32_t server_index, + rtems_interrupt_server_entry *entry + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the interrupt server index. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``entry`` + This parameter is the interrupt server entry to initialize. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +.. rubric:: NOTES: + +After initialization, the list of actions of the interrupt server entry is +empty. Actions may be prepended by +:ref:`InterfaceRtemsInterruptServerActionPrepend`. Interrupt server entries may +be moved to another interrupt vector with +:ref:`InterfaceRtemsInterruptServerEntryMove`. Server entries may be submitted +to get serviced by the interrupt server with +:ref:`InterfaceRtemsInterruptServerEntrySubmit`. Server entries may be +destroyed by :ref:`InterfaceRtemsInterruptServerEntryDestroy`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-action-prepend + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_action_prepend() + +.. _InterfaceRtemsInterruptServerActionPrepend: + +rtems_interrupt_server_action_prepend() +--------------------------------------- + +Prepends the interrupt server action to the list of actions of the interrupt +server entry. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_action_prepend( + rtems_interrupt_server_entry *entry, + rtems_interrupt_server_action *action, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``entry`` + This parameter is the interrupt server entry to prepend the interrupt + server action. It shall have been initialized via + :ref:`InterfaceRtemsInterruptServerEntryInitialize`. + +``action`` + This parameter is the interrupt server action to initialize and prepend to + the list of actions of the entry. + +``routine`` + This parameter is the interrupt handler routine to set in the action. + +``arg`` + This parameter is the interrupt handler argument to set in the action. + +.. rubric:: NOTES: + +No error checking is performed by the directive. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +* The interrupt server entry shall have been initialized by + :ref:`InterfaceRtemsInterruptServerEntryInitialize` and further optional + calls to :ref:`InterfaceRtemsInterruptServerActionPrepend`. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerActionPrepend` with the same interrupt + server entry. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerEntryMove` with the same interrupt server + entry. Calling the directive under this condition is undefined behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerEntrySubmit` with the same interrupt + server entry. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called while the interrupt server entry is pending + on or serviced by its current interrupt server. Calling the directive under + these conditions is undefined behaviour. + +.. Generated from spec:/rtems/intr/if/server-entry-destroy + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_entry_destroy() + +.. _InterfaceRtemsInterruptServerEntryDestroy: + +rtems_interrupt_server_entry_destroy() +-------------------------------------- + +Destroys the interrupt server entry. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_entry_destroy( + rtems_interrupt_server_entry *entry + ); + +.. rubric:: PARAMETERS: + +``entry`` + This parameter is the interrupt server entry to destroy. + +.. rubric:: NOTES: + +No error checking is performed by the directive. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +* The interrupt server entry shall have been initialized by + :ref:`InterfaceRtemsInterruptServerEntryInitialize` and further optional + calls to :ref:`InterfaceRtemsInterruptServerActionPrepend`. + +.. Generated from spec:/rtems/intr/if/server-entry-submit + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_entry_submit() + +.. _InterfaceRtemsInterruptServerEntrySubmit: + +rtems_interrupt_server_entry_submit() +------------------------------------- + +Submits the interrupt server entry to be serviced by the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_entry_submit( + rtems_interrupt_server_entry *entry + ); + +.. rubric:: PARAMETERS: + +``entry`` + This parameter is the interrupt server entry to submit. + +.. rubric:: DESCRIPTION: + +The directive appends the entry to the pending entries of the interrupt server. +The interrupt server is notified that a new entry is pending. Once the +interrupt server is scheduled it services the actions of all pending entries. + +.. rubric:: NOTES: + +This directive may be used to do a two-step interrupt processing. The first +step is done from within interrupt context by a call to this directive. The +second step is then done from within the context of the interrupt server. + +No error checking is performed by the directive. + +A submitted entry may be destroyed by +:ref:`InterfaceRtemsInterruptServerEntryDestroy`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may unblock a task. This may cause the calling task to be + preempted. + +* The interrupt server entry shall have been initialized by + :ref:`InterfaceRtemsInterruptServerEntryInitialize` and further optional + calls to :ref:`InterfaceRtemsInterruptServerActionPrepend`. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerActionPrepend` with the same interrupt + server entry. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerEntryMove` with the same interrupt server + entry. Calling the directive under this condition is undefined behaviour. + +.. Generated from spec:/rtems/intr/if/server-entry-move + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_entry_move() + +.. _InterfaceRtemsInterruptServerEntryMove: + +rtems_interrupt_server_entry_move() +----------------------------------- + +Moves the interrupt server entry to the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_entry_move( + rtems_interrupt_server_entry *entry, + uint32_t server_index + ); + +.. rubric:: PARAMETERS: + +``entry`` + This parameter is the interrupt server entry to move. + +``server_index`` + This parameter is the index of the destination interrupt server. The + constant :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify + the default interrupt server. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +* The interrupt server entry shall have been initialized by + :ref:`InterfaceRtemsInterruptServerEntryInitialize` and further optional + calls to :ref:`InterfaceRtemsInterruptServerActionPrepend`. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerActionPrepend` with the same interrupt + server entry. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerEntryMove` with the same interrupt server + entry. Calling the directive under this condition is undefined behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerEntrySubmit` with the same interrupt + server entry. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called while the interrupt server entry is pending + on or serviced by its current interrupt server. Calling the directive under + these conditions is undefined behaviour. + +.. Generated from spec:/rtems/intr/if/server-request-initialize + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_request_initialize() + +.. _InterfaceRtemsInterruptServerRequestInitialize: + +rtems_interrupt_server_request_initialize() +------------------------------------------- + +Initializes the interrupt server request. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + rtems_status_code rtems_interrupt_server_request_initialize( + uint32_t server_index, + rtems_interrupt_server_request *request, + rtems_interrupt_handler routine, + void *arg + ); + +.. rubric:: PARAMETERS: + +``server_index`` + This parameter is the interrupt server index. The constant + :c:macro:`RTEMS_INTERRUPT_SERVER_DEFAULT` may be used to specify the + default interrupt server. + +``request`` + This parameter is the interrupt server request to initialize. + +``routine`` + This parameter is the interrupt handler routine for the request action. + +``arg`` + This parameter is the interrupt handler argument for the request action. + +.. rubric:: RETURN VALUES: + +:c:macro:`RTEMS_SUCCESSFUL` + The requested operation was successful. + +:c:macro:`RTEMS_INVALID_ID` + There was no interrupt server associated with the index specified by + ``server_index``. + +.. rubric:: NOTES: + +An interrupt server requests consists of an interrupt server entry and exactly +one interrupt server action. The interrupt vector of the request may be +changed with :ref:`InterfaceRtemsInterruptServerRequestSetVector`. Interrupt +server requests may be submitted to get serviced by the interrupt server with +:ref:`InterfaceRtemsInterruptServerRequestSubmit`. Requests may be destroyed +by :ref:`InterfaceRtemsInterruptServerRequestDestroy`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may obtain and release the object allocator mutex. This may + cause the calling task to be preempted. + +.. Generated from spec:/rtems/intr/if/server-request-set-vector + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_request_set_vector() + +.. _InterfaceRtemsInterruptServerRequestSetVector: + +rtems_interrupt_server_request_set_vector() +------------------------------------------- + +Sets the interrupt vector in the interrupt server request. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_request_set_vector( + rtems_interrupt_server_request *request, + rtems_vector_number vector + ); + +.. rubric:: PARAMETERS: + +``request`` + This parameter is the interrupt server request to change. + +``vector`` + This parameter is the interrupt vector number to be used by the request. + +.. rubric:: NOTES: + +By default, the interrupt vector of an interrupt server request is set to a +special value which is outside the range of vectors supported by the interrupt +controller hardware. + +Calls to :ref:`InterfaceRtemsInterruptServerRequestSubmit` will disable the +interrupt vector of the request. After processing of the request by the +interrupt server the interrupt vector will be enabled again. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive will not cause the calling task to be preempted. + +* The interrupt server request shall have been initialized by + :ref:`InterfaceRtemsInterruptServerRequestInitialize`. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerRequestSetVector` with the same interrupt + server request. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerRequestSubmit` with the same interrupt + server request. Calling the directive under this condition is undefined + behaviour. + +* The directive shall not be called while the interrupt server entry is pending + on or serviced by its current interrupt server. Calling the directive under + these conditions is undefined behaviour. + +.. Generated from spec:/rtems/intr/if/server-request-destroy + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_request_destroy() + +.. _InterfaceRtemsInterruptServerRequestDestroy: + +rtems_interrupt_server_request_destroy() +---------------------------------------- + +Destroys the interrupt server request. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_request_destroy( + rtems_interrupt_server_request *request + ); + +.. rubric:: PARAMETERS: + +``request`` + This parameter is the interrupt server request to destroy. + +.. rubric:: NOTES: + +No error checking is performed by the directive. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within task context. + +* The directive shall not be called from within the context of an interrupt + server. Calling the directive from within the context of an interrupt server + is undefined behaviour. + +* The directive sends a request to another task and waits for a response. This + may cause the calling task to be blocked and unblocked. + +* The interrupt server request shall have been initialized by + :ref:`InterfaceRtemsInterruptServerRequestInitialize`. + +.. Generated from spec:/rtems/intr/if/server-request-submit + +.. raw:: latex + + \clearpage + +.. index:: rtems_interrupt_server_request_submit() + +.. _InterfaceRtemsInterruptServerRequestSubmit: + +rtems_interrupt_server_request_submit() +--------------------------------------- + +Submits the interrupt server request to be serviced by the interrupt server. + +.. rubric:: CALLING SEQUENCE: + +.. code-block:: c + + void rtems_interrupt_server_request_submit( + rtems_interrupt_server_request *request + ); + +.. rubric:: PARAMETERS: + +``request`` + This parameter is the interrupt server request to submit. + +.. rubric:: DESCRIPTION: + +The directive appends the interrupt server entry of the request to the pending +entries of the interrupt server. The interrupt server is notified that a new +entry is pending. Once the interrupt server is scheduled it services the +actions of all pending entries. + +.. rubric:: NOTES: + +This directive may be used to do a two-step interrupt processing. The first +step is done from within interrupt context by a call to this directive. The +second step is then done from within the context of the interrupt server. + +No error checking is performed by the directive. + +A submitted request may be destroyed by +:ref:`InterfaceRtemsInterruptServerRequestDestroy`. + +.. rubric:: CONSTRAINTS: + +The following constraints apply to this directive: + +* The directive may be called from within interrupt context. + +* The directive may be called from within device driver initialization context. + +* The directive may be called from within task context. + +* The directive may unblock a task. This may cause the calling task to be + preempted. + +* The interrupt server request shall have been initialized by + :ref:`InterfaceRtemsInterruptServerRequestInitialize`. + +* The directive shall not be called concurrently with + :ref:`InterfaceRtemsInterruptServerRequestSetVector` with the same interrupt + server request. Calling the directive under this condition is undefined + behaviour. diff --git a/c-user/interrupt/introduction.rst b/c-user/interrupt/introduction.rst index 3d5c71d..7987b54 100644 --- a/c-user/interrupt/introduction.rst +++ b/c-user/interrupt/introduction.rst @@ -1,6 +1,6 @@ .. SPDX-License-Identifier: CC-BY-SA-4.0 -.. Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) +.. Copyright (C) 2008, 2021 embedded brains GmbH (http://www.embedded-brains.de) .. Copyright (C) 1988, 2008 On-Line Applications Research Corporation (OAR) .. This file is part of the RTEMS quality process and was automatically @@ -33,8 +33,6 @@ Introduction .. spec:/rtems/intr/if/local-disable .. spec:/rtems/intr/if/local-enable .. spec:/rtems/intr/if/is-in-progress -.. spec:/rtems/intr/if/cause -.. spec:/rtems/intr/if/clear .. spec:/rtems/intr/if/lock-initialize .. spec:/rtems/intr/if/lock-destroy .. spec:/rtems/intr/if/lock-acquire @@ -47,6 +45,42 @@ Introduction .. spec:/rtems/intr/if/lock-initializer .. spec:/rtems/intr/if/lock-member .. spec:/rtems/intr/if/lock-reference +.. spec:/rtems/intr/if/entry-initializer +.. spec:/rtems/intr/if/entry-initialize +.. spec:/rtems/intr/if/entry-install +.. spec:/rtems/intr/if/entry-remove +.. spec:/rtems/intr/if/handler-install +.. spec:/rtems/intr/if/handler-remove +.. spec:/rtems/intr/if/vector-is-enabled +.. spec:/rtems/intr/if/vector-enable +.. spec:/rtems/intr/if/vector-disable +.. spec:/rtems/intr/if/is-pending +.. spec:/rtems/intr/if/raise +.. spec:/rtems/intr/if/raise-on +.. spec:/rtems/intr/if/clear +.. spec:/rtems/intr/if/get-affinity +.. spec:/rtems/intr/if/set-affinity +.. spec:/rtems/intr/if/get-attributes +.. spec:/rtems/intr/if/handler-iterate +.. spec:/rtems/intr/if/server-initialize +.. spec:/rtems/intr/if/server-create +.. spec:/rtems/intr/if/server-handler-install +.. spec:/rtems/intr/if/server-handler-remove +.. spec:/rtems/intr/if/server-set-affinity +.. spec:/rtems/intr/if/server-delete +.. spec:/rtems/intr/if/server-suspend +.. spec:/rtems/intr/if/server-resume +.. spec:/rtems/intr/if/server-move +.. spec:/rtems/intr/if/server-handler-iterate +.. spec:/rtems/intr/if/server-entry-initialize +.. spec:/rtems/intr/if/server-action-prepend +.. spec:/rtems/intr/if/server-entry-destroy +.. spec:/rtems/intr/if/server-entry-submit +.. spec:/rtems/intr/if/server-entry-move +.. spec:/rtems/intr/if/server-request-initialize +.. spec:/rtems/intr/if/server-request-set-vector +.. spec:/rtems/intr/if/server-request-destroy +.. spec:/rtems/intr/if/server-request-submit Any real-time executive must provide a mechanism for quick response to externally generated interrupts to satisfy the critical time constraints of the @@ -76,10 +110,6 @@ from an ISR. The directives provided by the Interrupt Manager are: * :ref:`InterfaceRtemsInterruptIsInProgress` - Checks if an ISR is in progress on the current processor. -* :ref:`InterfaceRtemsInterruptCause` - Causes the interrupt. - -* :ref:`InterfaceRtemsInterruptClear` - Clears the interrupt. - * :ref:`InterfaceRtemsInterruptLockInitialize` - Initializes the ISR lock. * :ref:`InterfaceRtemsInterruptLockDestroy` - Destroys the ISR lock. @@ -108,3 +138,104 @@ from an ISR. The directives provided by the Interrupt Manager are: * :ref:`InterfaceRTEMSINTERRUPTLOCKREFERENCE` - Defines an ISR lock object reference. + +* :ref:`InterfaceRTEMSINTERRUPTENTRYINITIALIZER` - Statically initializes an + interrupt entry object. + +* :ref:`InterfaceRtemsInterruptEntryInitialize` - Initializes the interrupt + entry. + +* :ref:`InterfaceRtemsInterruptEntryInstall` - Installs the interrupt entry at + the interrupt vector. + +* :ref:`InterfaceRtemsInterruptEntryRemove` - Removes the interrupt entry from + the interrupt vector. + +* :ref:`InterfaceRtemsInterruptHandlerInstall` - Installs the interrupt handler + routine and argument at the interrupt vector. + +* :ref:`InterfaceRtemsInterruptHandlerRemove` - Removes the interrupt handler + routine and argument from the interrupt vector. + +* :ref:`InterfaceRtemsInterruptVectorIsEnabled` - Checks if the interrupt + vector is enabled. + +* :ref:`InterfaceRtemsInterruptVectorEnable` - Enables the interrupt vector. + +* :ref:`InterfaceRtemsInterruptVectorDisable` - Disables the interrupt vector. + +* :ref:`InterfaceRtemsInterruptIsPending` - Checks if the interrupt is pending. + +* :ref:`InterfaceRtemsInterruptRaise` - Raises the interrupt vector. + +* :ref:`InterfaceRtemsInterruptRaiseOn` - Raises the interrupt vector on the + processor. + +* :ref:`InterfaceRtemsInterruptClear` - Clears the interrupt vector. + +* :ref:`InterfaceRtemsInterruptGetAffinity` - Gets the processor affinity set + of the interrupt vector. + +* :ref:`InterfaceRtemsInterruptSetAffinity` - Sets the processor affinity set + of the interrupt vector. + +* :ref:`InterfaceRtemsInterruptGetAttributes` - Gets the attributes of the + interrupt vector. + +* :ref:`InterfaceRtemsInterruptHandlerIterate` - Iterates over all interrupt + handler installed at the interrupt vector. + +* :ref:`InterfaceRtemsInterruptServerInitialize` - Initializes the interrupt + server tasks. + +* :ref:`InterfaceRtemsInterruptServerCreate` - Creates an interrupt server. + +* :ref:`InterfaceRtemsInterruptServerHandlerInstall` - Installs the interrupt + handler routine and argument at the interrupt vector on the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerHandlerRemove` - Removes the interrupt + handler routine and argument from the interrupt vector and the interrupt + server. + +* :ref:`InterfaceRtemsInterruptServerSetAffinity` - Sets the processor affinity + of the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerDelete` - Deletes the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerSuspend` - Suspends the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerResume` - Resumes the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerMove` - Moves the interrupt handlers + installed at the interrupt vector and the source interrupt server to the + destination interrupt server. + +* :ref:`InterfaceRtemsInterruptServerHandlerIterate` - Iterates over all + interrupt handler installed at the interrupt vector and interrupt server. + +* :ref:`InterfaceRtemsInterruptServerEntryInitialize` - Initializes the + interrupt server entry. + +* :ref:`InterfaceRtemsInterruptServerActionPrepend` - Prepends the interrupt + server action to the list of actions of the interrupt server entry. + +* :ref:`InterfaceRtemsInterruptServerEntryDestroy` - Destroys the interrupt + server entry. + +* :ref:`InterfaceRtemsInterruptServerEntrySubmit` - Submits the interrupt + server entry to be serviced by the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerEntryMove` - Moves the interrupt server + entry to the interrupt server. + +* :ref:`InterfaceRtemsInterruptServerRequestInitialize` - Initializes the + interrupt server request. + +* :ref:`InterfaceRtemsInterruptServerRequestSetVector` - Sets the interrupt + vector in the interrupt server request. + +* :ref:`InterfaceRtemsInterruptServerRequestDestroy` - Destroys the interrupt + server request. + +* :ref:`InterfaceRtemsInterruptServerRequestSubmit` - Submits the interrupt + server request to be serviced by the interrupt server. -- cgit v1.2.3