picoos-u.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2014, Ari Suutari <ari@stonepile.fi>.
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote
 *     products derived from this software without specific prior written
 *     permission. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _PICOOS_U_H
#define _PICOOS_U_H

#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */

#include "uoscfg.h"
#include <stdint.h>
#include <stdbool.h>

#ifndef UOSCFG_MAX_MOUNT
#define UOSCFG_MAX_MOUNT 2
#endif

void uosInit(void);

void uosBootDiag(void);

void uosResourceDiag(void);

void uosSpinInit(void);

#if defined(__MSP430__) && UOSCFG_SPIN_USECS == 2

#define uosSpinUSecs(t) __delay_cycles(PORTCFG_CPU_CLOCK_MHZ * (t))

#else

void uosSpinUSecs(uint16_t uSecs);

#endif

#if UOSCFG_SPI_BUS > 0 || DOX == 1

struct uosSpiBus;
struct uosSpiDev;

typedef struct uosSpiBusConf {

  void    (*init)(struct uosSpiBus* bus);
  void    (*control)(struct uosSpiBus* bus, bool fullSpeed);
  void    (*cs)(struct uosSpiBus* bus, bool select);
  uint8_t (*xchg)(const struct uosSpiBus* bus, uint8_t data);
  void    (*xmit)(const struct uosSpiBus*, const uint8_t* data, int len);
  void    (*rcvr)(const struct uosSpiBus*, uint8_t* data, int len);
} UosSpiBusConf;

typedef struct uosSpiBus {

  const UosSpiBusConf* cf;
  POSMUTEX_t busMutex;
  struct uosSpiDev* currentDev;
  bool active;
} UosSpiBus;

typedef struct __attribute__((aligned(4))) uosSpiDevConf {
#ifdef UOSCFG_SPI_CS_TYPE
  UOSCFG_SPI_CS_TYPE cs;
#endif
} UosSpiDevConf;

typedef struct uosSpiDev {

  const UosSpiDevConf* cf;
  UosSpiBus* bus;
} UosSpiDev;

void    uosSpiInit(UosSpiBus* bus, const UosSpiBusConf* cf);

void uosSpiDevInit(UosSpiDev* dev, const UosSpiDevConf* cf, UosSpiBus* bus);

void    uosSpiControl(UosSpiBus* bus, bool fullSpeed);

void    uosSpiBeginNoCS(UosSpiDev* dev);

void    uosSpiBegin(UosSpiDev* dev);

void    uosSpiCS(UosSpiDev* dev, bool select);

uint8_t uosSpiXchg(UosSpiDev* dev, uint8_t data);

void    uosSpiXmit(UosSpiDev* dev, const uint8_t* data, int len);

void    uosSpiRcvr(UosSpiDev* dev, uint8_t* data, int len);

void    uosSpiEnd(UosSpiDev* dev);

#endif

#if UOSCFG_MAX_OPEN_FILES > 0 || DOX == 1

#if !defined(UOSCFG_NEWLIB_SYSCALLS) || UOSCFG_NEWLIB_SYSCALLS == 0

#define O_RDONLY    0
#define O_WRONLY    1
#define O_RDWR      2
#define O_APPEND    0x0008
#define O_CREAT     0x0200
#define O_TRUNC     0x0400

#endif

struct uosFile;
struct uosFS;
struct uosDisk;

#define UOS_BITTAB_TABLE(type, size) \
  typedef struct { \
     uint8_t  bitmap[size / 8 + 1]; \
     type table[size]; \
  } type##Bittab

#define UOS_BITTAB_INIT(bm) memset(&bm.bitmap, '\0', sizeof(bm.bitmap))

#define UOS_BITTAB_SLOT(bm, elem) (elem == NULL ? -1 : (elem - bm.table))

#define UOS_BITTAB_ELEM(bm, slot) (slot == -1 ? NULL : (bm.table + slot))

#define UOS_BITTAB_ALLOC(bm) uosBitTabAlloc(bm.bitmap, sizeof(bm.table)/sizeof(bm.table[0]))

#define UOS_BITTAB_FREE(bm, slot) uosBitTabFree(bm.bitmap, slot)

#define UOS_BITTAB_IS_FREE(bm, slot) uosBitTabIsFree(bm.bitmap, slot)

int uosBitTabAlloc(uint8_t* bitmap, int size);

void uosBitTabFree(uint8_t* bitmap, int slot);

bool uosBitTabIsFree(uint8_t* bitmap, int slot);

typedef struct uosFileInfo {
  bool   isDir;
  bool   isSocket;
  int    size;
} UosFileInfo;

