Add software

Software/portapack-mayhem/firmware/chibios/os/various/cpp_wrappers/ch.cpp

@@ -0,0 +1,866 @@
+/*
+    ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/**
+ * @file    ch.cpp
+ * @brief   C++ wrapper code.
+ *
+ * @addtogroup cpp_library
+ * @{
+ */
+
+#include "ch.hpp"
+
+namespace chibios_rt {
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::System                                                     *
+   *------------------------------------------------------------------------*/
+  void System::init(void) {
+
+    chSysInit();
+  }
+
+  void System::lock(void) {
+
+    chSysLock();
+  }
+
+  void System::unlock(void) {
+
+    chSysUnlock();
+  }
+
+  void System::lockFromIsr(void) {
+
+    chSysLockFromIsr();
+  }
+
+  void System::unlockFromIsr(void) {
+
+    chSysUnlockFromIsr();
+  }
+
+  systime_t System::getTime(void) {
+
+    return chTimeNow();
+  }
+
+  bool System::isTimeWithin(systime_t start, systime_t end) {
+
+    return (bool)chTimeIsWithin(start, end);
+  }
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Core                                                       *
+   *------------------------------------------------------------------------*/
+  void *Core::alloc(size_t size) {
+
+    return chCoreAlloc(size);
+  }
+
+  void *Core::allocI(size_t size) {
+
+    return chCoreAllocI(size);
+  }
+
+  size_t Core::getStatus(void) {
+
+    return chCoreStatus();
+  }
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Timer                                                      *
+   *------------------------------------------------------------------------*/
+  void Timer::setI(systime_t time, vtfunc_t vtfunc, void *par) {
+
+    chVTSetI(&timer_ref, time, vtfunc, par);
+  }
+
+  void Timer::resetI() {
+
+    if (chVTIsArmedI(&timer_ref))
+      chVTResetI(&timer_ref);
+  }
+
+  bool Timer::isArmedI(void) {
+
+    return (bool)chVTIsArmedI(&timer_ref);
+  }
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ThreadReference                                            *
+   *------------------------------------------------------------------------*/
+
+  void ThreadReference::stop(void) {
+
+    chDbgPanic("invoked unimplemented method stop()");
+  }
+
+  msg_t ThreadReference::suspend(void) {
+    msg_t msg;
+
+    chSysLock();
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #1",
+                "already referenced");
+
+    thread_ref = chThdSelf();
+    chSchGoSleepS(THD_STATE_SUSPENDED);
+    msg = thread_ref->p_u.rdymsg;
+
+    chSysUnlock();
+    return msg;
+  }
+
+  msg_t ThreadReference::suspendS(void) {
+
+    chDbgAssert(thread_ref == NULL,
+                "ThreadReference, #2",
+                "already referenced");
+
+    thread_ref = chThdSelf();
+    chSchGoSleepS(THD_STATE_SUSPENDED);
+    return thread_ref->p_u.rdymsg;
+  }
+
+  void ThreadReference::resume(msg_t msg) {
+
+    chSysLock()
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #3",
+                "not referenced");
+
+    if (thread_ref) {
+      Thread *tp = thread_ref;
+      thread_ref = NULL;
+      chSchWakeupS(tp, msg);
+    }
+
+    chSysUnlock();
+  }
+
+  void ThreadReference::resumeI(msg_t msg) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #4",
+                "not referenced");
+
+    if (thread_ref) {
+      Thread *tp = thread_ref;
+      thread_ref = NULL;
+      tp->p_msg = msg;
+      chSchReadyI(tp);
+    }
+  }
+
+  void ThreadReference::requestTerminate(void) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #5",
+                "not referenced");
+
+    chThdTerminate(thread_ref);
+  }
+
+#if CH_USE_WAITEXIT
+    msg_t ThreadReference::wait(void) {
+
+      chDbgAssert(thread_ref != NULL,
+                  "ThreadReference, #6",
+                  "not referenced");
+
+      msg_t msg = chThdWait(thread_ref);
+      thread_ref = NULL;
+      return msg;
+    }
+#endif /* CH_USE_WAITEXIT */
+
+#if CH_USE_MESSAGES
+  msg_t ThreadReference::sendMessage(msg_t msg) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #7",
+                "not referenced");
+
+    return chMsgSend(thread_ref, msg);
+  }
+
+  bool ThreadReference::isPendingMessage(void) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #7",
+                "not referenced");
+
+    return (bool)chMsgIsPendingI(thread_ref);
+  }
+
+  msg_t ThreadReference::getMessage(void) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #8",
+                "not referenced");
+
+    return chMsgGet(thread_ref);
+  }
+
+  void ThreadReference::releaseMessage(msg_t msg) {
+
+    chDbgAssert(thread_ref != NULL,
+                "ThreadReference, #9",
+                "not referenced");
+
+    chMsgRelease(thread_ref, msg);
+  }
+#endif /* CH_USE_MESSAGES */
+
+#if CH_USE_EVENTS
+    void ThreadReference::signalEvents(eventmask_t mask) {
+
+      chDbgAssert(thread_ref != NULL,
+                  "ThreadReference, #10",
+                  "not referenced");
+
+      chEvtSignal(thread_ref, mask);
+    }
+
+    void ThreadReference::signalEventsI(eventmask_t mask) {
+
+      chDbgAssert(thread_ref != NULL,
+                  "ThreadReference, #11",
+                  "not referenced");
+
+      chEvtSignalI(thread_ref, mask);
+    }
+#endif /* CH_USE_EVENTS */
+
+#if CH_USE_DYNAMIC
+#endif /* CH_USE_DYNAMIC */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseThread                                                 *
+   *------------------------------------------------------------------------*/
+  BaseThread::BaseThread() : ThreadReference(NULL) {
+
+  }
+
+  msg_t BaseThread::main(void) {
+
+    return 0;
+  }
+
+  ThreadReference BaseThread::start(tprio_t prio) {
+
+    (void)prio;
+
+    return *this;
+  };
+
+  msg_t _thd_start(void *arg) {
+
+    return ((BaseThread *)arg)->main();
+  }
+
+  void BaseThread::setName(const char *tname) {
+
+    chRegSetThreadName(tname);
+  }
+
+  tprio_t BaseThread::setPriority(tprio_t newprio) {
+
+    return chThdSetPriority(newprio);
+  }
+
+  void BaseThread::exit(msg_t msg) {
+
+    chThdExit(msg);
+  }
+
+  void BaseThread::exitS(msg_t msg) {
+
+    chThdExitS(msg);
+  }
+
+  bool BaseThread::shouldTerminate(void) {
+
+    return (bool)chThdShouldTerminate();
+  }
+
+  void BaseThread::sleep(systime_t interval){
+
+    chThdSleep(interval);
+  }
+
+  void BaseThread::sleepUntil(systime_t time) {
+
+    chThdSleepUntil(time);
+  }
+
+  void BaseThread::yield(void) {
+
+    chThdYield();
+  }
+
+#if CH_USE_MESSAGES
+  ThreadReference BaseThread::waitMessage(void) {
+
+    ThreadReference tr(chMsgWait());
+    return tr;
+  }
+#endif /* CH_USE_MESSAGES */
+
+#if CH_USE_EVENTS
+  eventmask_t BaseThread::getAndClearEvents(eventmask_t mask) {
+
+    return chEvtGetAndClearEvents(mask);
+  }
+
+  eventmask_t BaseThread::addEvents(eventmask_t mask) {
+
+    return chEvtAddEvents(mask);
+  }
+
+  eventmask_t BaseThread::waitOneEvent(eventmask_t ewmask) {
+
+    return chEvtWaitOne(ewmask);
+  }
+
+  eventmask_t BaseThread::waitAnyEvent(eventmask_t ewmask) {
+
+    return chEvtWaitAny(ewmask);
+  }
+
+  eventmask_t BaseThread::waitAllEvents(eventmask_t ewmask) {
+
+    return chEvtWaitAll(ewmask);
+  }
+
+#if CH_USE_EVENTS_TIMEOUT
+  eventmask_t BaseThread::waitOneEventTimeout(eventmask_t ewmask,
+                                              systime_t time) {
+
+    return chEvtWaitOneTimeout(ewmask, time);
+  }
+
+  eventmask_t BaseThread::waitAnyEventTimeout(eventmask_t ewmask,
+                                              systime_t time) {
+
+    return chEvtWaitAnyTimeout(ewmask, time);
+  }
+
+  eventmask_t BaseThread::waitAllEventsTimeout(eventmask_t ewmask,
+                                               systime_t time) {
+
+    return chEvtWaitAllTimeout(ewmask, time);
+  }
+#endif /* CH_USE_EVENTS_TIMEOUT */
+
+  void BaseThread::dispatchEvents(const evhandler_t handlers[],
+                                  eventmask_t mask) {
+
+    chEvtDispatch(handlers, mask);
+  }
+#endif /* CH_USE_EVENTS */
+
+#if CH_USE_MUTEXES
+  void BaseThread::unlockMutex(void) {
+
+    chMtxUnlock();
+  }
+
+  void BaseThread::unlockMutexS(void) {
+
+    chMtxUnlockS();
+  }
+
+  void BaseThread::unlockAllMutexes(void) {
+
+    chMtxUnlockAll();
+  }
+#endif /* CH_USE_MUTEXES */
+
+#if CH_USE_SEMAPHORES
+  /*------------------------------------------------------------------------*
+   * chibios_rt::CounterSemaphore                                           *
+   *------------------------------------------------------------------------*/
+  CounterSemaphore::CounterSemaphore(cnt_t n) {
+
+    chSemInit(&sem, n);
+  }
+
+  void CounterSemaphore::reset(cnt_t n) {
+
+    chSemReset(&sem, n);
+  }
+
+  void CounterSemaphore::resetI(cnt_t n) {
+
+    chSemResetI(&sem, n);
+  }
+
+  msg_t CounterSemaphore::wait(void) {
+
+    return chSemWait(&sem);
+  }
+
+  msg_t CounterSemaphore::waitS(void) {
+
+    return chSemWaitS(&sem);
+  }
+
+  msg_t CounterSemaphore::waitTimeout(systime_t time) {
+
+    return chSemWaitTimeout(&sem, time);
+  }
+
+  msg_t CounterSemaphore::waitTimeoutS(systime_t time) {
+
+    return chSemWaitTimeoutS(&sem, time);
+  }
+
+  void CounterSemaphore::signal(void) {
+
+    chSemSignal(&sem);
+  }
+
+  void CounterSemaphore::signalI(void) {
+
+    chSemSignalI(&sem);
+  }
+
+  void CounterSemaphore::addCounterI(cnt_t n) {
+
+    chSemAddCounterI(&sem, n);
+  }
+
+  cnt_t CounterSemaphore::getCounterI(void) {
+
+    return chSemGetCounterI(&sem);
+  }
+
+#if CH_USE_SEMSW
+  msg_t CounterSemaphore::signalWait(CounterSemaphore *ssem,
+                                     CounterSemaphore *wsem) {
+
+    return chSemSignalWait(&ssem->sem, &wsem->sem);
+  }
+#endif /* CH_USE_SEMSW */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BinarySemaphore                                            *
+   *------------------------------------------------------------------------*/
+  BinarySemaphore::BinarySemaphore(bool taken) {
+
+    chBSemInit(&bsem, (bool_t)taken);
+  }
+
+  msg_t BinarySemaphore::wait(void) {
+
+    return chBSemWait(&bsem);
+  }
+
+  msg_t BinarySemaphore::waitS(void) {
+
+    return chBSemWaitS(&bsem);
+  }
+
+  msg_t BinarySemaphore::waitTimeout(systime_t time) {
+
+    return chBSemWaitTimeout(&bsem, time);
+  }
+
+  msg_t BinarySemaphore::waitTimeoutS(systime_t time) {
+
+    return chBSemWaitTimeoutS(&bsem, time);
+  }
+
+  void BinarySemaphore::reset(bool taken) {
+
+    chBSemReset(&bsem, (bool_t)taken);
+  }
+
+  void BinarySemaphore::resetI(bool taken) {
+
+    chBSemResetI(&bsem, (bool_t)taken);
+  }
+
+  void BinarySemaphore::signal(void) {
+
+    chBSemSignal(&bsem);
+  }
+
+  void BinarySemaphore::signalI(void) {
+
+    chBSemSignalI(&bsem);
+  }
+
+  bool BinarySemaphore::getStateI(void) {
+
+    return (bool)chBSemGetStateI(&bsem);
+  }
+#endif /* CH_USE_SEMAPHORES */
+
+#if CH_USE_MUTEXES
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Mutex                                                      *
+   *------------------------------------------------------------------------*/
+  Mutex::Mutex(void) {
+
+    chMtxInit(&mutex);
+  }
+
+  bool Mutex::tryLock(void) {
+
+    return chMtxTryLock(&mutex);
+  }
+
+  bool Mutex::tryLockS(void) {
+
+    return chMtxTryLockS(&mutex);
+  }
+
+  void Mutex::lock(void) {
+
+    chMtxLock(&mutex);
+  }
+
+  void Mutex::lockS(void) {
+
+    chMtxLockS(&mutex);
+  }
+
+#if CH_USE_CONDVARS
+  /*------------------------------------------------------------------------*
+   * chibios_rt::CondVar                                                    *
+   *------------------------------------------------------------------------*/
+  CondVar::CondVar(void) {
+
+    chCondInit(&condvar);
+  }
+
+  void CondVar::signal(void) {
+
+    chCondSignal(&condvar);
+  }
+
+  void CondVar::signalI(void) {
+
+    chCondSignalI(&condvar);
+  }
+
+  void CondVar::broadcast(void) {
+
+    chCondBroadcast(&condvar);
+  }
+
+  void CondVar::broadcastI(void) {
+
+    chCondBroadcastI(&condvar);
+  }
+
+  msg_t CondVar::wait(void) {
+
+    return chCondWait(&condvar);
+  }
+
+  msg_t CondVar::waitS(void) {
+
+    return chCondWaitS(&condvar);
+  }
+
+#if CH_USE_CONDVARS_TIMEOUT
+  msg_t CondVar::waitTimeout(systime_t time) {
+
+    return chCondWaitTimeout(&condvar, time);
+  }
+#endif /* CH_USE_CONDVARS_TIMEOUT */
+#endif /* CH_USE_CONDVARS */
+#endif /* CH_USE_MUTEXES */
+
+#if CH_USE_EVENTS
+  /*------------------------------------------------------------------------*
+   * chibios_rt::EvtListener                                              *
+   *------------------------------------------------------------------------*/
+  flagsmask_t EvtListener::getAndClearFlags(void) {
+
+    return chEvtGetAndClearFlags(&ev_listener);
+  }
+
+  flagsmask_t EvtListener::getAndClearFlagsI(void) {
+
+    return chEvtGetAndClearFlagsI(&ev_listener);
+  }
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::EvtSource                                                *
+   *------------------------------------------------------------------------*/
+  EvtSource::EvtSource(void) {
+
+    chEvtInit(&ev_source);
+  }
+
+  void EvtSource::registerOne(chibios_rt::EvtListener *elp,
+                                eventid_t eid) {
+
+    chEvtRegister(&ev_source, &elp->ev_listener, eid);
+  }
+
+  void EvtSource::registerMask(chibios_rt::EvtListener *elp,
+                                 eventmask_t emask) {
+
+    chEvtRegisterMask(&ev_source, &elp->ev_listener, emask);
+  }
+
+  void EvtSource::unregister(chibios_rt::EvtListener *elp) {
+
+    chEvtUnregister(&ev_source, &elp->ev_listener);
+  }
+
+  void EvtSource::broadcastFlags(flagsmask_t flags) {
+
+    chEvtBroadcastFlags(&ev_source, flags);
+  }
+
+  void EvtSource::broadcastFlagsI(flagsmask_t flags) {
+
+    chEvtBroadcastFlagsI(&ev_source, flags);
+  }
+#endif /* CH_USE_EVENTS */
+
+#if CH_USE_QUEUES
+  /*------------------------------------------------------------------------*
+   * chibios_rt::InQueue                                                    *
+   *------------------------------------------------------------------------*/
+  InQueue::InQueue(uint8_t *bp, size_t size, qnotify_t infy, void *link) {
+
+    chIQInit(&iq, bp, size, infy, link);
+  }
+
+  size_t InQueue::getFullI(void) {
+
+    return chIQGetFullI(&iq);
+  }
+
+  size_t InQueue::getEmptyI(void) {
+
+    return chIQGetEmptyI(&iq);
+  }
+
+  bool InQueue::isEmptyI(void) {
+
+    return (bool)chIQIsEmptyI(&iq);
+  }
+
+  bool InQueue::isFullI(void) {
+
+    return (bool)chIQIsFullI(&iq);
+  }
+
+  void InQueue::resetI(void) {
+
+    chIQResetI(&iq);
+  }
+
+  msg_t InQueue::putI(uint8_t b) {
+
+    return chIQPutI(&iq, b);
+  }
+
+  msg_t InQueue::get() {
+
+    return chIQGet(&iq);
+  }
+
+  msg_t InQueue::getTimeout(systime_t time) {
+
+    return chIQGetTimeout(&iq, time);
+  }
+
+  size_t InQueue::readTimeout(uint8_t *bp, size_t n, systime_t time) {
+
+    return chIQReadTimeout(&iq, bp, n, time);
+  }
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::OutQueue                                                   *
+   *------------------------------------------------------------------------*/
+  OutQueue::OutQueue(uint8_t *bp, size_t size, qnotify_t onfy, void *link) {
+
+    chOQInit(&oq, bp, size, onfy, link);
+  }
+
+  size_t OutQueue::getFullI(void) {
+
+    return chOQGetFullI(&oq);
+  }
+
+  size_t OutQueue::getEmptyI(void) {
+
+    return chOQGetEmptyI(&oq);
+  }
+
+  bool OutQueue::isEmptyI(void) {
+
+    return (bool)chOQIsEmptyI(&oq);
+  }
+
+  bool OutQueue::isFullI(void) {
+
+    return (bool)chOQIsFullI(&oq);
+  }
+
+  void OutQueue::resetI(void) {
+
+    chOQResetI(&oq);
+  }
+
+  msg_t OutQueue::put(uint8_t b) {
+
+    return chOQPut(&oq, b);
+  }
+
+  msg_t OutQueue::putTimeout(uint8_t b, systime_t time) {
+
+    return chOQPutTimeout(&oq, b, time);
+  }
+
+  msg_t OutQueue::getI(void) {
+
+    return chOQGetI(&oq);
+  }
+
+  size_t OutQueue::writeTimeout(const uint8_t *bp, size_t n,
+                                systime_t time) {
+
+    return chOQWriteTimeout(&oq, bp, n, time);
+  }
+#endif /* CH_USE_QUEUES */
+
+#if CH_USE_MAILBOXES
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Mailbox                                                    *
+   *------------------------------------------------------------------------*/
+  Mailbox::Mailbox(msg_t *buf, cnt_t n) {
+
+    chMBInit(&mb, buf, n);
+  }
+
+  void Mailbox::reset(void) {
+
+    chMBReset(&mb);
+  }
+
+  msg_t Mailbox::post(msg_t msg, systime_t time) {
+
+    return chMBPost(&mb, msg, time);
+  }
+
+  msg_t Mailbox::postS(msg_t msg, systime_t time) {
+
+    return chMBPostS(&mb, msg, time);
+  }
+
+  msg_t Mailbox::postI(msg_t msg) {
+
+    return chMBPostI(&mb, msg);
+  }
+
+  msg_t Mailbox::postAhead(msg_t msg, systime_t time) {
+
+    return chMBPostAhead(&mb, msg, time);
+  }
+
+  msg_t Mailbox::postAheadS(msg_t msg, systime_t time) {
+
+    return chMBPostAheadS(&mb, msg, time);
+  }
+
+  msg_t Mailbox::postAheadI(msg_t msg) {
+
+    return chMBPostAheadI(&mb, msg);
+  }
+
+  msg_t Mailbox::fetch(msg_t *msgp, systime_t time) {
+
+    return chMBFetch(&mb, msgp, time);
+  }
+
+  msg_t Mailbox::fetchS(msg_t *msgp, systime_t time) {
+
+    return chMBFetchS(&mb, msgp, time);
+  }
+
+  msg_t Mailbox::fetchI(msg_t *msgp) {
+
+    return chMBFetchI(&mb, msgp);
+  }
+
+  cnt_t Mailbox::getFreeCountI(void) {
+
+    return chMBGetFreeCountI(&mb);
+  }
+
+  cnt_t Mailbox::getUsedCountI(void) {
+
+    return chMBGetUsedCountI(&mb);
+  }
+#endif /* CH_USE_MAILBOXES */
+
+#if CH_USE_MEMPOOLS
+  /*------------------------------------------------------------------------*
+   * chibios_rt::MemoryPool                                                 *
+   *------------------------------------------------------------------------*/
+  MemoryPool::MemoryPool(size_t size, memgetfunc_t provider) {
+
+    chPoolInit(&pool, size, provider);
+  }
+
+  MemoryPool::MemoryPool(size_t size, memgetfunc_t provider, void* p, size_t n) {
+
+    chPoolInit(&pool, size, provider);
+    chPoolLoadArray(&pool, p, n);
+  }
+
+
+  void MemoryPool::loadArray(void *p, size_t n) {
+
+    chPoolLoadArray(&pool, p, n);
+  }
+
+  void *MemoryPool::allocI(void) {
+
+    return chPoolAllocI(&pool);
+  }
+
+  void *MemoryPool::alloc(void) {
+
+    return chPoolAlloc(&pool);
+  }
+
+  void MemoryPool::free(void *objp) {
+
+    chPoolFree(&pool, objp);
+  }
+
+  void MemoryPool::freeI(void *objp) {
+
+    chPoolFreeI(&pool, objp);
+  }
+#endif /* CH_USE_MEMPOOLS */
+}
+
+/** @} */

Software/portapack-mayhem/firmware/chibios/os/various/cpp_wrappers/kernel.mk

@@ -0,0 +1,4 @@
+# C++ wrapper files.
+CHCPPSRC = ${CHIBIOS}/os/various/cpp_wrappers/ch.cpp
+
+CHCPPINC = ${CHIBIOS}/os/various/cpp_wrappers