rpc_client.c

#include <errno.h>
#include <kernel.h>
#include <sifrpc.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>
#include <netman.h>
#include <netman_rpc.h>
#include <iopcontrol.h>
 
#include "rpc_client.h"
 
static SifRpcClientData_t NETMAN_rpc_cd;
extern void *_gp;
 
static union {
    s32 mode;
    struct NetManIoctl IoctlArgs;
    char netifName[NETMAN_NETIF_NAME_MAX_LEN];
    struct NetManRegNetworkStack NetStack;
    u8 buffer[128];
}TransmitBuffer ALIGNED(64);
 
static union {
    s32 result;
    struct NetManRegNetworkStackResult NetStackResult;
    struct NetManIoctlResult IoctlResult;
    struct NetManQueryMainNetIFResult QueryMainNetIFResult;
    u8 buffer[128];
}ReceiveBuffer ALIGNED(64);
 
static int NetManIOSemaID, NETMAN_Tx_threadID;
static unsigned char NETMAN_Tx_ThreadStack[0x1000] ALIGNED(16);
 
static unsigned short int IOPFrameBufferWrPtr;
static u8 *IOPFrameBuffer = NULL;   /* On the IOP side. */
static struct NetManBD *IOPFrameBufferStatus = NULL;
static struct NetManBD *FrameBufferStatus = NULL;
 
static unsigned char IsProcessingTx;
 
static void deinitCleanup(void)
{
    if(NetManIOSemaID > 0)
    {
        DeleteSema(NetManIOSemaID);
        NetManIOSemaID = 0;
    }
    if(NETMAN_Tx_threadID > 0)
    {
        TerminateThread(NETMAN_Tx_threadID);
        DeleteThread(NETMAN_Tx_threadID);
        NETMAN_Tx_threadID = 0;
    }
    memset(&NETMAN_rpc_cd, 0, sizeof(NETMAN_rpc_cd));
}
 
static void NETMAN_TxThread(void *arg);
 
int NetManInitRPCClient(void){
    static const char NetManID[]="NetMan";
    int result;
    ee_sema_t SemaData;
    ee_thread_t thread;
    if (HasIopRebootedSinceLastCall())
        deinitCleanup();
 
    if(NETMAN_rpc_cd.server)
        return 0;
    SemaData.max_count=1;
    SemaData.init_count=1;
    SemaData.option=(u32)NetManID;
    SemaData.attr=0;
    if((NetManIOSemaID=CreateSema(&SemaData)) <= 0)
    {
        NetManIOSemaID = 0;
        deinitCleanup();
        return -1;
    }
 
    thread.func=&NETMAN_TxThread;
    thread.stack=NETMAN_Tx_ThreadStack;
    thread.stack_size=sizeof(NETMAN_Tx_ThreadStack);
    thread.gp_reg=&_gp;
    thread.initial_priority=0x56;   /* Should be given a higher priority than the protocol stack, so that it can dump frames in the EE and return. */
    thread.attr=thread.option=0;
 
    if((NETMAN_Tx_threadID=CreateThread(&thread)) <= 0)
    {
        NETMAN_Tx_threadID = 0;
        deinitCleanup();
        return NETMAN_Tx_threadID;
    }
    IsProcessingTx = 0;
    StartThread(NETMAN_Tx_threadID, NULL);
 
    while((sceSifBindRpc(&NETMAN_rpc_cd, NETMAN_RPC_NUMBER, 0)<0)||(NETMAN_rpc_cd.server==NULL))
        nopdelay();
 
    if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_INIT, 0, NULL, 0, &ReceiveBuffer, sizeof(s32), NULL, NULL))<0 || (result=ReceiveBuffer.result) != 0)
        deinitCleanup();
 
    return result;
}
 
