git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/component/lists/generic_list.c

   1 /*\r
   2  * Copyright 2018 NXP\r
   3  * All rights reserved.\r
   4  *\r
   5  *\r
   6  * SPDX-License-Identifier: BSD-3-Clause\r
   7  */\r
   8 \r
   9 /*! *********************************************************************************\r
  10 *************************************************************************************\r
  11 * Include\r
  12 *************************************************************************************\r
  13 ********************************************************************************** */\r
  14 #include "fsl_common.h"\r
  15 #include "generic_list.h"\r
  16 \r
  17 /*! *********************************************************************************\r
  18 *************************************************************************************\r
  19 * Public functions\r
  20 *************************************************************************************\r
  21 ********************************************************************************** */\r
  22 /*! *********************************************************************************\r
  23 * \brief     Initialises the list descriptor.\r
  24 *\r
  25 * \param[in] list - LIST_ handle to init.\r
  26 *            max - Maximum number of elements in list. 0 for unlimited.\r
  27 *\r
  28 * \return void.\r
  29 *\r
  30 * \pre\r
  31 *\r
  32 * \post\r
  33 *\r
  34 * \remarks\r
  35 *\r
  36 ********************************************************************************** */\r
  37 void LIST_Init(list_handle_t list, uint32_t max)\r
  38 {\r
  39     list->head = NULL;\r
  40     list->tail = NULL;\r
  41     list->max = max;\r
  42     list->size = 0;\r
  43 }\r
  44 \r
  45 /*! *********************************************************************************\r
  46 * \brief     Gets the list that contains the given element.\r
  47 *\r
  48 * \param[in] element - Handle of the element.\r
  49 *\r
  50 * \return NULL if element is orphan.\r
  51 *         Handle of the list the element is inserted into.\r
  52 *\r
  53 * \pre\r
  54 *\r
  55 * \post\r
  56 *\r
  57 * \remarks\r
  58 *\r
  59 ********************************************************************************** */\r
  60 list_handle_t LIST_GetList(list_element_handle_t element)\r
  61 {\r
  62     return element->list;\r
  63 }\r
  64 \r
  65 /*! *********************************************************************************\r
  66 * \brief     Links element to the tail of the list.\r
  67 *\r
  68 * \param[in] list - ID of list to insert into.\r
  69 *            element - element to add\r
  70 *\r
  71 * \return kLIST_Full if list is full.\r
  72 *         kLIST_Ok if insertion was successful.\r
  73 *\r
  74 * \pre\r
  75 *\r
  76 * \post\r
  77 *\r
  78 * \remarks\r
  79 *\r
  80 ********************************************************************************** */\r
  81 list_status_t LIST_AddTail(list_handle_t list, list_element_handle_t element)\r
  82 {\r
  83     uint32_t regPrimask = DisableGlobalIRQ();\r
  84 \r
  85     if ((list->max != 0) && (list->max == list->size))\r
  86     {\r
  87         EnableGlobalIRQ(regPrimask);\r
  88         return kLIST_Full;\r
  89     }\r
  90 \r
  91     if (list->size == 0)\r
  92     {\r
  93         list->head = element;\r
  94     }\r
  95     else\r
  96     {\r
  97         list->tail->next = element;\r
  98     }\r
  99     element->prev = list->tail;\r
 100     element->next = NULL;\r
 101     element->list = list;\r
 102     list->tail = element;\r
 103     list->size++;\r
 104 \r
 105     EnableGlobalIRQ(regPrimask);\r
 106     return kLIST_Ok;\r
 107 }\r
 108 \r
 109 /*! *********************************************************************************\r
 110 * \brief     Links element to the head of the list.\r
 111 *\r
 112 * \param[in] list - ID of list to insert into.\r
 113 *            element - element to add\r
 114 *\r
 115 * \return kLIST_Full if list is full.\r
 116 *         kLIST_Ok if insertion was successful.\r
 117 *\r
 118 * \pre\r
 119 *\r
 120 * \post\r
 121 *\r
 122 * \remarks\r
 123 *\r
 124 ********************************************************************************** */\r
 125 list_status_t LIST_AddHead(list_handle_t list, list_element_handle_t element)\r
 126 {\r
 127     uint32_t regPrimask = DisableGlobalIRQ();\r
 128 \r
 129     if ((list->max != 0) && (list->max == list->size))\r
 130     {\r
 131         EnableGlobalIRQ(regPrimask);\r
 132         return kLIST_Full;\r
 133     }\r
 134 \r
 135     if (list->size == 0)\r
 136     {\r
 137         list->tail = element;\r
 138     }\r
 139     else\r
 140     {\r
 141         list->head->prev = element;\r
 142     }\r
 143     element->next = list->head;\r
 144     element->prev = NULL;\r
 145     element->list = list;\r
 146     list->head = element;\r
 147     list->size++;\r
 148 \r
 149     EnableGlobalIRQ(regPrimask);\r
 150     return kLIST_Ok;\r
 151 }\r
 152 \r
 153 /*! *********************************************************************************\r
 154 * \brief     Unlinks element from the head of the list.\r
 155 *\r
 156 * \param[in] list - ID of list to remove from.\r
 157 *\r
 158 * \return NULL if list is empty.\r
 159 *         ID of removed element(pointer) if removal was successful.\r
 160 *\r
 161 * \pre\r
 162 *\r
 163 * \post\r
 164 *\r
 165 * \remarks\r
 166 *\r
 167 ********************************************************************************** */\r
 168 list_element_handle_t LIST_RemoveHead(list_handle_t list)\r
 169 {\r
 170     list_element_handle_t element;\r
 171 \r
 172     uint32_t regPrimask = DisableGlobalIRQ();\r
 173 \r
 174     if ((NULL == list) || (list->size == 0))\r
 175     {\r
 176         EnableGlobalIRQ(regPrimask);\r
 177         return NULL; /*LIST_ is empty*/\r
 178     }\r
 179 \r
 180     element = list->head;\r
 181     list->size--;\r
 182     if (list->size == 0)\r
 183     {\r
 184         list->tail = NULL;\r
 185     }\r
 186     else\r
 187     {\r
 188         element->next->prev = NULL;\r
 189     }\r
 190     list->head = element->next; /*Is NULL if element is head*/\r
 191     element->list = NULL;\r
 192 \r
 193     EnableGlobalIRQ(regPrimask);\r
 194     return element;\r
 195 }\r
 196 \r
 197 /*! *********************************************************************************\r
 198 * \brief     Gets head element ID.\r
 199 *\r
 200 * \param[in] list - ID of list.\r
 201 *\r
 202 * \return NULL if list is empty.\r
 203 *         ID of head element if list is not empty.\r
 204 *\r
 205 * \pre\r
 206 *\r
 207 * \post\r
 208 *\r
 209 * \remarks\r
 210 *\r
 211 ********************************************************************************** */\r
 212 list_element_handle_t LIST_GetHead(list_handle_t list)\r
 213 {\r
 214     return list->head;\r
 215 }\r
 216 \r
 217 /*! *********************************************************************************\r
 218 * \brief     Gets next element ID.\r
 219 *\r
 220 * \param[in] element - ID of the element.\r
 221 *\r
 222 * \return NULL if element is tail.\r
 223 *         ID of next element if exists.\r
 224 *\r
 225 * \pre\r
 226 *\r
 227 * \post\r
 228 *\r
 229 * \remarks\r
 230 *\r
 231 ********************************************************************************** */\r
 232 list_element_handle_t LIST_GetNext(list_element_handle_t element)\r
 233 {\r
 234     return element->next;\r
 235 }\r
 236 \r
 237 /*! *********************************************************************************\r
 238 * \brief     Gets previous element ID.\r
 239 *\r
 240 * \param[in] element - ID of the element.\r
 241 *\r
 242 * \return NULL if element is head.\r
 243 *         ID of previous element if exists.\r
 244 *\r
 245 * \pre\r
 246 *\r
 247 * \post\r
 248 *\r
 249 * \remarks\r
 250 *\r
 251 ********************************************************************************** */\r
 252 list_element_handle_t LIST_GetPrev(list_element_handle_t element)\r
 253 {\r
 254     return element->prev;\r
 255 }\r
 256 \r
 257 /*! *********************************************************************************\r
 258 * \brief     Unlinks an element from its list.\r
 259 *\r
 260 * \param[in] element - ID of the element to remove.\r
 261 *\r
 262 * \return kLIST_OrphanElement if element is not part of any list.\r
 263 *         kLIST_Ok if removal was successful.\r
 264 *\r
 265 * \pre\r
 266 *\r
 267 * \post\r
 268 *\r
 269 * \remarks\r
 270 *\r
 271 ********************************************************************************** */\r
 272 list_status_t LIST_RemoveElement(list_element_handle_t element)\r
 273 {\r
 274     if (element->list == NULL)\r
 275     {\r
 276         return kLIST_OrphanElement; /*Element was previusly removed or never added*/\r
 277     }\r
 278 \r
 279     uint32_t regPrimask = DisableGlobalIRQ();\r
 280 \r
 281     if (element->prev == NULL) /*Element is head or solo*/\r
 282     {\r
 283         element->list->head = element->next; /*is null if solo*/\r
 284     }\r
 285     if (element->next == NULL) /*Element is tail or solo*/\r
 286     {\r
 287         element->list->tail = element->prev; /*is null if solo*/\r
 288     }\r
 289     if (element->prev != NULL) /*Element is not head*/\r
 290     {\r
 291         element->prev->next = element->next;\r
 292     }\r
 293     if (element->next != NULL) /*Element is not tail*/\r
 294     {\r
 295         element->next->prev = element->prev;\r
 296     }\r
 297     element->list->size--;\r
 298     element->list = NULL;\r
 299 \r
 300     EnableGlobalIRQ(regPrimask);\r
 301     return kLIST_Ok;\r
 302 }\r
 303 \r
 304 /*! *********************************************************************************\r
 305 * \brief     Links an element in the previous position relative to a given member\r
 306 *            of a list.\r
 307 *\r
 308 * \param[in] element - ID of a member of a list.\r
 309 *            newElement - new element to insert before the given member.\r
 310 *\r
 311 * \return kLIST_OrphanElement if element is not part of any list.\r
 312 *         kLIST_Full if list is full.\r
 313 *         kLIST_Ok if insertion was successful.\r
 314 *\r
 315 * \pre\r
 316 *\r
 317 * \post\r
 318 *\r
 319 * \remarks\r
 320 *\r
 321 ********************************************************************************** */\r
 322 list_status_t LIST_AddPrevElement(list_element_handle_t element, list_element_handle_t newElement)\r
 323 {\r
 324     if (element->list == NULL)\r
 325     {\r
 326         return kLIST_OrphanElement; /*Element was previusly removed or never added*/\r
 327     }\r
 328     uint32_t regPrimask = DisableGlobalIRQ();\r
 329 \r
 330     if ((element->list->max != 0) && (element->list->max == element->list->size))\r
 331     {\r
 332         EnableGlobalIRQ(regPrimask);\r
 333         return kLIST_Full;\r
 334     }\r
 335 \r
 336     if (element->prev == NULL) /*Element is list head*/\r
 337     {\r
 338         element->list->head = newElement;\r
 339     }\r
 340     else\r
 341     {\r
 342         element->prev->next = newElement;\r
 343     }\r
 344     newElement->list = element->list;\r
 345     element->list->size++;\r
 346     newElement->next = element;\r
 347     newElement->prev = element->prev;\r
 348     element->prev = newElement;\r
 349 \r
 350     EnableGlobalIRQ(regPrimask);\r
 351     return kLIST_Ok;\r
 352 }\r
 353 \r
 354 /*! *********************************************************************************\r
 355 * \brief     Gets the current size of a list.\r
 356 *\r
 357 * \param[in] list - ID of the list.\r
 358 *\r
 359 * \return Current size of the list.\r
 360 *\r
 361 * \pre\r
 362 *\r
 363 * \post\r
 364 *\r
 365 * \remarks\r
 366 *\r
 367 ********************************************************************************** */\r
 368 uint32_t LIST_GetSize(list_handle_t list)\r
 369 {\r
 370     return list->size;\r
 371 }\r
 372 \r
 373 /*! *********************************************************************************\r
 374 * \brief     Gets the number of free places in the list.\r
 375 *\r
 376 * \param[in] list - ID of the list.\r
 377 *\r
 378 * \return Available size of the list.\r
 379 *\r
 380 * \pre\r
 381 *\r
 382 * \post\r
 383 *\r
 384 * \remarks\r
 385 *\r
 386 ********************************************************************************** */\r
 387 uint32_t LIST_GetAvailableSize(list_handle_t list)\r
 388 {\r
 389     return (list->max - list->size);\r
 390 }\r