Subversion Repositories AFRtranscoder

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2013-2017 ARM Limited. All rights reserved.
  3.  *
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  *
  6.  * Licensed under the Apache License, Version 2.0 (the License); you may
  7.  * not use this file except in compliance with the License.
  8.  * You may obtain a copy of the License at
  9.  *
  10.  * www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  14.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  *
  18.  * ----------------------------------------------------------------------
  19.  *
  20.  * $Date:        10. January 2017
  21.  * $Revision:    V1.2
  22.  *
  23.  * Project:      CMSIS-RTOS API V1
  24.  * Title:        cmsis_os_v1.c V1 module file
  25.  *---------------------------------------------------------------------------*/
  26.  
  27. #include <string.h>
  28. #include "cmsis_os.h"
  29.  
  30. #if (osCMSIS >= 0x20000U)
  31.  
  32.  
  33. // Thread
  34. osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument) {
  35.  
  36.   if (thread_def == NULL) {
  37.     return (osThreadId)NULL;
  38.   }
  39.   return osThreadNew((osThreadFunc_t)thread_def->pthread, argument, &thread_def->attr);
  40. }
  41.  
  42.  
  43. // Signals
  44.  
  45. #define SignalMask ((1U<<osFeature_Signals)-1U)
  46.  
  47. int32_t osSignalSet (osThreadId thread_id, int32_t signals) {
  48.   uint32_t flags;
  49.  
  50.   flags = osThreadFlagsSet(thread_id, (uint32_t)signals);
  51.   if ((flags & 0x80000000U) != 0U) {
  52.     return ((int32_t)0x80000000U);
  53.   }
  54.   return ((int32_t)(flags & ~((uint32_t)signals)));
  55. }
  56.  
  57. int32_t osSignalClear (osThreadId thread_id, int32_t signals) {
  58.   uint32_t flags;
  59.  
  60.   if (thread_id != osThreadGetId()) {
  61.     return ((int32_t)0x80000000U);
  62.   }
  63.   flags = osThreadFlagsClear((uint32_t)signals);
  64.   if ((flags & 0x80000000U) != 0U) {
  65.     return ((int32_t)0x80000000U);
  66.   }
  67.   return ((int32_t)flags);
  68. }
  69.  
  70. osEvent osSignalWait (int32_t signals, uint32_t millisec) {
  71.   osEvent  event;
  72.   uint32_t flags;
  73.  
  74.   if (signals != 0) {
  75.     flags = osThreadFlagsWait((uint32_t)signals, osFlagsWaitAll, millisec);
  76.   } else {
  77.     flags = osThreadFlagsWait(SignalMask,        osFlagsWaitAny, millisec);
  78.   }
  79.   if ((flags > 0U) && (flags < 0x80000000U)) {
  80.     event.status = osEventSignal;
  81.     event.value.signals = (int32_t)flags;
  82.   } else {
  83.     switch ((int32_t)flags) {
  84.       case osErrorResource:
  85.         event.status = osOK;
  86.         break;
  87.       case osErrorTimeout:
  88.         event.status = osEventTimeout;
  89.         break;
  90.       case osErrorParameter:
  91.         event.status = osErrorValue;
  92.         break;
  93.       default:
  94.         event.status = (osStatus)flags;
  95.         break;
  96.     }
  97.   }
  98.   return event;
  99. }
  100.  
  101.  
  102. // Timer
  103. osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument) {
  104.  
  105.   if (timer_def == NULL) {
  106.     return (osTimerId)NULL;
  107.   }
  108.   return osTimerNew((osTimerFunc_t)timer_def->ptimer, type, argument, &timer_def->attr);
  109. }
  110.  
  111.  
  112. // Mutex
  113. osMutexId osMutexCreate (const osMutexDef_t *mutex_def) {
  114.  
  115.   if (mutex_def == NULL) {
  116.     return (osMutexId)NULL;
  117.   }
  118.   return osMutexNew(mutex_def);
  119. }
  120.  
  121.  
  122. // Semaphore
  123.  
  124. #if (defined (osFeature_Semaphore) && (osFeature_Semaphore != 0U))
  125.  
  126. osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count) {
  127.  
  128.   if (semaphore_def == NULL) {
  129.     return (osSemaphoreId)NULL;
  130.   }
  131.   return osSemaphoreNew((uint32_t)count, (uint32_t)count, semaphore_def);
  132. }
  133.  
  134. int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec) {
  135.   osStatus_t status;
  136.   uint32_t   count;
  137.  
  138.   status = osSemaphoreAcquire(semaphore_id, millisec);
  139.   switch (status) {
  140.     case osOK:
  141.       count = osSemaphoreGetCount(semaphore_id);
  142.       return ((int32_t)count + 1);
  143.     case osErrorResource:
  144.     case osErrorTimeout:
  145.       return 0;
  146.     default:
  147.       break;
  148.   }
  149.   return -1;
  150. }
  151.  
  152. #endif  // Semaphore
  153.  
  154.  
  155. // Memory Pool
  156.  
  157. #if (defined(osFeature_Pool) && (osFeature_Pool != 0))
  158.  
  159. osPoolId osPoolCreate (const osPoolDef_t *pool_def) {
  160.  
  161.   if (pool_def == NULL) {
  162.     return (osPoolId)NULL;
  163.   }
  164.   return ((osPoolId)(osMemoryPoolNew(pool_def->pool_sz, pool_def->item_sz, &pool_def->attr)));
  165. }
  166.  
  167. void *osPoolAlloc (osPoolId pool_id) {
  168.   return osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
  169. }
  170.  
  171. void *osPoolCAlloc (osPoolId pool_id) {
  172.   void    *block;
  173.   uint32_t block_size;
  174.  
  175.   block_size = osMemoryPoolGetBlockSize((osMemoryPoolId_t)pool_id);
  176.   if (block_size == 0U) {
  177.     return NULL;
  178.   }
  179.   block = osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
  180.   if (block != NULL) {
  181.     memset(block, 0, block_size);
  182.   }
  183.   return block;
  184. }
  185.  
  186. osStatus osPoolFree (osPoolId pool_id, void *block) {
  187.   return osMemoryPoolFree((osMemoryPoolId_t)pool_id, block);
  188. }
  189.  
  190. #endif  // Memory Pool
  191.  
  192.  
  193. // Message Queue
  194.  
  195. #if (defined(osFeature_MessageQ) && (osFeature_MessageQ != 0))
  196.  
  197. osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id) {
  198.   (void)thread_id;
  199.  
  200.   if (queue_def == NULL) {
  201.     return (osMessageQId)NULL;
  202.   }
  203.   return ((osMessageQId)(osMessageQueueNew(queue_def->queue_sz, sizeof(uint32_t), &queue_def->attr)));
  204. }
  205.  
  206. osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
  207.   return osMessageQueuePut((osMessageQueueId_t)queue_id, &info, 0U, millisec);
  208. }
  209.  
  210. osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec) {
  211.   osStatus_t status;
  212.   osEvent    event;
  213.   uint32_t   message;
  214.  
  215.   status = osMessageQueueGet((osMessageQueueId_t)queue_id, &message, NULL, millisec);
  216.   switch (status) {
  217.     case osOK:
  218.       event.status = osEventMessage;
  219.       event.value.v = message;
  220.       break;
  221.     case osErrorResource:
  222.       event.status = osOK;
  223.       break;
  224.     case osErrorTimeout:
  225.       event.status = osEventTimeout;
  226.       break;
  227.     default:
  228.       event.status = status;
  229.       break;
  230.   }
  231.   return event;
  232. }
  233.  
  234. #endif  // Message Queue
  235.  
  236.  
  237. // Mail Queue
  238.  
  239. #if (defined(osFeature_MailQ) && (osFeature_MailQ != 0))
  240.  
  241. typedef struct os_mail_queue_s {
  242.   osMemoryPoolId_t   mp_id;
  243.   osMessageQueueId_t mq_id;
  244. } os_mail_queue_t;
  245.  
  246. osMailQId osMailCreate (const osMailQDef_t *queue_def, osThreadId thread_id) {
  247.   os_mail_queue_t *ptr;
  248.   (void)thread_id;
  249.  
  250.   if (queue_def == NULL) {
  251.     return (osMailQId)NULL;
  252.   }
  253.  
  254.   ptr = queue_def->mail;
  255.   if (ptr == NULL) {
  256.     return (osMailQId)NULL;
  257.   }
  258.  
  259.   ptr->mp_id = osMemoryPoolNew  (queue_def->queue_sz, queue_def->item_sz, &queue_def->mp_attr);
  260.   ptr->mq_id = osMessageQueueNew(queue_def->queue_sz, sizeof(void *), &queue_def->mq_attr);
  261.   if ((ptr->mp_id == (osMemoryPoolId_t)NULL) || (ptr->mq_id == (osMessageQueueId_t)NULL)) {
  262.     if (ptr->mp_id != (osMemoryPoolId_t)NULL) {
  263.       osMemoryPoolDelete(ptr->mp_id);
  264.     }
  265.     if (ptr->mq_id != (osMessageQueueId_t)NULL) {
  266.       osMessageQueueDelete(ptr->mq_id);
  267.     }
  268.     return (osMailQId)NULL;
  269.   }
  270.  
  271.   return (osMailQId)ptr;
  272. }
  273.  
  274. void *osMailAlloc (osMailQId queue_id, uint32_t millisec) {
  275.   os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
  276.  
  277.   if (ptr == NULL) {
  278.     return NULL;
  279.   }
  280.   return osMemoryPoolAlloc(ptr->mp_id, millisec);
  281. }
  282.  
  283. void *osMailCAlloc (osMailQId queue_id, uint32_t millisec) {
  284.   os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
  285.   void            *block;
  286.   uint32_t         block_size;
  287.  
  288.   if (ptr == NULL) {
  289.     return NULL;
  290.   }
  291.   block_size = osMemoryPoolGetBlockSize(ptr->mp_id);
  292.   if (block_size == 0U) {
  293.     return NULL;
  294.   }
  295.   block = osMemoryPoolAlloc(ptr->mp_id, millisec);
  296.   if (block != NULL) {
  297.     memset(block, 0, block_size);
  298.   }
  299.  
  300.   return block;
  301.  
  302. }
  303.  
  304. osStatus osMailPut (osMailQId queue_id, const void *mail) {
  305.   os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
  306.  
  307.   if (ptr == NULL) {
  308.     return osErrorParameter;
  309.   }
  310.   if (mail == NULL) {
  311.     return osErrorValue;
  312.   }
  313.   return osMessageQueuePut(ptr->mq_id, &mail, 0U, 0U);
  314. }
  315.  
  316. osEvent osMailGet (osMailQId queue_id, uint32_t millisec) {
  317.   os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
  318.   osStatus_t       status;
  319.   osEvent          event;
  320.   void            *mail;
  321.  
  322.   if (ptr == NULL) {
  323.     event.status = osErrorParameter;
  324.     return event;
  325.   }
  326.  
  327.   status = osMessageQueueGet(ptr->mq_id, &mail, NULL, millisec);
  328.   switch (status) {
  329.     case osOK:
  330.       event.status = osEventMail;
  331.       event.value.p = mail;
  332.       break;
  333.     case osErrorResource:
  334.       event.status = osOK;
  335.       break;
  336.     case osErrorTimeout:
  337.       event.status = osEventTimeout;
  338.       break;
  339.     default:
  340.       event.status = status;
  341.       break;
  342.   }
  343.   return event;
  344. }
  345.  
  346. osStatus osMailFree (osMailQId queue_id, void *mail) {
  347.   os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
  348.  
  349.   if (ptr == NULL) {
  350.     return osErrorParameter;
  351.   }
  352.   if (mail == NULL) {
  353.     return osErrorValue;
  354.   }
  355.   return osMemoryPoolFree(ptr->mp_id, mail);
  356. }
  357.  
  358. #endif  // Mail Queue
  359.  
  360.  
  361. #endif  // osCMSIS
  362.