#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"

Include dependency graph for rpc_server.c:

Functions
static void	NETMAN_RxThread (void *arg)

static void	ClearBufferLen (int index, void packet, void payload)

static s32	HandleRxEvent (s32 channel)

int	NetManRPCAllocRxBuffers (void)

static void *	NETMAN_EE_RPC_Handler (int fnum, void *buffer, int NumBytes)

static void	NETMAN_RPC_Thread (void *arg)

int	NetManInitRPCServer (void)

void	NetManDeinitRPCServer (void)

Variables
static int	NETMAN_RpcSvr_threadID =-1

static int	NETMAN_Rx_threadID =-1

static int	SifHandlerID =-1

static unsigned char	NETMAN_RpcSvr_ThreadStack [0x1000]

static unsigned char	NETMAN_Rx_ThreadStack [0x1000]

static unsigned char	IsInitialized =0

static unsigned char	IsProcessingRx

static struct NetManBD *	FrameBufferStatus = NULL

static struct NetManBD *	RxIOPFrameBufferStatus

static unsigned short int	RxBufferRdPtr

static unsigned short int	RxBufferNextRdPtr

void *	_gp

static struct t_SifRpcDataQueue	cb_queue

static struct t_SifRpcServerData	cb_srv

Function Documentation

◆ ClearBufferLen()

static void ClearBufferLen	(	int	index,
		void *	packet,
		void *	payload
	)

static

Definition at line 26 of file rpc_server.c.

 {
         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(SifSetDma(&dmat, 1) == 0){ };
 }

References SifDmaTransfer_t::attr, SifDmaTransfer_t::dest, FrameBufferStatus, index, NetManBD::length, NetManBD::packet, packet, NetManBD::payload, RxIOPFrameBufferStatus, SifSetDma(), SifDmaTransfer_t::size, SifDmaTransfer_t::src, and UNCACHED_SEG.

Referenced by NETMAN_RxThread(), and NetManRPCAllocRxBuffers().

◆ HandleRxEvent()

static s32 HandleRxEvent ( s32 channel )

static

Definition at line 44 of file rpc_server.c.

 {
         struct NetManBD *bd;
  
         bd = UNCACHED_SEG(&FrameBufferStatus[RxBufferNextRdPtr]);
         if(bd->length > 0)
         {
                 iSifSetDChain();
  
                 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;
 }

References ExitHandler, FrameBufferStatus, iSifSetDChain(), IsProcessingRx, iWakeupThread(), NetManBD::length, NETMAN_Rx_threadID, RxBufferNextRdPtr, and UNCACHED_SEG.

◆ NETMAN_EE_RPC_Handler()

static void* NETMAN_EE_RPC_Handler	(	int	fnum,
		void *	buffer,
		int	NumBytes
	)

static

Definition at line 85 of file rpc_server.c.

 {
         ee_thread_t thread;
         void *result;
  
         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;
 }

Referenced by NETMAN_RPC_Thread().

◆ NETMAN_RPC_Thread()

static void NETMAN_RPC_Thread ( void * arg )

static

Definition at line 153 of file rpc_server.c.

 {
         static unsigned char cb_rpc_buffer[64] __attribute__((aligned(64)));
  
         SifSetRpcQueue(&cb_queue, NETMAN_RpcSvr_threadID);
         SifRegisterRpc(&cb_srv, NETMAN_RPC_NUMBER, &NETMAN_EE_RPC_Handler, cb_rpc_buffer, NULL, NULL, &cb_queue);
         SifRpcLoop(&cb_queue);
 }

References cb_queue, cb_srv, NETMAN_EE_RPC_Handler(), NETMAN_RPC_NUMBER, NETMAN_RpcSvr_threadID, NULL, SifRegisterRpc(), SifRpcLoop(), and SifSetRpcQueue().

Referenced by NetManInitRPCServer().

◆ NETMAN_RxThread()

static void NETMAN_RxThread ( void * arg )

static

Definition at line 162 of file rpc_server.c.

 {
         volatile struct NetManBD *bd;
         void *payload, *payloadNext;
         u32 PacketLength, PacketLengthAligned;
         void *packet, *packetNext;
         u8 run;
  
         while(1)
         {
                 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;
                 SifWriteBackDCache(payload, PacketLengthAligned);
                 NetManNetProtStackReallocRxPacket(packet, PacketLength);
                 NetManNetProtStackEnQRxPacket(packet);
         }
 }

References ClearBufferLen(), DI, EI, FrameBufferStatus, IsProcessingRx, NetManBD::length, NETMAN_NETIF_FRAME_SIZE, NETMAN_RPC_BLOCK_SIZE, NetManNetProtStackAllocRxPacket(), NetManNetProtStackEnQRxPacket(), NetManNetProtStackReallocRxPacket(), NULL, NetManBD::packet, packet, NetManBD::payload, RxBufferNextRdPtr, RxBufferRdPtr, SifWriteBackDCache(), SleepThread(), and UNCACHED_SEG.

◆ NetManDeinitRPCServer()

void NetManDeinitRPCServer ( void )

Definition at line 236 of file rpc_server.c.

 {
         if(IsInitialized)
         {
                 SifRemoveRpc(&cb_srv, &cb_queue);
                 SifRemoveRpcQueue(&cb_queue);
                 RemoveDmacHandler(DMAC_SIF0, SifHandlerID);
  
                 if(NETMAN_RpcSvr_threadID>=0)
                 {
                         TerminateThread(NETMAN_RpcSvr_threadID);
                         DeleteThread(NETMAN_RpcSvr_threadID);
                         NETMAN_RpcSvr_threadID = -1;
                 }
  
                 if(NETMAN_Rx_threadID>=0)
                 {
                         TerminateThread(NETMAN_Rx_threadID);
                         DeleteThread(NETMAN_Rx_threadID);
                         NETMAN_Rx_threadID = -1;
                 }
  
                 IsInitialized=0;
         }
 }

References cb_queue, cb_srv, DeleteThread(), DMAC_SIF0, IsInitialized, NETMAN_RpcSvr_threadID, NETMAN_Rx_threadID, RemoveDmacHandler(), SifHandlerID, SifRemoveRpc(), SifRemoveRpcQueue(), and TerminateThread().

Referenced by NetManDeinit().

◆ NetManInitRPCServer()

int NetManInitRPCServer ( void )

Definition at line 209 of file rpc_server.c.

 {
         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;
 }

References _gp, ee_thread_t::attr, CreateThread(), ee_thread_t::func, ee_thread_t::gp_reg, ee_thread_t::initial_priority, IsInitialized, NETMAN_RPC_Thread(), NETMAN_RpcSvr_threadID, NETMAN_RpcSvr_ThreadStack, NULL, ee_thread_t::option, result, ee_thread_t::stack, ee_thread_t::stack_size, and StartThread().

Referenced by NetManInit().

◆ NetManRPCAllocRxBuffers()

int NetManRPCAllocRxBuffers ( void )

Definition at line 65 of file rpc_server.c.

 {
         int i;
         void *packet, *payload;
  
         for(i = 0; i < NETMAN_RPC_BLOCK_SIZE; i++)
         {
                 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;
 }