int NetManRPCRegisterNetworkStack(void)
{
    int result;
 
    WaitSema(NetManIOSemaID);
 
    if(FrameBufferStatus == NULL) FrameBufferStatus = memalign(64, NETMAN_RPC_BLOCK_SIZE * sizeof(struct NetManBD));
 
    if(FrameBufferStatus != NULL)
    {
        memset(UNCACHED_SEG(FrameBufferStatus), 0, NETMAN_RPC_BLOCK_SIZE * sizeof(struct NetManBD));
        TransmitBuffer.NetStack.FrameBufferStatus = FrameBufferStatus;
        IOPFrameBufferWrPtr = 0;
 
        if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_REG_NETWORK_STACK, 0, &TransmitBuffer, sizeof(struct NetManRegNetworkStack), &ReceiveBuffer, sizeof(struct NetManRegNetworkStackResult), NULL, NULL))>=0)
        {
            if((result=ReceiveBuffer.NetStackResult.result) == 0)
            {
                IOPFrameBuffer = ReceiveBuffer.NetStackResult.FrameBuffer;
                IOPFrameBufferStatus = ReceiveBuffer.NetStackResult.FrameBufferStatus;
            }
        }
    }
    else
    {
        result = -ENOMEM;
    }
 
    SignalSema(NetManIOSemaID);
 
    return result;
}
 
int NetManRPCUnregisterNetworkStack(void)
{
    int result;
 
    WaitSema(NetManIOSemaID);
 
    result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_UNREG_NETWORK_STACK, 0, NULL, 0, NULL, 0, NULL, NULL);
    IOPFrameBuffer = NULL;
    IOPFrameBufferWrPtr = 0;
 
    free(FrameBufferStatus);
    FrameBufferStatus = NULL;
 
    SignalSema(NetManIOSemaID);
 
    return result;
}
 
void NetManDeinitRPCClient(void)
{
    if(NETMAN_rpc_cd.server)
    {
        WaitSema(NetManIOSemaID);
 
        sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_DEINIT, 0, NULL, 0, NULL, 0, NULL, NULL);
        deinitCleanup();
    }
}
 
int NetManRpcIoctl(unsigned int command, void *args, unsigned int args_len, void *output, unsigned int length)
{
    int result;
    struct NetManIoctl *IoctlArgs=&TransmitBuffer.IoctlArgs;
 
    WaitSema(NetManIOSemaID);
 
    IoctlArgs->command=command;
    memcpy(IoctlArgs->args, args, args_len);
    IoctlArgs->args_len=args_len;
    IoctlArgs->output=output;
    IoctlArgs->length=length;
 
    if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_IOCTL, 0, &TransmitBuffer, sizeof(struct NetManIoctl), &ReceiveBuffer, sizeof(struct NetManIoctlResult), NULL, NULL))>=0)
    {
        result=ReceiveBuffer.IoctlResult.result;
        memcpy(output, ReceiveBuffer.IoctlResult.output, length);
    }
 
    SignalSema(NetManIOSemaID);
 
    return result;
}
 
