ps2ip.c File Reference

#include <stdio.h>
#include <kernel.h>
#include <iopcontrol.h>
#include <iopheap.h>
#include <debug.h>
#include <netman.h>
#include <ps2ip.h>
#include <sifrpc.h>
#include <loadfile.h>
#include <sbv_patches.h>

Include dependency graph for ps2ip.c:

Go to the source code of this file.

Functions
static int	ethApplyNetIFConfig (int mode)
static void	EthStatusCheckCb (s32 alarm_id, u16 time, void *common)
static int	WaitValidNetState (int(*checkingFunction)(void))
static int	ethGetNetIFLinkStatus (void)
static int	ethWaitValidNetIFLinkState (void)
static int	ethGetDHCPStatus (void)
static int	ethWaitValidDHCPState (void)
static int	ethApplyIPConfig (int use_dhcp, const struct ip4_addr *ip, const struct ip4_addr *netmask, const struct ip4_addr *gateway, const struct ip4_addr *dns)
static void	ethPrintIPConfig (void)
static void	ethPrintLinkStatus (void)
int	main (int argc, char *argv[])

Variables
unsigned char	DEV9_irx []
unsigned int	size_DEV9_irx
unsigned char	SMAP_irx []
unsigned int	size_SMAP_irx
unsigned char	NETMAN_irx []
unsigned int	size_NETMAN_irx

Function Documentation

ethApplyIPConfig()

static int ethApplyIPConfig ( int  use_dhcp, const struct ip4_addr *  ip, const struct ip4_addr *  netmask, const struct ip4_addr *  gateway, const struct ip4_addr *  dns  )

static

Definition at line 102 of file ps2ip.c.

{
        t_ip_info ip_info;
        const ip_addr_t *dns_curr;
        int result;
 
        //SMAP is registered as the "sm0" device to the TCP/IP stack.
        if ((result = ps2ip_getconfig("sm0", &ip_info)) >= 0)
        {
                //Obtain the current DNS server settings.
                dns_curr = dns_getserver(0);
 
                //Check if it's the same. Otherwise, apply the new configuration.
                if ((use_dhcp != ip_info.dhcp_enabled)
                    ||  (!use_dhcp &&
                         (!ip_addr_cmp(ip, (struct ip4_addr *)&ip_info.ipaddr) ||
                         !ip_addr_cmp(netmask, (struct ip4_addr *)&ip_info.netmask) ||
                         !ip_addr_cmp(gateway, (struct ip4_addr *)&ip_info.gw) ||
                         !ip_addr_cmp(dns, dns_curr))))
                {
                        if (use_dhcp)
                        {
                                ip_info.dhcp_enabled = 1;
                        }
                        else
                        {       //Copy over new settings if DHCP is not used.
                                ip_addr_set((struct ip4_addr *)&ip_info.ipaddr, ip);
                                ip_addr_set((struct ip4_addr *)&ip_info.netmask, netmask);
                                ip_addr_set((struct ip4_addr *)&ip_info.gw, gateway);
 
                                ip_info.dhcp_enabled = 0;
                        }
 
                        //Update settings.
                        result = ps2ip_setconfig(&ip_info);
                        if (!use_dhcp)
                                dns_setserver(0, dns);
                }
                else
                        result = 0;
        }
 
        return result;
}

References t_ip_info::dhcp_enabled, dns_getserver(), dns_setserver(), t_ip_info::gw, ip_addr_cmp, ip_addr_set, ip_info, t_ip_info::ipaddr, t_ip_info::netmask, ps2ip_getconfig(), ps2ip_setconfig(), and result.

Referenced by main().

ethApplyNetIFConfig()

static int ethApplyNetIFConfig ( int  mode )

static

Definition at line 32 of file ps2ip.c.

{
        int result;
        //By default, auto-negotiation is used.
        static int CurrentMode = NETMAN_NETIF_ETH_LINK_MODE_AUTO;
 
        if(CurrentMode != mode)
        {       //Change the setting, only if different.
                if((result = NetManSetLinkMode(mode)) == 0)
                        CurrentMode = mode;
        }else
                result = 0;
 
        return result;
}

