#include <errno.h>
#include <kernel.h>
#include <sifrpc.h>
#include <string.h>
#include <malloc.h>
#include <netman.h>
#include <netman_rpc.h>
#include "rpc_client.h"

Include dependency graph for rpc_client.c:

Functions
static void	deinitCleanup (void)

static void	NETMAN_TxThread (void *arg)

int	NetManInitRPCClient (void)

int	NetManRPCRegisterNetworkStack (void)

int	NetManRPCUnregisterNetworkStack (void)

void	NetManDeinitRPCClient (void)

int	NetManRpcIoctl (unsigned int command, void args, unsigned int args_len, void output, unsigned int length)

void	NetManRpcNetIFXmit (void)

int	NetManSetMainIF (const char *name)

int	NetManQueryMainIF (char *name)

int	NetManSetLinkMode (int mode)

Variables
static SifRpcClientData_t	NETMAN_rpc_cd

void *	_gp

union {
s32 mode

struct NetManIoctl IoctlArgs

char netifName [NETMAN_NETIF_NAME_MAX_LEN]

struct NetManRegNetworkStack NetStack

u8 buffer [128]

}	TransmitBuffer

union {
s32 result

struct NetManRegNetworkStackResult NetStackResult

struct NetManIoctlResult IoctlResult

struct NetManQueryMainNetIFResult QueryMainNetIFResult

u8 buffer [128]

}	ReceiveBuffer

static int	NetManIOSemaID = -1

static int	NETMAN_Tx_threadID = -1

static unsigned char	NETMAN_Tx_ThreadStack [0x1000]

static unsigned short int	IOPFrameBufferWrPtr

static u8 *	IOPFrameBuffer = NULL

static struct NetManBD *	IOPFrameBufferStatus = NULL

static struct NetManBD *	FrameBufferStatus = NULL

static unsigned char	IsInitialized =0

static unsigned char	IsProcessingTx

Function Documentation

◆ deinitCleanup()

static void deinitCleanup ( void )

static

Definition at line 40 of file rpc_client.c.

 {
         if(NetManIOSemaID >= 0)
         {
                 DeleteSema(NetManIOSemaID);
                 NetManIOSemaID = -1;
         }
         if(NETMAN_Tx_threadID >= 0)
         {
                 TerminateThread(NETMAN_Tx_threadID);
                 DeleteThread(NETMAN_Tx_threadID);
                 NETMAN_Tx_threadID = -1;
         }
 }

References DeleteSema(), DeleteThread(), NETMAN_Tx_threadID, NetManIOSemaID, and TerminateThread().

Referenced by NetManDeinitRPCClient(), and NetManInitRPCClient().

◆ NETMAN_TxThread()

static void NETMAN_TxThread ( void * arg )

static

Definition at line 197 of file rpc_client.c.

 {
         static SifCmdHeader_t cmd ALIGNED(64);
         SifDmaTransfer_t dmat[2];
         struct NetManPktCmd *npcmd;
         int dmat_id, length, unaligned, unalignedCache, NumTx;
         void *payload, *payloadAligned, *payloadCacheAligned;
         volatile struct NetManBD *bd, *bdNext;
  
         while(1)
         {
                 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);
                         SifWriteBackDCache(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 = SifSendCmd(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 = SifSetDma(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);
                                         SifWriteBackDCache(payloadCacheAligned, (length + unalignedCache + 63) & ~63);
                                 }
  
                                 NumTx++;
  
                                 while(SifDmaStat(dmat_id) >= 0){ };
                                 NetManTxPacketDeQ();
                         } while(length > 0);
  
                         IsProcessingTx = 0;
                 }
         }
 }

