Line data    Source code

       1             : // ---------------------------------------------------------------------------
       2             : // USB EPROM/Flash Programmer
       3             : //
       4             : // Copyright (2022) Robson Martins
       5             : //
       6             : // This work is licensed under a Creative Commons Attribution-NonCommercial-
       7             : // ShareAlike 4.0 International License.
       8             : // ---------------------------------------------------------------------------
       9             : /**
      10             :  * @ingroup Firmware
      11             :  * @file hal/multicore.cpp
      12             :  * @brief Implementation of the Pico Multi Core Class.
      13             :  *
      14             :  * @author Robson Martins (https://www.robsonmartins.com)
      15             :  */
      16             : // ---------------------------------------------------------------------------
      17             : 
      18             : #include "hal/multicore.hpp"
      19             : 
      20             : #include "pico/multicore.h"
      21             : #include "pico/mutex.h"
      22             : 
      23             : void multicore_core_1_entry_(void);
      24             : 
      25             : // ---------------------------------------------------------------------------
      26             : 
      27          80 : MultiCore::MultiCore(MultiCoreEntry entry) : entry_(entry), status_(csStopped) {
      28          80 :     mutex_t *mutex = new mutex_t();
      29          80 :     mutex_init(mutex);
      30          80 :     mutex_ = reinterpret_cast<void *>(mutex);
      31          80 : }
      32             : 
      33          80 : MultiCore::~MultiCore() {
      34          80 :     stop();
      35          80 :     mutex_t *mutex = reinterpret_cast<mutex_t *>(mutex_);
      36          80 :     delete mutex;
      37          80 : }
      38             : 
      39           7 : void MultiCore::launch() {
      40           7 :     if (status_ != csStopped) {
      41           0 :         return;
      42             :     }
      43           7 :     status_ = csStarting;
      44           7 :     multicore_launch_core1(multicore_core_1_entry_);
      45           7 :     multicore_fifo_push_blocking(reinterpret_cast<uintptr_t>(this));
      46          14 :     while (status_ == csStarting) {
      47           7 :         usleep(1);
      48             :     }
      49             : }
      50             : 
      51          87 : void MultiCore::stop() {
      52          87 :     if (status_ != csRunning) {
      53          80 :         return;
      54             :     }
      55           7 :     lock();
      56           7 :     status_ = csStopping;
      57           7 :     unlock();
      58           7 :     multicore_reset_core1();
      59             : #ifdef __arm__
      60             :     lock();
      61             :     status_ = csStopped;
      62             :     unlock();
      63             : #endif
      64             : }
      65             : 
      66           3 : bool MultiCore::isRunning() const {
      67           3 :     return (status_ != csStopped);
      68             : }
      69             : 
      70      112706 : bool MultiCore::isStopRequested() const {
      71      112706 :     return (status_ == csStopping);
      72             : }
      73             : 
      74           3 : MultiCore::CoreStatus MultiCore::getStatus() const {
      75           3 :     return status_;
      76             : }
      77             : 
      78          19 : void MultiCore::putParam(uintptr_t src) {
      79          19 :     if (status_ != csRunning) {
      80           2 :         return;
      81             :     }
      82          17 :     multicore_fifo_push_blocking(src);
      83             : }
      84             : 
      85          18 : uintptr_t MultiCore::getParam() {
      86          18 :     if (status_ != csRunning) {
      87           1 :         return 0;
      88             :     }
      89          17 :     return multicore_fifo_pop_blocking();
      90             : }
      91             : 
      92          42 : void MultiCore::lock() {
      93          42 :     mutex_t *mutex = reinterpret_cast<mutex_t *>(mutex_);
      94          42 :     mutex_enter_blocking(mutex);
      95          42 : }
      96             : 
      97          42 : void MultiCore::unlock() {
      98          42 :     mutex_t *mutex = reinterpret_cast<mutex_t *>(mutex_);
      99          42 :     mutex_exit(mutex);
     100          42 : }
     101             : 
     102         120 : void MultiCore::usleep(uint64_t us) {
     103         120 :     sleep_us(us);
     104         120 : }
     105             : 
     106          15 : void MultiCore::msleep(uint32_t ms) {
     107          15 :     sleep_ms(ms);
     108          15 : }
     109             : 
     110             : // ---------------------------------------------------------------------------
     111             : 
     112           7 : void multicore_core_1_entry_(void) {
     113           7 :     uintptr_t p = multicore_fifo_pop_blocking();
     114           7 :     MultiCore *core = reinterpret_cast<MultiCore *>(p);
     115           7 :     core->lock();
     116           7 :     core->status_ = MultiCore::csRunning;
     117           7 :     core->unlock();
     118           7 :     core->entry_(*core);
     119           7 :     core->lock();
     120           7 :     core->status_ = MultiCore::csStopped;
     121           7 :     core->unlock();
     122           7 : }