References mode, NETMAN_NETIF_ETH_LINK_MODE_AUTO, NetManSetLinkMode(), and result.

Referenced by main().

ethGetDHCPStatus()

static int ethGetDHCPStatus ( void  )

static

Definition at line 81 of file ps2ip.c.

{
        t_ip_info ip_info;
        int result;
 
        if ((result = ps2ip_getconfig("sm0", &ip_info)) >= 0)
        {       //Check for a successful state if DHCP is enabled.
                if (ip_info.dhcp_enabled)
                        result = (ip_info.dhcp_status == DHCP_STATE_BOUND || (ip_info.dhcp_status == DHCP_STATE_OFF));
                else
                        result = -1;
        }
 
        return result;
}

References t_ip_info::dhcp_enabled, DHCP_STATE_BOUND, DHCP_STATE_OFF, t_ip_info::dhcp_status, ip_info, ps2ip_getconfig(), and result.

Referenced by ethWaitValidDHCPState().

ethGetNetIFLinkStatus()

static int ethGetNetIFLinkStatus ( void  )

static

Definition at line 71 of file ps2ip.c.

{
        return(NetManIoctl(NETMAN_NETIF_IOCTL_GET_LINK_STATUS, NULL, 0, NULL, 0) == NETMAN_NETIF_ETH_LINK_STATE_UP);
}

References NETMAN_NETIF_ETH_LINK_STATE_UP, NETMAN_NETIF_IOCTL_GET_LINK_STATUS, NetManIoctl(), and NULL.

Referenced by ethWaitValidNetIFLinkState().

ethPrintIPConfig()

static void ethPrintIPConfig ( void  )

static

Definition at line 147 of file ps2ip.c.

{
        t_ip_info ip_info;
        const ip_addr_t *dns_curr;
        u8 ip_address[4], netmask[4], gateway[4], dns[4];
 
        //SMAP is registered as the "sm0" device to the TCP/IP stack.
        if (ps2ip_getconfig("sm0", &ip_info) >= 0)
        {
                //Obtain the current DNS server settings.
                dns_curr = dns_getserver(0);
 
                ip_address[0] = ip4_addr1((struct ip4_addr *)&ip_info.ipaddr);
                ip_address[1] = ip4_addr2((struct ip4_addr *)&ip_info.ipaddr);
                ip_address[2] = ip4_addr3((struct ip4_addr *)&ip_info.ipaddr);
                ip_address[3] = ip4_addr4((struct ip4_addr *)&ip_info.ipaddr);
 
                netmask[0] = ip4_addr1((struct ip4_addr *)&ip_info.netmask);
                netmask[1] = ip4_addr2((struct ip4_addr *)&ip_info.netmask);
                netmask[2] = ip4_addr3((struct ip4_addr *)&ip_info.netmask);
                netmask[3] = ip4_addr4((struct ip4_addr *)&ip_info.netmask);
 
                gateway[0] = ip4_addr1((struct ip4_addr *)&ip_info.gw);
                gateway[1] = ip4_addr2((struct ip4_addr *)&ip_info.gw);
                gateway[2] = ip4_addr3((struct ip4_addr *)&ip_info.gw);
                gateway[3] = ip4_addr4((struct ip4_addr *)&ip_info.gw);
 
                dns[0] = ip4_addr1(dns_curr);
                dns[1] = ip4_addr2(dns_curr);
                dns[2] = ip4_addr3(dns_curr);
                dns[3] = ip4_addr4(dns_curr);
 
                scr_printf(     "IP:\t%d.%d.%d.%d\n"
                                "NM:\t%d.%d.%d.%d\n"
                                "GW:\t%d.%d.%d.%d\n"
                                "DNS:\t%d.%d.%d.%d\n",
                                        ip_address[0], ip_address[1], ip_address[2], ip_address[3],
                                        netmask[0], netmask[1], netmask[2], netmask[3],
                                        gateway[0], gateway[1], gateway[2], gateway[3],
                                        dns[0], dns[1], dns[2], dns[3]);
        }
        else
        {
                scr_printf("Unable to read IP address.\n");
        }
}