static void NETMAN_TxThread(void *arg)
{
    static SifCmdHeader_t cmd ALIGNED(64);
    SifDmaTransfer_t dmat[2];
    struct NetManPktCmd *npcmd;
    int dmat_id, unaligned, unalignedCache;
    void *payload, *payloadAligned, *payloadCacheAligned;
    volatile struct NetManBD *bd, *bdNext;
 
    (void)arg;
 
    while(1)
    {
        int length, NumTx;
        SleepThread();
 
        NumTx = 0;
        while((length = NetManTxPacketNext(&payload)) > 0)
        {
            IsProcessingTx = 1;
 
            //Write back D-cache, before performing a DMA transfer.
            unaligned = (int)((u32)payload & 15);
            unalignedCache = (int)((u32)payload & 63);
            payloadAligned = (void*)((u32)payload & ~15);
            payloadCacheAligned = (void*)((u32)payload & ~63);
            sceSifWriteBackDCache(payloadCacheAligned, (length + unalignedCache + 63) & ~63);
 
            do {
                //Wait for a spot to be freed up.
                bd = UNCACHED_SEG(&FrameBufferStatus[IOPFrameBufferWrPtr]);
                while(bd->length != 0){}
 
                //Transfer to IOP RAM
                //Determine mode of transfer.
                bdNext = UNCACHED_SEG(&FrameBufferStatus[(IOPFrameBufferWrPtr + 1) % NETMAN_RPC_BLOCK_SIZE]);
                if((NumTx + 1) >= NETMAN_FRAME_GROUP_SIZE || bdNext->length == 0)
                {
                    //Prepare SIFCMD packet
                    //Record the frame length.
                    npcmd = (struct NetManPktCmd*)&cmd.opt;
                    npcmd->length = length;
                    npcmd->offset = unaligned;
                    npcmd->id = IOPFrameBufferWrPtr;
 
                    while((dmat_id = sceSifSendCmd(NETMAN_SIFCMD_ID, &cmd, sizeof(SifCmdHeader_t),
                                    (void*)payloadAligned,
                                    (void*)&IOPFrameBuffer[IOPFrameBufferWrPtr * NETMAN_MAX_FRAME_SIZE],
                                    (length + unaligned + 15) & ~15)) == 0){ };
                } else {
                    //Record the frame length.
                    bd->length = length;
                    bd->offset = unaligned;
 
                    //Normal DMA transfer
                    dmat[0].src = (void*)payloadAligned;
                    dmat[0].dest = (void*)&IOPFrameBuffer[IOPFrameBufferWrPtr * NETMAN_MAX_FRAME_SIZE];
                    dmat[0].size = (length + unaligned + 15) & ~15;
                    dmat[0].attr = 0;
                    dmat[1].src = (void*)&FrameBufferStatus[IOPFrameBufferWrPtr];
                    dmat[1].dest = (void*)&IOPFrameBufferStatus[IOPFrameBufferWrPtr];
                    dmat[1].size = sizeof(struct NetManBD);
                    dmat[1].attr = 0;
 
                    while((dmat_id = sceSifSetDma(dmat, 2)) == 0){ };
                }
 
                //Increase write pointer by one position.
                IOPFrameBufferWrPtr = (IOPFrameBufferWrPtr + 1) % NETMAN_RPC_BLOCK_SIZE;
 
                if((length = NetManTxPacketAfter(&payload)) > 0)
                {   //Write back the cache of the next packet, while waiting.
                    unaligned = (int)((u32)payload & 15);
                    unalignedCache = (int)((u32)payload & 63);
                    payloadAligned = (void*)((u32)payload & ~15);
                    payloadCacheAligned = (void*)((u32)payload & ~63);
                    sceSifWriteBackDCache(payloadCacheAligned, (length + unalignedCache + 63) & ~63);
                }
 
                NumTx++;
 
                while(sceSifDmaStat(dmat_id) >= 0){ };
                NetManTxPacketDeQ();
            } while(length > 0);
 
            IsProcessingTx = 0;
        }
    }
}
 
void NetManRpcNetIFXmit(void)
{
    if(!IsProcessingTx)
        WakeupThread(NETMAN_Tx_threadID);
}
 
int NetManSetMainIF(const char *name)
{
    int result;
 
    if (!NETMAN_rpc_cd.server)
        return -1;
 
    WaitSema(NetManIOSemaID);
 
    strlcpy(TransmitBuffer.netifName, name, sizeof(TransmitBuffer.netifName));
    TransmitBuffer.netifName[NETMAN_NETIF_NAME_MAX_LEN-1] = '\0';
    if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SET_MAIN_NETIF, 0, &TransmitBuffer, NETMAN_NETIF_NAME_MAX_LEN, &ReceiveBuffer, sizeof(s32), NULL, NULL))>=0)
        result=ReceiveBuffer.result;
 
    SignalSema(NetManIOSemaID);
 
    return result;
}
 
int NetManQueryMainIF(char *name)
{
    int result;
    
    if (!NETMAN_rpc_cd.server)
        return -1;
 
    WaitSema(NetManIOSemaID);
 
    if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_QUERY_MAIN_NETIF, 0, NULL, 0, &ReceiveBuffer, sizeof(struct NetManQueryMainNetIFResult), NULL, NULL))>=0)
    {
        if((result=ReceiveBuffer.QueryMainNetIFResult.result) == 0)
        {
            sprintf(name, "%.*s", (int)sizeof(ReceiveBuffer.QueryMainNetIFResult.name), ReceiveBuffer.QueryMainNetIFResult.name);
            name[NETMAN_NETIF_NAME_MAX_LEN-1] = '\0';
        }
    }
 
    SignalSema(NetManIOSemaID);
 
    return result;
}
 
int NetManSetLinkMode(int mode)
{
    int result;
    
    if (!NETMAN_rpc_cd.server)
        return -1;
 
    WaitSema(NetManIOSemaID);
 
    TransmitBuffer.mode = mode;
    if((result=sceSifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SET_LINK_MODE, 0, &TransmitBuffer, sizeof(s32), &ReceiveBuffer, sizeof(s32), NULL, NULL))>=0)
        result=ReceiveBuffer.result;
 
    SignalSema(NetManIOSemaID);
 
    return result;
}