typedef struct uosFileConf {

  int (*read)(struct uosFile* file, char* buf, int max);
  int (*write)(struct uosFile* file, const char* buf, int len);
  int (*close)(struct uosFile* file);
  int (*fstat)(struct uosFile* file, UosFileInfo* st);
  int (*lseek)(struct uosFile* file, int offset, int whence);
  int (*sync)(struct uosFile* file);
} UosFileConf;

typedef struct uosFSConf {

  int (*init)(const struct uosFS* mount);
  int (*open)(const struct uosFS* mount, struct uosFile* file, const char* filename, int flags, int mode);
  int (*stat)(const struct uosFS* mount, const char* filename, UosFileInfo* st);
  int (*unlink)(const struct uosFS* mount, const char* name);
} UosFSConf;

typedef struct uosDiskConf {

  int (*init)(const struct uosDisk* disk);
  int (*status)(const struct uosDisk* disk);
  int (*read)(const struct uosDisk* disk, uint8_t* buff, int sector, int count);
  int (*write)(const struct uosDisk* disk, const uint8_t* buff, int sector, int count);
  int (*ioctl)(const struct uosDisk* disk, uint8_t cmd, void* buff);
} UosDiskConf;

typedef struct uosDisk {

  const UosDiskConf* cf;
} UosDisk;

typedef struct uosFS {

  const UosFSConf*  cf;
  const char*     mountPoint;
} UosFS;

typedef struct uosFile {

  const UosFileConf*  cf;
  const UosFS*        fs;
  union {
    void*             fsPriv;
    int               fsPrivFd;
  };
    
} UosFile;

void uosFileInit(void);

int uosFile2Slot(UosFile* file);

UosFile* uosSlot2File(int fd);

int uosMount(const UosFS* mount);

UosFile* uosFileAlloc(void);

int uosFileFree(UosFile* file);

UosFile* uosFileOpen(const char* fileName, int flags,  int mode);

int uosFileRead(UosFile* file, char* buf, int max);

int uosFileWrite(UosFile* file, const char* buf, int len);

int uosFileClose(UosFile* file);

int uosFileStat(const char* filename, UosFileInfo* st);

int uosFileFStat(UosFile* file, UosFileInfo* st);

int uosFileSeek(UosFile* file, int offset, int whence);

int uosFileUnlink(const char* filename);

int uosFileSync(UosFile* file);

int uosAddDisk(const UosDisk* disk);

const UosDisk* uosGetDisk(int diskNumber);

#if UOSCFG_FAT > 0 || DOX == 1

int uosMountFat(const char* mountPoint, int diskNumber);

#if UOSCFG_FAT_MMC > 0 || DOX == 1

extern const UosDiskConf uosMmcDiskConf;

struct uosMmcDisk;

typedef struct uosMmcSpiConf {

  void    (*open)(const struct uosMmcDisk* disk);
  void    (*close)(const struct uosMmcDisk* disk);
} UosMmcSpiConf;

typedef struct uosMmcDisk {

  UosDisk base;
  const UosMmcSpiConf* cf;
  UosSpiDev* dev;
} UosMmcDisk;

void uosMmcSpiXmit(const UosMmcDisk*, const uint8_t* data, int len);

void uosMmcSpiRcvr(const UosMmcDisk*, uint8_t* data, int len);

#endif
#endif

#if UOSCFG_FS_ROM > 0 || DOX == 1

typedef struct {
  const char* fileName;
  const uint8_t* contents;
  int       size;
} UosRomFile;

int uosMountRom(const char* mountPoint, const UosRomFile* data);

#endif

#endif

void uosNewlibInit(void);

#if UOSCFG_RING > 0 || DOX == 1

typedef struct uosRing UosRing;

UosRing* uosRingCreate(int msgSize, int msgCount);

bool uosRingPut(UosRing* ring, const void *msg, UINT_t timeout);

bool uosRingGet(UosRing* ring, void *msg, UINT_t timeout);

void uosRingDestroy(UosRing* ring);

#endif

#if UOSCFG_NEWLIB_SYSCALLS == 1
int fsync(int);
#endif

#define UOS_CONFIG_KEYSIZE  20
#define UOS_CONFIG_VALUESIZE    40

typedef struct _uosConfigKeyValue {

  char key[UOS_CONFIG_KEYSIZE];
  char value[UOS_CONFIG_VALUESIZE];
  struct _uosConfigKeyValue* next;
  
} UosConfigKeyValue;

typedef int (*UosConfigSaver)(void* context, const char* key, const char* value);

const char* uosConfigGet(const char* key);

const char* uosConfigSet(const char* key, const char* value);

void uosConfigInit(void);

int uosConfigSaveEntries(void* context, UosConfigSaver saver);
  
#if UOSCFG_MAX_OPEN_FILES > 0 || DOX == 1

int uosConfigSave(const char* filename);

int uosConfigLoad(const char* filename);

#endif

#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif