rpc_server.c

#include <kernel.h>
#include <malloc.h>
#include <sifcmd.h>
#include <sifrpc.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <netman.h>
#include <netman_rpc.h>
 
#include "internal.h"
#include "rpc_server.h"
 
static int NETMAN_RpcSvr_threadID, NETMAN_Rx_threadID, SifHandlerID;
static unsigned char NETMAN_RpcSvr_ThreadStack[0x1000] ALIGNED(16);
static unsigned char NETMAN_Rx_ThreadStack[0x1000] ALIGNED(16);
static unsigned char IsInitialized=0, IsProcessingRx;
 
static struct NetManBD *FrameBufferStatus = NULL;
static struct NetManBD *RxIOPFrameBufferStatus;
static unsigned short int RxBufferRdPtr, RxBufferNextRdPtr;
extern void *_gp;
 
static void NETMAN_RxThread(void *arg);
 
static void ClearBufferLen(int index, void *packet, void *payload)
{
    struct NetManBD *bd;
    SifDmaTransfer_t dmat;
 
    bd = UNCACHED_SEG(&FrameBufferStatus[index]);
    bd->length = 0;
    bd->packet = packet;
    bd->payload = payload;
 
    //Transfer to IOP RAM
    dmat.src = (void*)&FrameBufferStatus[index];
    dmat.dest = &RxIOPFrameBufferStatus[index];
    dmat.size = sizeof(struct NetManBD);
    dmat.attr = 0;
    while(sceSifSetDma(&dmat, 1) == 0){ };
}
 
static s32 HandleRxEvent(s32 channel)
{
    struct NetManBD *bd;
 
    (void)channel;
 
    bd = UNCACHED_SEG(&FrameBufferStatus[RxBufferNextRdPtr]);
    if(bd->length > 0)
    {
        isceSifSetDChain();
 
        if(!IsProcessingRx)
        {
            IsProcessingRx = 1;
            iWakeupThread(NETMAN_Rx_threadID);
        }
    }
 
    ExitHandler();
    //Must allow the other SIF handlers to check their states, as it is possible for this handler to block other handlers until FrameBufferStatus is cleared.
    return 0;
}
 
int NetManRPCAllocRxBuffers(void)
{
    int i;
 
    for(i = 0; i < NETMAN_RPC_BLOCK_SIZE; i++)
    {
        void *packet, *payload;
 
        if((packet = NetManNetProtStackAllocRxPacket(NETMAN_NETIF_FRAME_SIZE, &payload)) != NULL)
        {
            ClearBufferLen(i, packet, payload);
        } else {
            printf("NETMAN: error - unable to allocate Rx FIFO buffers.\n");
            return -ENOMEM;
        }
    }
 
    return 0;
}
 
/* Main EE RPC thread. */
static void *NETMAN_EE_RPC_Handler(int fnum, void *buffer, int NumBytes)
{
    ee_thread_t thread;
    void *result;
 
    (void)NumBytes;
 
    switch(fnum)
    {
        case NETMAN_EE_RPC_FUNC_INIT:
            RxIOPFrameBufferStatus = *(void**)buffer;
 
            //Maintain 64-byte alignment to avoid non-uncached writes to the same cache line from contaminating the line.
            if(FrameBufferStatus == NULL) FrameBufferStatus = memalign(64, sizeof(struct NetManBD) * NETMAN_RPC_BLOCK_SIZE);
 
            if(FrameBufferStatus != NULL)
            {
                memset(UNCACHED_SEG(FrameBufferStatus), 0, sizeof(struct NetManBD) * NETMAN_RPC_BLOCK_SIZE);
                RxBufferRdPtr = 0;
                RxBufferNextRdPtr = 0;
                IsProcessingRx = 0;
 
                thread.func=&NETMAN_RxThread;
                thread.stack=NETMAN_Rx_ThreadStack;
                thread.stack_size=sizeof(NETMAN_Rx_ThreadStack);
                thread.gp_reg=&_gp;
                thread.initial_priority=0x59;   /* Should be given a lower priority than the protocol stack, so that the protocol stack can process incoming frames. */
                thread.attr=thread.option=0;
 
                if((NETMAN_Rx_threadID=CreateThread(&thread)) > 0)
                {
                    StartThread(NETMAN_Rx_threadID, NULL);
 
                    SifHandlerID = AddDmacHandler(DMAC_SIF0, &HandleRxEvent, 0);
                    EnableDmac(DMAC_SIF0);
                    ((struct NetManEEInitResult *)buffer)->result = 0;
                    ((struct NetManEEInitResult *)buffer)->FrameBufferStatus = FrameBufferStatus;
                }
                else{
                    ((struct NetManEEInitResult *)buffer)->result = NETMAN_Rx_threadID;
                }
            }else{
                ((struct NetManEEInitResult *)buffer)->result = -ENOMEM;
            }
            result=buffer;
            break;
        case NETMAN_EE_RPC_FUNC_DEINIT:
            if(FrameBufferStatus != NULL)
            {
                free(FrameBufferStatus);
                FrameBufferStatus = NULL;
            }
            result=NULL;
            break;
        case NETMAN_EE_RPC_FUNC_HANDLE_LINK_STATUS_CHANGE:
            NetManToggleGlobalNetIFLinkState(*(u32*)buffer);
            result=NULL;
            break;
        default:
            printf("NETMAN [EE]: Unrecognized command: 0x%x\n", fnum);
            *(int *)buffer=EINVAL;
            result=buffer;
    }
 
    return result;
}
 
static struct t_SifRpcDataQueue cb_queue;
static struct t_SifRpcServerData cb_srv;
 
static void NETMAN_RPC_Thread(void *arg)
{
    static unsigned char cb_rpc_buffer[64] __attribute__((__aligned__(64)));
 
    (void)arg;
 
    sceSifSetRpcQueue(&cb_queue, NETMAN_RpcSvr_threadID);
    sceSifRegisterRpc(&cb_srv, NETMAN_RPC_NUMBER, &NETMAN_EE_RPC_Handler, cb_rpc_buffer, NULL, NULL, &cb_queue);
    sceSifRpcLoop(&cb_queue);
}
 
static void NETMAN_RxThread(void *arg)
{
    volatile struct NetManBD *bd;
    u32 PacketLength, PacketLengthAligned;
    u8 run;
 
    (void)arg;
 
    while(1)
    {
        void *payload, *payloadNext;
        void *packet, *packetNext;
 
        bd = UNCACHED_SEG(&FrameBufferStatus[RxBufferRdPtr]);
 
        do {
            DI();
            PacketLength = bd->length;
            if (PacketLength > 0)
            {
                run = 1;
            } else {
                run = 0;
                IsProcessingRx = 0;
            }
            EI();
 
            if(!run)
                SleepThread();
        } while(!run);
 
        payload = bd->payload;
        packet = bd->packet;
 
        //Must successfully allocate a replacement buffer for the input buffer.
        while((packetNext = NetManNetProtStackAllocRxPacket(NETMAN_NETIF_FRAME_SIZE, &payloadNext)) == NULL){};
        RxBufferNextRdPtr = (RxBufferNextRdPtr + 1) % NETMAN_RPC_BLOCK_SIZE;
        ClearBufferLen(RxBufferRdPtr, packetNext, payloadNext);
 
        //Increment read pointer by one place.
        RxBufferRdPtr = RxBufferNextRdPtr;
 
        //Now process the received packet.
        PacketLengthAligned = (PacketLength + 63) & ~63;
        sceSifWriteBackDCache(payload, PacketLengthAligned);
        NetManNetProtStackReallocRxPacket(packet, PacketLength);
        NetManNetProtStackEnQRxPacket(packet);
    }
}
 
int NetManInitRPCServer(void)
{
    int result;
    ee_thread_t ThreadData;
 
    if(!IsInitialized)
    {
        ThreadData.func=&NETMAN_RPC_Thread;
        ThreadData.stack=NETMAN_RpcSvr_ThreadStack;
        ThreadData.stack_size=sizeof(NETMAN_RpcSvr_ThreadStack);
        ThreadData.gp_reg=&_gp;
        ThreadData.initial_priority=0x57;   /* The RPC server thread should be given a higher priority than the protocol stack, so that it can issue commants to the EE and return. */
        ThreadData.attr=ThreadData.option=0;
 
        if((NETMAN_RpcSvr_threadID=CreateThread(&ThreadData))>0)
        {
            StartThread(NETMAN_RpcSvr_threadID, NULL);
            IsInitialized=1;
            result=0;
        }
        else result=NETMAN_RpcSvr_threadID;
    }
    else result=0;
 
    return result;
}
 
void NetManDeinitRPCServer(void)
{
    if(IsInitialized)
    {
        sceSifRemoveRpc(&cb_srv, &cb_queue);
        sceSifRemoveRpcQueue(&cb_queue);
        RemoveDmacHandler(DMAC_SIF0, SifHandlerID);
 
        if(NETMAN_RpcSvr_threadID>0)
        {
            TerminateThread(NETMAN_RpcSvr_threadID);
            DeleteThread(NETMAN_RpcSvr_threadID);
            NETMAN_RpcSvr_threadID = 0;
        }
 
        if(NETMAN_Rx_threadID>0)
        {
            TerminateThread(NETMAN_Rx_threadID);
            DeleteThread(NETMAN_Rx_threadID);
            NETMAN_Rx_threadID = 0;
        }
 
        IsInitialized=0;
    }
}