References ALIGNED, SifDmaTransfer_t::attr, SifDmaTransfer_t::dest, FrameBufferStatus, NetManPktCmd::id, IOPFrameBuffer, IOPFrameBufferStatus, IOPFrameBufferWrPtr, IsProcessingTx, NetManPktCmd::length, NetManBD::length, NETMAN_FRAME_GROUP_SIZE, NETMAN_MAX_FRAME_SIZE, NETMAN_RPC_BLOCK_SIZE, NETMAN_SIFCMD_ID, NetManTxPacketAfter(), NetManTxPacketDeQ(), NetManTxPacketNext(), NetManPktCmd::offset, NetManBD::offset, NetManBD::payload, SifDmaStat(), SifSendCmd(), SifSetDma(), SifWriteBackDCache(), SifDmaTransfer_t::size, SleepThread(), SifDmaTransfer_t::src, and UNCACHED_SEG.

Referenced by NetManInitRPCClient().

◆ NetManDeinitRPCClient()

void NetManDeinitRPCClient ( void )

Definition at line 160 of file rpc_client.c.

 {
         if(IsInitialized)
         {
                 WaitSema(NetManIOSemaID);
  
                 SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_DEINIT, 0, NULL, 0, NULL, 0, NULL, NULL);
                 deinitCleanup();
  
                 IsInitialized=0;
         }
 }

References deinitCleanup(), IsInitialized, NETMAN_IOP_RPC_FUNC_DEINIT, NETMAN_rpc_cd, NetManIOSemaID, NULL, SifCallRpc(), and WaitSema().

Referenced by NetManDeinit().

◆ NetManInitRPCClient()

int NetManInitRPCClient ( void )

Definition at line 57 of file rpc_client.c.

                              {
         static const char NetManID[]="NetMan";
         int result;
         ee_sema_t SemaData;
         ee_thread_t thread;
  
         if(!IsInitialized)
         {
                 SemaData.max_count=1;
                 SemaData.init_count=1;
                 SemaData.option=(u32)NetManID;
                 SemaData.attr=0;
                 if((NetManIOSemaID=CreateSema(&SemaData)) < 0)
                 {
                         deinitCleanup();
                         return NetManIOSemaID;
                 }
  
                 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)
                 {
                         IsProcessingTx = 0;
                         StartThread(NETMAN_Tx_threadID, NULL);
                 } else {
                         deinitCleanup();
                         return NETMAN_Tx_threadID;
                 }
  
                 while((SifBindRpc(&NETMAN_rpc_cd, NETMAN_RPC_NUMBER, 0)<0)||(NETMAN_rpc_cd.server==NULL))
                         nopdelay();
  
                 if((result=SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_INIT, 0, NULL, 0, &ReceiveBuffer, sizeof(s32), NULL, NULL))>=0)
                 {
                         if((result=ReceiveBuffer.result) == 0)
                                 IsInitialized=1;
                         else
                                 deinitCleanup();
                 }else{
                         deinitCleanup();
                 }
         }
         else result=0;
  
         return result;
 }

References _gp, ee_sema_t::attr, ee_thread_t::attr, CreateSema(), CreateThread(), deinitCleanup(), ee_thread_t::func, ee_thread_t::gp_reg, ee_sema_t::init_count, ee_thread_t::initial_priority, IsInitialized, IsProcessingTx, ee_sema_t::max_count, NETMAN_IOP_RPC_FUNC_INIT, NETMAN_rpc_cd, NETMAN_RPC_NUMBER, NETMAN_Tx_threadID, NETMAN_Tx_ThreadStack, NETMAN_TxThread(), NetManIOSemaID, nopdelay(), NULL, ee_sema_t::option, ee_thread_t::option, ReceiveBuffer, result, SifRpcClientData_t::server, SifBindRpc(), SifCallRpc(), ee_thread_t::stack, ee_thread_t::stack_size, and StartThread().

Referenced by NetManInit().

◆ NetManQueryMainIF()

int NetManQueryMainIF ( char * name )

