Changeset d8134178 in rtems


Ignore:
Timestamp:
Jan 9, 2013, 4:20:58 PM (8 years ago)
Author:
Alex Ivanov <alexivanov97@…>
Branches:
4.11, 5, master
Children:
f33a84b5
Parents:
f12ef239
git-author:
Alex Ivanov <alexivanov97@…> (01/09/13 16:20:58)
git-committer:
Gedare Bloom <gedare@…> (01/09/13 16:20:58)
Message:

score: Doxygen Clean Up Task #18

http://www.google-melange.com/gci/task/view/google/gci2012/8137204

Location:
cpukit/score/inline/rtems/score
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/inline/rtems/score/address.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/address.inl
     1/**
     2 * @file
    33 *
    4  *  This include file contains the bodies of the routines
    5  *  about addresses which are inlined.
     4 * @brief Inlined Routines Associated with Addresses
     5 *
     6 * This include file contains the bodies of the routines
     7 * about addresses which are inlined.
    68 */
    79
     
    2527
    2628/**
    27  *  @addtogroup ScoreAddress
    28  *  @{
     29 * @addtogroup ScoreAddress
     30 *
     31 * @{
    2932 */
    3033
    31 /** @brief Add Offset to Address
     34/**
     35 * @brief Add offset to an address.
    3236 *
    33  *  This function is used to add an @a offset to a @a base address.
    34  *  It returns the resulting address.  This address is typically
    35  *  converted to an access type before being used further.
     37 * This function is used to add an @a offset to a @a base address.
     38 * It returns the resulting address.  This address is typically
     39 * converted to an access type before being used further.
    3640 *
    37  *  @param[in] base is the base address.
    38  *  @param[in] offset is the offset to add to @a base.
     41 * @param[in] base is the base address.
     42 * @param[in] offset is the offset to add to @a base.
    3943 *
    40  *  @return This method returns the resulting address.
     44 * @return This method returns the resulting address.
    4145 */
    4246#include <rtems/bspIo.h>
     
    4953}
    5054
    51 /** @brief Subtract Offset from Offset
     55/**
     56 * @brief Subtract offset from offset.
    5257 *
    53  *  This function is used to subtract an @a offset from a @a base
    54  *  address.  It returns the resulting address.  This address is
    55  *  typically converted to an access type before being used further.
     58 * This function is used to subtract an @a offset from a @a base
     59 * address.  It returns the resulting address.  This address is
     60 * typically converted to an access type before being used further.
    5661 *
    57  *  @param[in] base is the base address.
    58  *  @param[in] offset is the offset to subtract to @a base.
     62 * @param[in] base is the base address.
     63 * @param[in] offset is the offset to subtract to @a base.
    5964 *
    60  *  @return This method returns the resulting address.
     65 * @return This method returns the resulting address.
    6166 */
    6267
     
    6974}
    7075
    71 /** @brief Subtract Two Offsets
     76/**
     77 * @brief Subtract two offsets.
    7278 *
    73  *  This function is used to subtract two addresses.  It returns the
    74  *  resulting offset.
     79 * This function is used to subtract two addresses.  It returns the
     80 * resulting offset.
    7581 *
    76  *  @param[in] left is the address on the left hand side of the subtraction.
    77  *  @param[in] right is the address on the right hand side of the subtraction.
     82 * @param[in] left is the address on the left hand side of the subtraction.
     83 * @param[in] right is the address on the right hand side of the subtraction.
    7884 *
    79  *  @return This method returns the resulting address.
     85 * @return This method returns the resulting address.
    8086 *
    81  *  @note  The cast of an address to an uint32_t makes this code
    82  *         dependent on an addresses being thirty two bits.
     87 * @note  The cast of an address to an uint32_t makes this code
     88 *        dependent on an addresses being thirty two bits.
    8389 */
    8490RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
     
    9096}
    9197
    92 /** @brief Is Address Aligned
     98/**
     99 * @brief Is address aligned.
    93100 *
    94  *  This function returns true if the given address is correctly
    95  *  aligned for this processor and false otherwise.  Proper alignment
    96  *  is based on correctness and efficiency.
     101 * This function returns true if the given address is correctly
     102 * aligned for this processor and false otherwise.  Proper alignment
     103 * is based on correctness and efficiency.
    97104 *
    98  *  @param[in] address is the address being checked for alignment.
     105 * @param[in] address is the address being checked for alignment.
    99106 *
    100  *  @return This method returns true if the address is aligned and
    101  *          false otherwise.
     107 * @retval true The @a address is aligned.
     108 * @retval false The @a address is not aligned.
    102109 */
    103110RTEMS_INLINE_ROUTINE bool _Addresses_Is_aligned (
     
    112119}
    113120
    114 /** @brief Is Address In Range
     121/**
     122 * @brief Is address in range.
    115123 *
    116  *  This function returns true if the given address is within the
    117  *  memory range specified and false otherwise.  base is the address
    118  *  of the first byte in the memory range and limit is the address
    119  *  of the last byte in the memory range.  The base address is
    120  *  assumed to be lower than the limit address.
     124 * This function returns true if the given address is within the
     125 * memory range specified and false otherwise.  base is the address
     126 * of the first byte in the memory range and limit is the address
     127 * of the last byte in the memory range.  The base address is
     128 * assumed to be lower than the limit address.
    121129 *
    122  *  @param[in] address is the address to check.
    123  *  @param[in] base is the lowest address of the range to check against.
    124  *  @param[in] limit is the highest address of the range to check against.
     130 * @param[in] address is the address to check.
     131 * @param[in] base is the lowest address of the range to check against.
     132 * @param[in] limit is the highest address of the range to check against.
    125133 *
    126  *  @return This method returns true if the given @a address is within the
    127  *  memory range specified and false otherwise.
     134 * @retval true The @a address is within the memory range specified
     135 * @retval false The @a address is not within the memory range specified.
    128136 */
    129137RTEMS_INLINE_ROUTINE bool _Addresses_Is_in_range (
     
    136144}
    137145
    138 /**@}*/
     146/** @} */
    139147
    140148#endif
  • cpukit/score/inline/rtems/score/coremutex.inl

    rf12ef239 rd8134178  
    1 /**
    2  *  @file  rtems/score/coremutex.inl
    3  *
    4  *  This include file contains all of the inlined routines associated
    5  *  with the CORE mutexes.
     1/**
     2 * @file
     3 *
     4 * @brief Inlined Routines Associated with the CORE Mutexes
     5 *
     6 * This include file contains all of the inlined routines associated
     7 * with the CORE mutexes.
    68 */
    79
     
    2325
    2426/**
    25  *  @addtogroup ScoreMutex
    26  *  @{
    27  */
    28 
    29 /**
    30  *  @brief Is Mutex Locked
    31  *
    32  *  This routine returns true if the mutex specified is locked and false
    33  *  otherwise.
    34  *
    35  *  @param[in] the_mutex is the mutex to check
    36  *
    37  *  @return This method returns true if the mutex is locked.
     27 * @addtogroup ScoreMutex
     28 *
     29 * @{
     30 */
     31
     32/**
     33 * @brief Is mutex locked.
     34 *
     35 * This routine returns true if the mutex specified is locked and false
     36 * otherwise.
     37 *
     38 * @param[in] the_mutex is the mutex to check.
     39 *
     40 * @retval true The mutex is locked.
     41 * @retval false The mutex is not locked.
    3842 */
    3943RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_locked(
     
    4347  return the_mutex->lock == CORE_MUTEX_LOCKED;
    4448}
    45  
    46 /**
    47  *  @brief Does Core Mutex Use FIFO Blocking
    48  *
    49  *  This routine returns true if the mutex's wait discipline is FIFO and false
    50  *  otherwise.
    51  *
    52  *  @param[in] the_attribute is the attribute set of the mutex
    53  *
    54  *  @return This method returns true if the mutex is using FIFO blocking order.
     49
     50/**
     51 * @brief Does core mutex use FIFO blocking.
     52 *
     53 * This routine returns true if the mutex's wait discipline is FIFO and false
     54 * otherwise.
     55 *
     56 * @param[in] the_attribute is the attribute set of the mutex.
     57 *
     58 * @retval true The mutex is using FIFO blocking order.
     59 * @retval false The mutex is not using FIFO blocking order.
    5560 */
    5661RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_fifo(
     
    6065  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_FIFO;
    6166}
    62  
    63 /**
    64  *  @brief Doex Core Mutex Use Priority Blocking
    65  *
    66  *  This routine returns true if the mutex's wait discipline is PRIORITY and
    67  *  false otherwise.
    68  *
    69  *  @param[in] the_attribute is the attribute set of the mutex
    70  *
    71  *  @return This method returns true if the mutex is using
    72  *          priority blocking order.
     67
     68/**
     69 * @brief Doex core mutex use priority blocking.
     70 *
     71 * This routine returns true if the mutex's wait discipline is PRIORITY and
     72 * false otherwise.
     73 *
     74 * @param[in] the_attribute is the attribute set of the mutex.
     75 *
     76 * @retval true The mutex is using priority blocking order.
     77 * @retval false The mutex is not using priority blocking order.
     78 *
    7379 */
    7480RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority(
     
    7884  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY;
    7985}
    80  
    81 /**
    82  *  @brief Does Mutex Use Priority Inheritance
    83  *
    84  *  This routine returns true if the mutex's wait discipline is
    85  *  INHERIT_PRIORITY and false otherwise.
    86  *
    87  *  @param[in] the_attribute is the attribute set of the mutex
    88  *
    89  *  @return This method returns true if the mutex is using priority
    90  *         inheritance.
     86
     87/**
     88 * @brief Does mutex use priority inheritance.
     89 *
     90 * This routine returns true if the mutex's wait discipline is
     91 * INHERIT_PRIORITY and false otherwise.
     92 *
     93 * @param[in] the_attribute is the attribute set of the mutex.
     94 *
     95 * @retval true The mutex is using priority inheritance.
     96 * @retval false The mutex is not using priority inheritance.
    9197 */
    9298RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
     
    96102  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
    97103}
    98  
    99 /**
    100  *  @brief Does Mutex Use Priority Ceiling
    101  *
    102  *  This routine returns true if the mutex's wait discipline is
    103  *  PRIORITY_CEILING and false otherwise.
    104  *
    105  *  @param[in] the_attribute is the attribute set of the mutex
    106  *  @return This method returns true if the mutex is using priority
    107  *          ceiling.
     104
     105/**
     106 * @brief Does mutex use priority ceiling.
     107 *
     108 * This routine returns true if the mutex's wait discipline is
     109 * PRIORITY_CEILING and false otherwise.
     110 *
     111 * @param[in] the_attribute is the attribute set of the mutex.
     112 *
     113 * @retval true The mutex is using priority ceiling.
     114 * @retval false The mutex is not using priority ceiling.
    108115 */
    109116RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority_ceiling(
     
    113120  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
    114121}
    115  
     122
    116123/*
    117124 *  Seize Mutex with Quick Success Path
     
    222229}
    223230
    224 /**@}*/
     231/** @} */
    225232
    226233#endif
  • cpukit/score/inline/rtems/score/heap.inl

    rf12ef239 rd8134178  
    22 * @file
    33 *
    4  * @ingroup ScoreHeap
    5  *
    6  * @brief Heap Handler API.
     4 * @brief Heap Handler API
    75 */
    86
     
    202200 * The next block of the last block will be the first block.  Since the first
    203201 * block indicates that the previous block is used, this ensures that the last
    204  * block appears as used for the _Heap_Is_used() and _Heap_Is_free() functions.
     202 * block appears as used for the _Heap_Is_used() and _Heap_Is_free()
     203 * functions.
    205204 *
    206205 * This feature will be used to terminate the scattered heap area list.  See
  • cpukit/score/inline/rtems/score/priority.inl

    rf12ef239 rd8134178  
    1 /**
    2  * @file rtems/score/priority.inl
     1/**
     2 * @file
     3 *
     4 * @brief Inlined Routines in the Priority Handler
    35 *
    46 * This file contains the static inline implementation of all inlined
     
    2325
    2426/**
    25  *  @addtogroup ScorePriority
    26  *  @{
     27 * @addtogroup ScorePriority
     28 *
     29 * @{
    2730 */
    2831
    2932/**
    30  *  This function returns true if the_priority if valid for a
    31  *  user task, and false otherwise.
     33 * This function returns true if the_priority if valid for a
     34 * user task, and false otherwise.
    3235 */
    3336
     
    3639)
    3740{
    38   /* 
     41  /*
    3942   *  Since PRIORITY_MINIMUM is 0 and priorities are stored unsigned,
    4043   *  then checking for less than 0 is unnecessary.
     
    4649
    4750
    48 /**@}*/
     51/** @} */
    4952
    5053#endif
  • cpukit/score/inline/rtems/score/prioritybitmap.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/prioritybitmap.inl
     1/**
     2 * @file
    33 *
    4  *  This file contains the static inline implementation of all inlined
    5  *  routines in the Priority Handler bit map implementation
     4 * @brief Inlined Routines in the Priority Handler Bit Map Implementation
     5 *
     6 * This file contains the static inline implementation of all inlined
     7 * routines in the Priority Handler bit map implementation
    68 */
    79
     
    2325
    2426/**
    25  *  @addtogroup ScorePriority
    26  *  @{
     27 * @addtogroup ScorePriority
     28 *
     29 * @{
    2730 */
    2831
     
    3033
    3134/**
    32  *  This function returns the major portion of the_priority.
     35 * This function returns the major portion of the_priority.
    3336 */
    3437
     
    4144
    4245/**
    43  *  This function returns the minor portion of the_priority.
     46 * This function returns the minor portion of the_priority.
    4447 */
    4548
     
    5255
    5356#if ( CPU_USE_GENERIC_BITFIELD_CODE == TRUE )
    54  
     57
    5558/**
    56  *  This function returns the mask associated with the major or minor
    57  *  number passed to it.
     59 * This function returns the mask associated with the major or minor
     60 * number passed to it.
    5861 */
    59  
     62
    6063RTEMS_INLINE_ROUTINE Priority_bit_map_Control   _Priority_Mask (
    6164  uint32_t   bit_number
     
    6467  return (Priority_bit_map_Control)(0x8000u >> bit_number);
    6568}
    66  
     69
    6770/**
    68  *  This function returns the mask bit inverted.
     71 * This function returns the mask bit inverted.
    6972 */
    70  
     73
    7174RTEMS_INLINE_ROUTINE Priority_bit_map_Control   _Priority_Mask_invert (
    7275  uint32_t   mask
     
    7679}
    7780
    78  
     81
    7982/**
    80  *  This function translates the bit numbers returned by the bit scan
    81  *  of a priority bit field into something suitable for use as
    82  *  a major or minor component of a priority.
     83 * This function translates the bit numbers returned by the bit scan
     84 * of a priority bit field into something suitable for use as
     85 * a major or minor component of a priority.
    8386 */
    84  
     87
    8588RTEMS_INLINE_ROUTINE uint32_t   _Priority_Bits_index (
    8689  uint32_t   bit_number
     
    97100
    98101/**
    99  *  This routine performs the initialization necessary for this handler.
     102 * This routine performs the initialization necessary for this handler.
    100103 */
    101104
     
    110113
    111114/**
    112  *  This routine uses the_priority_map to update the priority
    113  *  bit maps to indicate that a thread has been readied.
     115 * This routine uses the_priority_map to update the priority
     116 * bit maps to indicate that a thread has been readied.
    114117 */
    115118
     
    123126
    124127/**
    125  *  This routine uses the_priority_map to update the priority
    126  *  bit maps to indicate that a thread has been removed from the
    127  *  ready state.
     128 * This routine uses the_priority_map to update the priority
     129 * bit maps to indicate that a thread has been removed from the
     130 * ready state.
    128131 */
    129132
     
    138141
    139142/**
    140  *  This function returns the priority of the highest priority
    141  *  ready thread.
     143 * This function returns the priority of the highest priority
     144 * ready thread.
    142145 */
    143146
     
    155158
    156159/**
    157  *  This routine initializes the_priority_map so that it
    158  *  contains the information necessary to manage a thread
    159  *  at new_priority.
     160 * This routine initializes the_priority_map so that it
     161 * contains the information necessary to manage a thread
     162 * at new_priority.
    160163 */
    161164
     
    186189}
    187190
    188 /**@}*/
     191/** @} */
    189192
    190193#endif
  • cpukit/score/inline/rtems/score/rbtree.inl

    rf12ef239 rd8134178  
    11/**
    2  *  @file  rtems/score/rbtree.inl
    3  *
    4  *  This include file contains the bodies of the routines which are
    5  *  associated with Red-Black Trees and inlined.
    6  *
    7  *  @note  The routines in this file are ordered from simple
    8  *         to complex.  No other RBTree Handler routine is referenced
    9  *         unless it has already been defined.
     2 * @file
     3 *
     4 * @brief Inlined Routines Associated with Red-Black Trees
     5 *
     6 * This include file contains the bodies of the routines which are
     7 * associated with Red-Black Trees and inlined.
     8 *
     9 * @note  The routines in this file are ordered from simple
     10 *        to complex.  No other RBTree Handler routine is referenced
     11 *        unless it has already been defined.
    1012 */
    1113
     
    2628
    2729/**
    28  *  @addtogroup ScoreRBTree
    29  *  @{
    30  */
    31 
    32 /**
    33  * @brief Get the direction opposite to @a the_dir
     30 * @addtogroup ScoreRBTree
     31 *
     32 * @{
     33 */
     34
     35/**
     36 * @brief Get the direction opposite to @a the_dir.
    3437 */
    3538RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
     
    4043}
    4144
    42 /** @brief Set off rbtree
    43  *
    44  *  This function sets the parent and child fields of the @a node to NULL
    45  *  indicating the @a node is not part of a rbtree.
     45/**
     46 * @brief Set off RBtree.
     47 *
     48 * This function sets the parent and child fields of the @a node to NULL
     49 * indicating the @a node is not part of a rbtree.
    4650 *
    4751 */
     
    5357}
    5458
    55 /** @brief Is the Node off RBTree
    56  *
    57  *  This function returns true if the @a node is not on a rbtree. A @a node is
    58  *  off rbtree if the parent and child fields are set to NULL.
     59/**
     60 * @brief Is the node off RBTree.
     61 *
     62 * This function returns true if the @a node is not on a rbtree. A @a node is
     63 * off rbtree if the parent and child fields are set to NULL.
    5964 */
    6065RTEMS_INLINE_ROUTINE bool _RBTree_Is_node_off_rbtree(
     
    6570}
    6671
    67 /** @brief Are Two Nodes Equal
    68  *
    69  *  This function returns true if @a left and @a right are equal,
    70  *  and false otherwise.
     72/**
     73 * @brief Are two Nodes equal.
     74 *
     75 * This function returns true if @a left and @a right are equal,
     76 * and false otherwise.
     77 *
     78 * @retval true @a left and @a right are equal.
     79 * @retval false @a left and @a right are not equal.
    7180 */
    7281RTEMS_INLINE_ROUTINE bool _RBTree_Are_nodes_equal(
     
    7887}
    7988
    80 /** @brief Is this RBTree Control Pointer Null
    81  *
    82  *  This function returns true if @a the_rbtree is NULL and false otherwise.
     89/**
     90 * @brief Is this RBTree control pointer NULL.
     91 *
     92 * This function returns true if @a the_rbtree is NULL and false otherwise.
     93 *
     94 * @retval true @a the_rbtree is @c NULL.
     95 * @retval false @a the_rbtree is not @c NULL.
    8396 */
    8497RTEMS_INLINE_ROUTINE bool _RBTree_Is_null(
     
    89102}
    90103
    91 /** @brief Is the RBTree Node Pointer NULL
    92  *
    93  *  This function returns true if @a the_node is NULL and false otherwise.
     104/**
     105 * @brief Is the RBTree node pointer NUL.
     106 *
     107 * This function returns true if @a the_node is NULL and false otherwise.
     108 *
     109 * @retval true @a the_node is @c NULL.
     110 * @retval false @a the_node is not @c NULL.
    94111 */
    95112RTEMS_INLINE_ROUTINE bool _RBTree_Is_null_node(
     
    101118
    102119
    103 /** @brief Return pointer to RBTree's root node
    104  *
    105  *  This function returns a pointer to the root node of @a the_rbtree.
     120/**
     121 * @brief Return pointer to RBTree's root node.
     122 *
     123 * This function returns a pointer to the root node of @a the_rbtree.
    106124 */
    107125RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Root(
     
    112130}
    113131
    114 /** @brief Return pointer to RBTree's First node
    115  *
    116  *  This function returns a pointer to the first node on @a the_rbtree,
    117  *  where @a dir specifies whether to return the minimum (0) or maximum (1).
     132/**
     133 * @brief Return pointer to RBTree's first node.
     134 *
     135 * This function returns a pointer to the first node on @a the_rbtree,
     136 * where @a dir specifies whether to return the minimum (0) or maximum (1).
    118137 */
    119138RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
     
    125144}
    126145
    127 /** @brief Return pointer to the parent of this node
    128  *
    129  *  This function returns a pointer to the parent node of @a the_node.
     146/**
     147 * @brief Return pointer to the parent of this node.
     148 *
     149 * This function returns a pointer to the parent node of @a the_node.
    130150 */
    131151RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
     
    137157}
    138158
    139 /** @brief Return pointer to the left of this node
    140  *
    141  *  This function returns a pointer to the left node of this node.
    142  *
    143  *  @param[in] the_node is the node to be operated upon.
    144  *
    145  *  @return This method returns the left node on the rbtree.
     159/**
     160 * @brief Return pointer to the left of this node.
     161 *
     162 * This function returns a pointer to the left node of this node.
     163 *
     164 * @param[in] the_node is the node to be operated upon.
     165 *
     166 * @return This method returns the left node on the rbtree.
    146167 */
    147168RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Left(
     
    152173}
    153174
    154 /** @brief Return pointer to the right of this node
    155  *
    156  *  This function returns a pointer to the right node of this node.
    157  *
    158  *  @param[in] the_node is the node to be operated upon.
    159  *
    160  *  @return This method returns the right node on the rbtree.
     175/**
     176 * @brief Return pointer to the right of this node.
     177 *
     178 * This function returns a pointer to the right node of this node.
     179 *
     180 * @param[in] the_node is the node to be operated upon.
     181 *
     182 * @return This method returns the right node on the rbtree.
    161183 */
    162184RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Right(
     
    167189}
    168190
    169 /** @brief Is the RBTree Empty
    170  *
    171  *  This function returns true if there are no nodes on @a the_rbtree and
    172  *  false otherwise.
    173  *
    174  *  @param[in] the_rbtree is the rbtree to be operated upon.
    175  *
    176  *  @return This function returns true if there are no nodes on
    177  *  @a the_rbtree and false otherwise.
     191/**
     192 * @brief Is the RBTree empty.
     193 *
     194 * This function returns true if there are no nodes on @a the_rbtree and
     195 * false otherwise.
     196 *
     197 * @param[in] the_rbtree is the rbtree to be operated upon.
     198 *
     199 * @retval true There are no nodes on @a the_rbtree.
     200 * @retval false There are nodes on @a the_rbtree.
    178201 */
    179202RTEMS_INLINE_ROUTINE bool _RBTree_Is_empty(
     
    184207}
    185208
    186 /** @brief Is this the First Node on the RBTree
    187  *
    188  *  This function returns true if @a the_node is the first node on
    189  *  @a the_rbtree and false otherwise. @a dir specifies whether first means
    190  *  minimum (0) or maximum (1).
     209/**
     210 * @brief Is this the first node on the RBTree.
     211 *
     212 * This function returns true if @a the_node is the first node on
     213 * @a the_rbtree and false otherwise. @a dir specifies whether first means
     214 * minimum (0) or maximum (1).
     215 *
     216 * @retval true @a the_node is the first node on @a the_rbtree.
     217 * @retval false @a the_node is not the first node on @a the_rbtree.
    191218 *
    192219 */
     
    200227}
    201228
    202 /** @brief Is this node red?
    203  *
    204  *  This function returns true if @a the_node is red and false otherwise.
     229/**
     230 * @brief Is this node red.
     231 *
     232 * This function returns true if @a the_node is red and false otherwise.
     233 *
     234 * @retval true @a the_node is red.
     235 * @retval false @a the_node in not red.
    205236 */
    206237RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
     
    212243
    213244
    214 /** @brief Does this RBTree have only One Node
    215  *
    216  *  This function returns true if there is only one node on @a the_rbtree and
    217  *  false otherwise.
    218  *
     245/**
     246 * @brief Does this RBTree have only one node.
     247 *
     248 * This function returns true if there is only one node on @a the_rbtree and
     249 * false otherwise.
     250 *
     251 * @retval true @a the_rbtree has only one node.
     252 * @retval false @a the_rbtree has more than one nodes.
    219253 */
    220254RTEMS_INLINE_ROUTINE bool _RBTree_Has_only_one_node(
     
    226260}
    227261
    228 /** @brief Is this Node the RBTree root
    229  *
    230  *  This function returns true if @a the_node is the root of @a the_rbtree and
    231  *  false otherwise.
     262/**
     263 * @brief Is this node the RBTree root.
     264 *
     265 * This function returns true if @a the_node is the root of @a the_rbtree and
     266 * false otherwise.
     267 *
     268 * @retval true @a the_node is the root of @a the_rbtree.
     269 * @retval false @a the_node is not the root of @a the_rbtree.
    232270 */
    233271RTEMS_INLINE_ROUTINE bool _RBTree_Is_root(
     
    239277}
    240278
    241 /** @brief Initialize this RBTree as Empty
    242  *
    243  *  This routine initializes @a the_rbtree to contain zero nodes.
     279/**
     280 * @brief Initialize this RBTree as empty.
     281 *
     282 * This routine initializes @a the_rbtree to contain zero nodes.
    244283 */
    245284RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
     
    257296}
    258297
    259 /** @brief Return a pointer to node's grandparent
    260  *
    261  *  This function returns a pointer to the grandparent of @a the_node if it
    262  *  exists, and NULL if not.
    263  *  
     298/**
     299 * @brief Return a pointer to node's grandparent.
     300 *
     301 * This function returns a pointer to the grandparent of @a the_node if it
     302 * exists, and NULL if not.
    264303 */
    265304RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Grandparent(
     
    274313}
    275314
    276 /** @brief Return a pointer to node's sibling
    277  *
    278  *  This function returns a pointer to the sibling of @a the_node if it
    279  *  exists, and NULL if not.
     315/**
     316 * @brief Return a pointer to node's sibling.
     317 *
     318 * This function returns a pointer to the sibling of @a the_node if it
     319 * exists, and NULL if not.
    280320 */
    281321RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
     
    293333}
    294334
    295 /** @brief Return a pointer to node's parent's sibling
    296  *
    297  *  This function returns a pointer to the sibling of the parent of
    298  *  @a the_node if it exists, and NULL if not.
     335/**
     336 * @brief Return a pointer to node's parent's sibling.
     337 *
     338 * This function returns a pointer to the sibling of the parent of
     339 * @a the_node if it exists, and NULL if not.
    299340 */
    300341RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent_sibling(
     
    308349}
    309350
    310 /** @brief Find the RBTree_Control header given a node in the tree
    311  *
    312  *  This function returns a pointer to the header of the Red Black
    313  *  Tree containing @a the_node if it exists, and NULL if not.
     351/**
     352 * @brief Find the RBTree_Control header given a node in the tree.
     353 *
     354 * This function returns a pointer to the header of the Red Black
     355 * Tree containing @a the_node if it exists, and NULL if not.
    314356 */
    315357RTEMS_INLINE_ROUTINE RBTree_Control *_RBTree_Find_header_unprotected(
     
    345387 * @brief Returns the predecessor of a node.
    346388 *
    347  * @param[in] rbtree The red-black tree.
    348  * @param[in] node The node.
     389 * @param[in] rbtree is the red-black tree.
     390 * @param[in] node is the node.
    349391 *
    350392 * @retval NULL The predecessor does not exist.
     
    373415 * @brief Returns the successor of a node.
    374416 *
    375  * @param[in] rbtree The red-black tree.
    376  * @param[in] node The node.
     417 * @param[in] rbtree is the red-black tree.
     418 * @param[in] node is the node.
    377419 *
    378420 * @retval NULL The successor does not exist.
     
    398440}
    399441
    400 /** @brief Get the First Node (unprotected)
    401  *
    402  *  This function removes the minimum or maximum node from the_rbtree and
    403  *  returns a pointer to that node.  It does NOT disable interrupts to ensure
    404  *  the atomicity of the get operation.
    405  *
    406  *  @param[in] the_rbtree is the rbtree to attempt to get the min node from.
    407  *  @param[in] dir specifies whether to get minimum (0) or maximum (1)
    408  *
    409  *  @return This method returns the min or max node on the rbtree, or NULL.
    410  *
    411  *  @note This routine may return NULL if the RBTree is empty.
     442/**
     443 * @brief Get the first node (unprotected).
     444 *
     445 * This function removes the minimum or maximum node from the_rbtree and
     446 * returns a pointer to that node.  It does NOT disable interrupts to ensure
     447 * the atomicity of the get operation.
     448 *
     449 * @param[in] the_rbtree is the rbtree to attempt to get the min node from.
     450 * @param[in] dir specifies whether to get minimum (0) or maximum (1)
     451 *
     452 * @return This method returns the min or max node on the rbtree, or NULL.
     453 *
     454 * @note This routine may return NULL if the RBTree is empty.
    412455 */
    413456RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Get_unprotected(
     
    421464}
    422465
    423 /** @brief Rotate the_node in the direction passed as second argument
    424  * 
    425  *  This routine rotates @a the_node to the direction @a dir, swapping
    426  *  @a the_node with its child\[@a dir\].
     466/**
     467 * @brief Rotate the_node in the direction passed as second argument.
     468 *
     469 * This routine rotates @a the_node to the direction @a dir, swapping
     470 * @a the_node with its child\[@a dir\].
    427471 */
    428472RTEMS_INLINE_ROUTINE void _RBTree_Rotate(
     
    449493}
    450494
    451 /** @brief Determines whether the tree is unique
     495/**
     496 * @brief Determines whether the tree is unique.
    452497 */
    453498RTEMS_INLINE_ROUTINE bool _RBTree_Is_unique(
     
    457502  return( the_rbtree && the_rbtree->is_unique );
    458503}
    459 /**@}*/
     504
     505/** @} */
    460506
    461507#endif
  • cpukit/score/inline/rtems/score/schedulerpriority.inl

    rf12ef239 rd8134178  
    1 /**
    2  *  @file  rtems/score/schedulerpriority.inl
    3  *
    4  *  This inline file contains all of the inlined routines associated with
    5  *  the manipulation of the priority-based scheduling structures.
     1/**
     2 * @file
     3 *
     4 * @brief Inlined Routines Associated with the Manipulation of the
     5 * Priority-Based Scheduling Structures
     6 *
     7 * This inline file contains all of the inlined routines associated with
     8 * the manipulation of the priority-based scheduling structures.
    69 */
    710
     
    2528
    2629/**
    27  *  @addtogroup ScoreScheduler
     30 * @addtogroup ScoreScheduler
     31 *
    2832 * @{
    2933 */
    3034
    31 /** @brief  Scheduler priority Ready queue initialize
    32  *
    33  *  This routine initializes @a the_ready_queue for priority-based scheduling.
     35/**
     36 * @brief Ready queue initialization.
     37 *
     38 * This routine initializes @a the_ready_queue for priority-based scheduling.
    3439 */
    3540RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_initialize(void)
     
    5055
    5156/**
    52  *  @brief _Scheduler_priority_Ready_queue_enqueue
    53  *
    54  *  This routine puts @a the_thread on to the priority-based ready queue.
    55  * 
    56  *  @param[in] the_thread  - pointer to thread
     57 * @brief Put a thread to the ready queue.
     58 *
     59 * This routine puts @a the_thread on to the priority-based ready queue.
     60 *
     61 * @param[in] the_thread is a pointer to the thread
    5762 */
    5863RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
     
    6772
    6873  _Priority_bit_map_Add( &sched_info->Priority_map );
    69  
     74
    7075  _Chain_Append_unprotected( ready, &the_thread->Object.Node );
    7176}
    7277
    7378/**
    74  *  @brief _Scheduler_priority_Ready_queue_Enqueue_first
    75  *
    76  *  This routine puts @a the_thread to the head of the ready queue.
    77  *  For priority-based ready queues, the thread will be the first thread
    78  *  at its priority level.
    79  * 
    80  *  @param[in] the_thread  - pointer to thread
     79 * @brief Put a thread to the head of the ready queue.
     80 *
     81 * This routine puts @a the_thread to the head of the ready queue.
     82 * For priority-based ready queues, the thread will be the first thread
     83 * at its priority level.
     84 *
     85 * @param[in] the_thread is a pointer to the thread.
    8186 */
    8287RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first(
     
    97102
    98103/**
    99  *  @brief _Scheduler_priority_Ready_queue_extract
    100  *
    101  *  This routine removes a specific thread from the specified
    102  *  priority-based ready queue.
    103  *
    104  *  @param[in] the_thread  - pointer to thread
     104 * @brief Remove a specific thread from the ready queue.
     105 *
     106 * This routine removes a specific thread from the specified
     107 * priority-based ready queue.
     108 *
     109 * @param[in] the_thread is a pointer to the thread.
    105110 */
    106111RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract(
     
    123128
    124129/**
    125  *  @brief _Scheduler_priority_Ready_queue_first
    126  *
    127  *  This routines returns a pointer to the first thread on @a the_ready_queue.
    128  *
    129  *  @param[in] the_ready_queue - pointer to thread queue
    130  *
    131  *  @return This method returns the first thread or NULL
     130 * @brief Return a pointer to the first thread.
     131 *
     132 * This routines returns a pointer to the first thread on @a the_ready_queue.
     133 *
     134 * @param[in] the_ready_queue - pointer to thread queue
     135 *
     136 * @return This method returns the first thread or NULL
    132137 */
    133138RTEMS_INLINE_ROUTINE Thread_Control *_Scheduler_priority_Ready_queue_first(
     
    144149
    145150/**
    146  *  @brief _Scheduler_priority_Ready_queue_requeue
    147  *
    148  *  This routine is invoked when a thread changes priority and should be
    149  *  moved to a different position on the ready queue.
    150  *
    151  *  @param[in] the_thread  - pointer to thread
     151 * @brief Requeue a thread on the ready queue.
     152 *
     153 * This routine is invoked when a thread changes priority and should be
     154 * moved to a different position on the ready queue.
     155 *
     156 * @param[in] the_thread is a pointer to the thread
    152157 */
    153158RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_requeue(
     
    163168
    164169    _Chain_Append_unprotected(
    165       sched_info->ready_chain, 
     170      sched_info->ready_chain,
    166171      &the_thread->Object.Node
    167172    );
     
    170175
    171176/**
    172  *  @brief _Scheduler_priority_Schedule_body
    173  *
    174  *  This kernel routine implements scheduling decision logic
    175  *  for priority-based scheduling. 
    176  *
    177  *  @param[in] the_thread  - pointer to thread
     177 * @brief Scheduling decision logic.
     178 *
     179 * This kernel routine implements scheduling decision logic
     180 * for priority-based scheduling.
    178181 */
    179182RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
     
    185188
    186189/**
    187  *  @brief Scheduler priority Priority compare body
    188  *
    189  *  This routine implements priority comparison for priority-based
    190  *  scheduling.
    191  *
    192  *  @return >0 for higher priority, 0 for equal and <0 for lower priority.
     190 * @brief Priority comparison.
     191 *
     192 * This routine implements priority comparison for priority-based
     193 * scheduling.
     194 *
     195 * @return >0 for higher priority, 0 for equal and <0 for lower priority.
    193196 */
    194197RTEMS_INLINE_ROUTINE int _Scheduler_priority_Priority_compare_body(
     
    201204}
    202205
    203 /**@}*/
     206/** @} */
    204207
    205208#endif
  • cpukit/score/inline/rtems/score/schedulersimple.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/schedulersimple.inl
     1/**
     2 * @file
    33 *
    4  *  This inline file contains all of the inlined routines associated with
    5  *  the manipulation of the priority-based scheduling structures.
     4 * @brief Inlined Routines Associated with the Manipulation of the
     5 * Priority-Based Scheduling Structures
     6 *
     7 * This inline file contains all of the inlined routines associated with
     8 * the manipulation of the priority-based scheduling structures.
    69 */
    710
     
    2427
    2528/**
    26  *  @addtogroup ScoreScheduler
     29 * @addtogroup ScoreScheduler
     30 *
    2731 * @{
    2832 */
    2933
    3034/**
    31  *  This routine puts @a the_thread on to the ready queue.
     35 * This routine puts @a the_thread on to the ready queue.
    3236 *
    33  *  @param[in] the_ready_queue is a pointer to the ready queue head
    34  *  @param[in] the_thread is the thread to be blocked
     37 * @param[in] the_ready_queue is a pointer to the ready queue head
     38 * @param[in] the_thread is the thread to be blocked
    3539 */
    3640RTEMS_INLINE_ROUTINE void _Scheduler_simple_Ready_queue_requeue(
     
    4650}
    4751
    48 /**@}*/
     52/** @} */
    4953
    5054#endif
  • cpukit/score/inline/rtems/score/threadmp.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/threadmp.inl
     1/**
     2 * @file
    33 *
    4  *  This include file contains the bodies of all inlined routines
    5  *  for the multiprocessing part of thread package.
     4 * @brief Inlined Routines for the Multiprocessing part of Thread Package
     5 *
     6 * This include file contains the bodies of all inlined routines
     7 * for the multiprocessing part of thread package.
    68 */
    79
     
    2527
    2628/**
    27  *  @addtogroup ScoreThreadMP
    28  *  @{
     29 * @addtogroup ScoreThreadMP
     30 *
     31 * @{
    2932 */
    3033
    3134/**
    32  *  This function returns true if the thread in question is the
    33  *  multiprocessing receive thread.
     35 * This function returns true if the thread in question is the
     36 * multiprocessing receive thread.
    3437 *
    35  *  @note This is a macro to avoid needing a prototype for
    36  *        _MPCI_Receive_server_tcb until it is used.
     38 * @note This is a macro to avoid needing a prototype for
     39 *       _MPCI_Receive_server_tcb until it is used.
    3740 */
    3841#define _Thread_MP_Is_receive(_the_thread) \
     
    4043
    4144/**
    42  *  This routine frees a proxy control block to the
    43  *  inactive chain of free proxy control blocks.
     45 * This routine frees a proxy control block to the
     46 * inactive chain of free proxy control blocks.
    4447 */
    4548
     
    5760}
    5861
    59 /**@}*/
     62/** @} */
    6063
    6164#endif
  • cpukit/score/inline/rtems/score/threadq.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/threadq.inl
     1/**
     2 * @file
    33 *
    4  *  This inline file contains all of the inlined routines associated with
    5  *  the manipulation of thread queues.
     4 * @brief Inlined Routines Associated with the Manipulation of Thread Queues
     5 *
     6 * This inline file contains all of the inlined routines associated with
     7 * the manipulation of thread queues.
    68 */
    79
     
    2527
    2628/**
    27  *  @addtogroup ScoreThreadQ
     29 * @addtogroup ScoreThreadQ
     30 *
    2831 * @{
    2932 */
    3033
    31 /**@}*/
     34/** @} */
    3235
    3336#endif
  • cpukit/score/inline/rtems/score/watchdog.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/watchdog.inl
     1/**
     2 * @file
    33 *
    4  *  This file contains the static inline implementation of all inlined
    5  *  routines in the Watchdog Handler.
     4 * @brief Inlined Routines in the Watchdog Handler
     5 *
     6 * This file contains the static inline implementation of all inlined
     7 * routines in the Watchdog Handler.
    68 */
    79
     
    2325
    2426/**
    25  *  @addtogroup ScoreWatchdog 
     27 *  @addtogroup ScoreWatchdog
    2628 *  @{
    2729 */
    2830
    2931/**
    30  *  This routine initializes the specified watchdog.  The watchdog is
    31  *  made inactive, the watchdog id and handler routine are set to the
    32  *  specified values.
     32 * This routine initializes the specified watchdog.  The watchdog is
     33 * made inactive, the watchdog id and handler routine are set to the
     34 * specified values.
    3335 */
    3436
     
    4749
    4850/**
    49  *  This routine returns true if the watchdog timer is in the ACTIVE
    50  *  state, and false otherwise.
     51 * This routine returns true if the watchdog timer is in the ACTIVE
     52 * state, and false otherwise.
    5153 */
    5254
     
    6163
    6264/**
    63  *  This routine activates THE_WATCHDOG timer which is already
    64  *  on a watchdog chain.
     65 * This routine activates THE_WATCHDOG timer which is already
     66 * on a watchdog chain.
    6567 */
    6668
     
    7577
    7678/**
    77  *  This routine deactivates THE_WATCHDOG timer which will remain
    78  *  on a watchdog chain.
     79 * This routine deactivates THE_WATCHDOG timer which will remain
     80 * on a watchdog chain.
    7981 */
    8082
     
    8991
    9092/**
    91  *  This routine is invoked at each clock tick to update the ticks
    92  *  watchdog chain.
     93 * This routine is invoked at each clock tick to update the ticks
     94 * watchdog chain.
    9395 */
    9496
     
    101103
    102104/**
    103  *  This routine is invoked at each clock tick to update the seconds
    104  *  watchdog chain.
     105 * This routine is invoked at each clock tick to update the seconds
     106 * watchdog chain.
    105107 */
    106108
     
    113115
    114116/**
    115  *  This routine inserts THE_WATCHDOG into the ticks watchdog chain
    116  *  for a time of UNITS ticks.  The INSERT_MODE indicates whether
    117  *  THE_WATCHDOG is to be activated automatically or later, explicitly
    118  *  by the caller.
     117 * This routine inserts THE_WATCHDOG into the ticks watchdog chain
     118 * for a time of UNITS ticks.  The INSERT_MODE indicates whether
     119 * THE_WATCHDOG is to be activated automatically or later, explicitly
     120 * by the caller.
    119121 */
    120122
     
    132134
    133135/**
    134  *  This routine inserts THE_WATCHDOG into the seconds watchdog chain
    135  *  for a time of UNITS seconds.  The INSERT_MODE indicates whether
    136  *  THE_WATCHDOG is to be activated automatically or later, explicitly
    137  *  by the caller.
     136 * This routine inserts THE_WATCHDOG into the seconds watchdog chain
     137 * for a time of UNITS seconds.  The INSERT_MODE indicates whether
     138 * THE_WATCHDOG is to be activated automatically or later, explicitly
     139 * by the caller.
    138140 */
    139141
     
    151153
    152154/**
    153  *  This routine adjusts the seconds watchdog chain in the forward
    154  *  or backward DIRECTION for UNITS seconds.  This is invoked when the
    155  *  current time of day is changed.
     155 * This routine adjusts the seconds watchdog chain in the forward
     156 * or backward DIRECTION for UNITS seconds.  This is invoked when the
     157 * current time of day is changed.
    156158 */
    157159
     
    167169
    168170/**
    169  *  This routine adjusts the ticks watchdog chain in the forward
    170  *  or backward DIRECTION for UNITS ticks.
     171 * This routine adjusts the ticks watchdog chain in the forward
     172 * or backward DIRECTION for UNITS ticks.
    171173 */
    172174
     
    182184
    183185/**
    184  *  This routine resets THE_WATCHDOG timer to its state at INSERT
    185  *  time.  This routine is valid only on interval watchdog timers
    186  *  and is used to make an interval watchdog timer fire "every" so
    187  *  many ticks.
     186 * This routine resets THE_WATCHDOG timer to its state at INSERT
     187 * time.  This routine is valid only on interval watchdog timers
     188 * and is used to make an interval watchdog timer fire "every" so
     189 * many ticks.
    188190 */
    189191
     
    200202
    201203/**
    202  *  This routine returns a pointer to the watchdog timer following
    203  *  THE_WATCHDOG on the watchdog chain.
     204 * This routine returns a pointer to the watchdog timer following
     205 * THE_WATCHDOG on the watchdog chain.
    204206 */
    205207
     
    214216
    215217/**
    216  *  This routine returns a pointer to the watchdog timer preceding
    217  *  THE_WATCHDOG on the watchdog chain.
     218 * This routine returns a pointer to the watchdog timer preceding
     219 * THE_WATCHDOG on the watchdog chain.
    218220 */
    219221
     
    228230
    229231/**
    230  *  This routine returns a pointer to the first watchdog timer
    231  *  on the watchdog chain HEADER.
     232 * This routine returns a pointer to the first watchdog timer
     233 * on the watchdog chain HEADER.
    232234 */
    233235
     
    242244
    243245/**
    244  *  This routine returns a pointer to the last watchdog timer
    245  *  on the watchdog chain HEADER.
     246 * This routine returns a pointer to the last watchdog timer
     247 * on the watchdog chain HEADER.
    246248 */
    247249
     
    255257}
    256258
    257 /**@}*/
     259/** @} */
    258260
    259261#endif
  • cpukit/score/inline/rtems/score/wkspace.inl

    rf12ef239 rd8134178  
    1 /** 
    2  *  @file  rtems/score/wkspace.inl
     1/**
     2 * @file
    33 *
    4  *  This include file contains the bodies of the routines which contains
    5  *  information related to the RAM Workspace.
     4 * @brief Inlined Routines Associated with the RAM Workspace
     5 *
     6 * This include file contains the bodies of the routines which contains
     7 * information related to the RAM Workspace.
    68 */
    79
     
    2325
    2426/**
    25  *  @addtogroup ScoreWorkspace
     27 *  @addtogroup ScoreWorkspace
     28 *
    2629 *  @{
    2730 */
    2831
    29 /**@}*/
     32/** @} */
    3033
    3134#endif
Note: See TracChangeset for help on using the changeset viewer.