References dns_getserver(), t_ip_info::gw, ip4_addr1, ip4_addr2, ip4_addr3, ip4_addr4, ip_info, t_ip_info::ipaddr, t_ip_info::netmask, ps2ip_getconfig(), and scr_printf().

Referenced by main().

ethPrintLinkStatus()

static void ethPrintLinkStatus ( void  )

static

Definition at line 194 of file ps2ip.c.

{
        int mode, baseMode;
 
        //SMAP is registered as the "sm0" device to the TCP/IP stack.
        scr_printf("Link:\t");
        if (NetManIoctl(NETMAN_NETIF_IOCTL_GET_LINK_STATUS, NULL, 0, NULL, 0) == NETMAN_NETIF_ETH_LINK_STATE_UP)
                scr_printf("Up\n");
        else
                scr_printf("Down\n");
 
        scr_printf("Mode:\t");
        mode = NetManIoctl(NETMAN_NETIF_IOCTL_ETH_GET_LINK_MODE, NULL, 0, NULL, 0);
 
        //NETMAN_NETIF_ETH_LINK_MODE_PAUSE is a flag, so file it off first.
        baseMode = mode & (~NETMAN_NETIF_ETH_LINK_DISABLE_PAUSE);
        switch(baseMode)
        {
                case NETMAN_NETIF_ETH_LINK_MODE_10M_HDX:
                        scr_printf("10M HDX");
                        break;
                case NETMAN_NETIF_ETH_LINK_MODE_10M_FDX:
                        scr_printf("10M FDX");
                        break;
                case NETMAN_NETIF_ETH_LINK_MODE_100M_HDX:
                        scr_printf("100M HDX");
                        break;
                case NETMAN_NETIF_ETH_LINK_MODE_100M_FDX:
                        scr_printf("100M FDX");
                        break;
                default:
                        scr_printf("Unknown");
        }
        if(!(mode & NETMAN_NETIF_ETH_LINK_DISABLE_PAUSE))
                scr_printf(" with ");
        else
                scr_printf(" without ");
        scr_printf("Flow Control\n");
}

References mode, NETMAN_NETIF_ETH_LINK_DISABLE_PAUSE, NETMAN_NETIF_ETH_LINK_MODE_100M_FDX, NETMAN_NETIF_ETH_LINK_MODE_100M_HDX, NETMAN_NETIF_ETH_LINK_MODE_10M_FDX, NETMAN_NETIF_ETH_LINK_MODE_10M_HDX, NETMAN_NETIF_ETH_LINK_STATE_UP, NETMAN_NETIF_IOCTL_ETH_GET_LINK_MODE, NETMAN_NETIF_IOCTL_GET_LINK_STATUS, NetManIoctl(), NULL, and scr_printf().

Referenced by main().

EthStatusCheckCb()

static void EthStatusCheckCb ( s32  alarm_id, u16  time, void *  common  )

static

Definition at line 48 of file ps2ip.c.

{
        iWakeupThread(*(int*)common);
}

References iWakeupThread().

Referenced by WaitValidNetState().

ethWaitValidDHCPState()

static int ethWaitValidDHCPState ( void  )

static

Definition at line 97 of file ps2ip.c.

{
        return WaitValidNetState(&ethGetDHCPStatus);
}

References ethGetDHCPStatus(), and WaitValidNetState().

Referenced by main().

ethWaitValidNetIFLinkState()

static int ethWaitValidNetIFLinkState ( void  )

static

Definition at line 76 of file ps2ip.c.

{
        return WaitValidNetState(&ethGetNetIFLinkStatus);
}

References ethGetNetIFLinkStatus(), and WaitValidNetState().

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 234 of file ps2ip.c.

