MP.h

Go to the documentation of this file.

/*
 *  MP.h - Spresense Arduino Multi-Processer Communication library
 *  Copyright 2019,2021 Sony Semiconductor Solutions Corporation
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef _MP_H_
#define _MP_H_
 
/****************************************************************************
 * Included Files
 ****************************************************************************/
 
#include <Arduino.h>
#include <sdk/config.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
 
#include <asmp/asmp.h>
#include <asmp/mptask.h>
#include <asmp/mpshm.h>
#include <asmp/mpmq.h>
#include <asmp/mpmutex.h>
 
#include <multi_print.h>
 
/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/
 
#ifdef BRD_DEBUG
#define MPDBG(format, ...) printf("DEBUG: " format, ##__VA_ARGS__)
#else
#define MPDBG(format, ...)
#endif
#define MPERR(format, ...) printf("ERROR: " format, ##__VA_ARGS__)
 
#define KEY_SHM   1
#define KEY_MQ    2
 
#define MP_RECV_BLOCKING    (0)
#define MP_RECV_POLLING     (MPMQ_NONBLOCK)
 
#define MP_GET_CPUID()      (*(volatile int *)0x4e002040)
 
#define MP_MAX_SUBID 6
 
/* MP Log utility */
#if   (SUBCORE == 1)
#define MPLOG_PREFIX "[Sub1] "
#elif (SUBCORE == 2)
#define MPLOG_PREFIX "[Sub2] "
#elif (SUBCORE == 3)
#define MPLOG_PREFIX "[Sub3] "
#elif (SUBCORE == 4)
#define MPLOG_PREFIX "[Sub4] "
#elif (SUBCORE == 5)
#define MPLOG_PREFIX "[Sub5] "
#else
#define MPLOG_PREFIX "[Main] "
#endif
 
#define MPLog(fmt, ...) do { \
    irqstate_t flags; \
    flags = printlock(); \
    sync_printf(MPLOG_PREFIX fmt, ##__VA_ARGS__); \
    printunlock(flags); \
} while (0)
 
/****************************************************************************
 * class declaration
 ****************************************************************************/
 
class MPClass
{
public:
  MPClass();
 
#ifdef SUBCORE
  int begin();
#else
  int begin(int subid);
#endif
 
#ifdef SUBCORE
  int end();
#else
  int end(int subid);
#endif
 
#ifdef SUBCORE
  int Send(int8_t msgid, uint32_t msgdata, int subid = 0);
#else
  int Send(int8_t msgid, uint32_t msgdata, int subid);
#endif
 
#ifdef SUBCORE
  int Recv(int8_t *msgid, uint32_t *msgdata, int subid = 0);
#else
  int Recv(int8_t *msgid, uint32_t *msgdata, int subid);
#endif
 
#ifdef SUBCORE
  int Send(int8_t msgid, void *msgaddr, int subid = 0);
#else
  int Send(int8_t msgid, void *msgaddr, int subid);
#endif
 
#ifdef SUBCORE
  int Recv(int8_t *msgid, void *msgaddr, int subid = 0);
#else
  int Recv(int8_t *msgid, void *msgaddr, int subid);
#endif
 
#ifdef SUBCORE
  template <typename T> int SendObject(T &t, int subid = 0);
#else
  template <typename T> int SendObject(T &t, int subid);
#endif
 
#ifdef SUBCORE
  template <typename T> int RecvObject(T &t, int subid = 0);
#else
  template <typename T> int RecvObject(T &t, int subid);
#endif
 
#ifdef SUBCORE
  int SendWaitComplete(int subid = 0);
#else
  int SendWaitComplete(int subid);
#endif
 
  void RecvTimeout(uint32_t timeout);
 
  uint32_t GetRecvTimeout();
 
  uint32_t Virt2Phys(void *virt);
 
  void GetMemoryInfo(int &usedMem, int &freeMem, int &largestFreeMem);
 
  void EnableConsole();
 
  void DisableConsole();
 
#ifndef SUBCORE
  void *AllocSharedMemory(size_t size);
 
  void FreeSharedMemory(void *addr);
#endif
 
private:
  uint32_t _recvTimeout;
  mpmq_t   _mq[MP_MAX_SUBID];
  struct ResourceManagement {
    uint32_t magic;
    uint32_t cpu_assign;
    uint32_t reserved[2];
    uint32_t resource[4];
  } *_rmng;
 
  int checkid(int subid);
#ifndef SUBCORE
  mptask_t _mptask[MP_MAX_SUBID];
  int load(int subid);
  int unload(int subid);
  sq_queue_t _shmlist;
  struct shm_entry {
    sq_entry_t entry;
    mpshm_t    shm;
    uint32_t   addr;
  };
#endif
};
 
/****************************************************************************
 * template functions
 ****************************************************************************/
 
template <typename T> int MPClass::SendObject(T &t, int subid)
{
  int ret;
 
  ret = checkid(subid);
  if (ret) {
    return ret;
  }
 
  size_t msgsz = sizeof(T);
  if (msgsz > 127) {
    return -EINVAL;
  }
 
  ret = Send((int8_t)msgsz, Virt2Phys(&t), subid);
  if (ret < 0) {
    MPDBG("Send(&object) failure. %d\n", ret);
    return ret;
  }
 
  return ret;
}
 
template <typename T> int MPClass::RecvObject(T &t, int subid)
{
  int ret;
  void *vp;
  int8_t rsz;
 
  ret = checkid(subid);
  if (ret) {
    return ret;
  }
 
  size_t msgsz = sizeof(T);
  if (msgsz > 127) {
    return -EINVAL;
  }
 
  ret = Recv(&rsz, (uint32_t*)&vp, subid);
 
  if ((ret <= 0) || (msgsz != ret)) {
    MPDBG("Recv(&object) failure. %d\n", ret);
    mpmq_send(&_mq[subid], -1, 0); // error
    return ret;
  }
 
  memcpy(&t, vp, msgsz);
 
  ret = mpmq_send(&_mq[subid], 0, 0); // success
  if (ret < 0) {
    MPDBG("mpmq_send() failure. %d\n", ret);
    return ret;
  }
 
  return ret;
}
 
/****************************************************************************
 * extern declaration
 ****************************************************************************/
 
extern MPClass MP;
 
#endif /* _MP_H_ */