Definition at line 309 of file rpc_client.c.

 {
         int result;
         
         if (!IsInitialized)
                 return -1;
  
         WaitSema(NetManIOSemaID);
  
         if((result=SifCallRpc(&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)
                 {
                         strncpy(name, ReceiveBuffer.QueryMainNetIFResult.name, NETMAN_NETIF_NAME_MAX_LEN);
                         name[NETMAN_NETIF_NAME_MAX_LEN-1] = '\0';
                 }
         }
  
         SignalSema(NetManIOSemaID);
  
         return result;
 }

References IsInitialized, NETMAN_IOP_RPC_FUNC_QUERY_MAIN_NETIF, NETMAN_NETIF_NAME_MAX_LEN, NETMAN_rpc_cd, NetManIOSemaID, NULL, ReceiveBuffer, result, SifCallRpc(), SignalSema(), and WaitSema().

◆ NetManRpcIoctl()

int NetManRpcIoctl	(	unsigned int	command,
		void *	args,
		unsigned int	args_len,
		void *	output,
		unsigned int	length
	)

Definition at line 173 of file rpc_client.c.

 {
         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=SifCallRpc(&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;
 }

References NetManIoctl::args, NetManIoctl::args_len, NetManIoctl::command, command, IoctlArgs, NetManIoctl::length, NETMAN_IOP_RPC_FUNC_IOCTL, NETMAN_rpc_cd, NetManIOSemaID, NULL, NetManIoctl::output, ReceiveBuffer, result, SifCallRpc(), SignalSema(), TransmitBuffer, and WaitSema().

Referenced by NetManIoctl().

◆ NetManRpcNetIFXmit()

void NetManRpcNetIFXmit ( void )

Definition at line 284 of file rpc_client.c.

 {
         if(!IsProcessingTx)
                 WakeupThread(NETMAN_Tx_threadID);
 }

References IsProcessingTx, NETMAN_Tx_threadID, and WakeupThread().

Referenced by NetManNetIFXmit().

◆ NetManRPCRegisterNetworkStack()

int NetManRPCRegisterNetworkStack ( void )

Definition at line 109 of file rpc_client.c.

 {
         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=SifCallRpc(&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;
 }

References ENOMEM, FrameBufferStatus, IOPFrameBuffer, IOPFrameBufferStatus, IOPFrameBufferWrPtr, NETMAN_IOP_RPC_FUNC_REG_NETWORK_STACK, NETMAN_RPC_BLOCK_SIZE, NETMAN_rpc_cd, NetManIOSemaID, NULL, ReceiveBuffer, result, SifCallRpc(), SignalSema(), TransmitBuffer, UNCACHED_SEG, and WaitSema().

Referenced by NetManRegisterNetworkStack().

◆ NetManRPCUnregisterNetworkStack()

int NetManRPCUnregisterNetworkStack ( void )

Definition at line 142 of file rpc_client.c.

 {
         int result;
  
         WaitSema(NetManIOSemaID);
  
         result=SifCallRpc(&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;
 }

References FrameBufferStatus, IOPFrameBuffer, IOPFrameBufferWrPtr, NETMAN_IOP_RPC_FUNC_UNREG_NETWORK_STACK, NETMAN_rpc_cd, NetManIOSemaID, NULL, result, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by NetManUnregisterNetworkStack().

◆ NetManSetLinkMode()

int NetManSetLinkMode ( int mode )

Definition at line 332 of file rpc_client.c.

 {
         int result;
         
         if (!IsInitialized)
                 return -1;
  
         WaitSema(NetManIOSemaID);
  
         TransmitBuffer.mode = mode;
         if((result=SifCallRpc(&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;
 }

References IsInitialized, mode, NETMAN_IOP_RPC_FUNC_SET_LINK_MODE, NETMAN_rpc_cd, NetManIOSemaID, NULL, ReceiveBuffer, result, SifCallRpc(), SignalSema(), TransmitBuffer, and WaitSema().

Referenced by ethApplyNetIFConfig().

◆ NetManSetMainIF()

int NetManSetMainIF ( const char * name )

Definition at line 290 of file rpc_client.c.

 {
         int result;
  
         if (!IsInitialized)
                 return -1;
  
         WaitSema(NetManIOSemaID);
  
         strncpy(TransmitBuffer.netifName, name, NETMAN_NETIF_NAME_MAX_LEN);
         TransmitBuffer.netifName[NETMAN_NETIF_NAME_MAX_LEN-1] = '\0';
         if((result=SifCallRpc(&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;
 }