fifocommon.h

説明を見る。

#ifndef FIFOCOMMON_H
#define FIFOCOMMON_H

#include "ndstypes.h"

typedef enum {
   FIFO_PM              = 0,
   FIFO_SOUND   = 1,
   FIFO_SYSTEM  = 2, 
   FIFO_MAXMOD  = 3,
   FIFO_DSWIFI  = 4,
   FIFO_RSDV_01 = 5,
   FIFO_RSVD_02 = 6,
   FIFO_RSVD_03 = 7,
   FIFO_USER_01 = 8,
   FIFO_USER_02 = 9,
   FIFO_USER_03 = 10,
   FIFO_USER_04 = 11,
   FIFO_USER_05 = 12,
   FIFO_USER_06 = 13,
   FIFO_USER_07 = 14,
   FIFO_USER_08 = 15,
} FifoChannels;


typedef enum {
        SOUND_SET_PAN                   = 0 << 20,
        SOUND_SET_VOLUME                = 1 << 20,
        SOUND_SET_FREQ                  = 2 << 20,
        SOUND_SET_WAVEDUTY              = 3 << 20,
        SOUND_MASTER_ENABLE             = 4 << 20,
        SOUND_MASTER_DISABLE    = 5 << 20,
        SOUND_PAUSE                             = 6 << 20,
        SOUND_RESUME                    = 7 << 20,
        SOUND_KILL                              = 8 << 20,
        SOUND_SET_MASTER_VOL    = 9 << 20,
        MIC_STOP                                = 10 << 20

} FifoSoundCommand;

typedef enum {
        SYS_REQ_TOUCH,
        SYS_REQ_KEYS,
        SYS_REQ_TIME,

} FifoSystemCommands;

typedef enum {
        PM_REQ_ON = (1<<16),
        PM_REQ_OFF  = (2<<16),
        PM_REQ_LED  = (3<<16),
        PM_REQ_SLEEP  = (4<<16),
        PM_REQ_SLEEP_DISABLE  = (5<<16),
        PM_REQ_SLEEP_ENABLE  = (6<<16)
}FifoPMCommands;

typedef enum {
        WIFI_ENABLE,
        WIFI_DISABLE,
        WIFI_SYNC,
        WIFI_STARTUP
} FifoWifiCommands;



typedef enum {
        PM_LED_ON               =(0<<4),        
        PM_LED_SLEEP    =(1<<4),        
        PM_LED_BLINK    =(3<<4),        
}PM_LedBlinkMode;


#ifdef __cplusplus
extern "C" {
#endif

#if FIFO_RIGOROUS_ERROR_CHECKING
        int fifoError(char *, ...); // expected to be defined externally.
#endif

// Handlers are called when new data arrives - they're called from interrupt level, but well secured so not too much caution is necessary.
// Except that you shouldn't alloc/free or printf from within them, just to be safe.
// FifoAddressHandlerFunc - Provides callback with the sent address and the callback's user data

typedef void (*FifoAddressHandlerFunc)(void * address, void * userdata);

// FifoValue32HandlerFunc - Provides callback with the sent value and the callback's user data
typedef void (*FifoValue32HandlerFunc)(u32 value32, void * userdata);
// FifoDatamsgHandlerFunc - Provides callback with the number of bytes sent and the callback's user data
// This callback must call fifoGetData to actually retrieve the data. If it doesn't, the data will be destroyed on return.
typedef void (*FifoDatamsgHandlerFunc)(int num_bytes, void * userdata);

bool fifoInit();

bool fifoSendAddress(int channel, void *address);

bool fifoSendValue32(int channel, u32 value32);

bool fifoSendDatamsg(int channel, int num_bytes, u8 * data_array);

// Note about setting handlers: if a handler is already set, the function will FAIL and return false unless you're trying to unset the handler.
//  Alternately, use the FifoForce*Handler functions, to set regardless - these are specificly designed to try to prevent misuse.
// Another note on setting handlers: Setting the handler for a channel feeds the queue of buffered messages to the new handler, if there are any unread messages.
// FifoSetAddressHandler - Set a callback to receive incoming address messages on a specific channel.

bool fifoSetAddressHandler(int channel, FifoAddressHandlerFunc newhandler, void * userdata);

bool fifoSetValue32Handler(int channel, FifoValue32HandlerFunc newhandler, void * userdata);
// FifoSetDatamsgHandler - Set a callback to receive incoming data sequences on a specific channel.

bool fifoSetDatamsgHandler(int channel, FifoDatamsgHandlerFunc newhandler, void * userdata);


// Check functions see if there are any of a specific type of data in queue.
// Note: these functions will never return true if there is a callback for the specific channel and type of data being checked.
bool fifoCheckAddress(int channel);
bool fifoCheckValue32(int channel);
bool fifoCheckDatamsg(int channel);
// fifoCheckDatamsgLength - gets the number of bytes in the queue for the first data entry. (or -1 if there are no entries)
int fifoCheckDatamsgLength(int channel);

// fifoGetAddress - Get the first address in queue for a specific channel (or NULL if there is none)
void * fifoGetAddress(int channel);
// fifoGetValue32 - Get the first value32 in queue for a specific channel (will return 0 if there is no message)
u32 fifoGetValue32(int channel);
// fifoGetDatamsg - Read a data message - returns the number of bytes written (or -1 if there is no message)
//  Warning: If your buffer is not big enough, you may lose data! Check the data length first if you're not sure what the size is.
int fifoGetDatamsg(int channel, int buffersize, u8 * destbuffer);



#ifdef __cplusplus
};
#endif


#endif

---