{
        struct ip4_addr IP, NM, GW, DNS;
        int EthernetLinkMode;
 
        //Reboot IOP
        SifInitRpc(0);
        while(!SifIopReset("", 0)){};
        while(!SifIopSync()){};
 
        //Initialize SIF services
        SifInitRpc(0);
        SifLoadFileInit();
        SifInitIopHeap();
        sbv_patch_enable_lmb();
 
        //Load modules
        SifExecModuleBuffer(DEV9_irx, size_DEV9_irx, 0, NULL, NULL);
        SifExecModuleBuffer(NETMAN_irx, size_NETMAN_irx, 0, NULL, NULL);
        SifExecModuleBuffer(SMAP_irx, size_SMAP_irx, 0, NULL, NULL);
 
        //Initialize NETMAN
        NetManInit();
 
        init_scr();
 
        //The network interface link mode/duplex can be set.
        EthernetLinkMode = NETMAN_NETIF_ETH_LINK_MODE_AUTO;
 
        //Attempt to apply the new link setting.
        if(ethApplyNetIFConfig(EthernetLinkMode) != 0) {
                scr_printf("Error: failed to set link mode.\n");
                goto end;
        }
 
        //Initialize IP address.
        //In this example, DHCP is enabled, hence the IP, NM, GW and DNS fields are cleared to 0..
        ip4_addr_set_zero(&IP);
        ip4_addr_set_zero(&NM);
        ip4_addr_set_zero(&GW);
        ip4_addr_set_zero(&DNS);
 
        //Initialize the TCP/IP protocol stack.
        ps2ipInit(&IP, &NM, &GW);
 
        //Enable DHCP
        ethApplyIPConfig(1, &IP, &NM, &GW, &DNS);
 
        //Wait for the link to become ready.
        scr_printf("Waiting for connection...\n");
        if(ethWaitValidNetIFLinkState() != 0) {
                scr_printf("Error: failed to get valid link status.\n");
                goto end;
        }
 
        scr_printf("Waiting for DHCP lease...");
        //Wait for DHCP to initialize, if DHCP is enabled.
        if (ethWaitValidDHCPState() != 0)
        {
                scr_printf("DHCP failed\n.");
                goto end;
        }
        scr_printf("done!\n");
 
        scr_printf("Initialized:\n");
        ethPrintLinkStatus();
        ethPrintIPConfig();
 
        //At this point, network support has been initialized and the PS2 can be pinged.
        SleepThread();
 
end:
        //To cleanup, just call these functions.
        ps2ipDeinit();
        NetManDeinit();
 
        //Deinitialize SIF services
        SifExitRpc();
 
        return 0;
}

References DEV9_irx, ethApplyIPConfig(), ethApplyNetIFConfig(), ethPrintIPConfig(), ethPrintLinkStatus(), ethWaitValidDHCPState(), ethWaitValidNetIFLinkState(), init_scr(), ip4_addr_set_zero, NETMAN_irx, NETMAN_NETIF_ETH_LINK_MODE_AUTO, NetManDeinit(), NetManInit(), NULL, ps2ipDeinit(), ps2ipInit(), sbv_patch_enable_lmb(), scr_printf(), SifExecModuleBuffer(), SifExitRpc(), SifInitIopHeap(), SifInitRpc(), SifIopReset(), SifIopSync(), SifLoadFileInit(), size_DEV9_irx, size_NETMAN_irx, size_SMAP_irx, SleepThread(), and SMAP_irx.

WaitValidNetState()

static int WaitValidNetState ( int(*)(void)  checkingFunction )

static

Definition at line 53 of file ps2ip.c.

{
        int ThreadID, retry_cycles;
 
        // Wait for a valid network status;
        ThreadID = GetThreadId();
        for(retry_cycles = 0; checkingFunction() == 0; retry_cycles++)
        {       //Sleep for 1000ms.
                SetAlarm(1000 * 16, &EthStatusCheckCb, &ThreadID);
                SleepThread();
 
                if(retry_cycles >= 10)  //10s = 10*1000ms
                        return -1;
        }
 
        return 0;
}

References EthStatusCheckCb(), GetThreadId(), SetAlarm(), and SleepThread().

Referenced by ethWaitValidDHCPState(), and ethWaitValidNetIFLinkState().

Variable Documentation

DEV9_irx

unsigned char DEV9_irx[]

extern

NETMAN_irx

unsigned char NETMAN_irx[]

extern

size_DEV9_irx

unsigned int size_DEV9_irx

extern

size_NETMAN_irx

unsigned int size_NETMAN_irx

extern

size_SMAP_irx

unsigned int size_SMAP_irx

extern

SMAP_irx

unsigned char SMAP_irx[]

extern