Merge branch 'master' of github.com:elua/elua

.gitignore

@@ -11,4 +11,8 @@ inc/romfiles.h
 .sconf_temp/
 .sconsign.dblite
 config.log
+mux*
+rfs_server*
+doc/dist
+doc/cache
 

SConstruct

@@ -1,5 +1,6 @@
 import os, sys, shutil, string
 import platform as syspl
+import glob
 
 # Helper: "normalize" a name to make it a suitable C macro name
 def cnorm( name ):
@@ -116,89 +117,6 @@ board_list = { 'SAM7-EX256' : [ 'AT91SAM7X256', 'AT91SAM7X512' ],
 
 cpu_list = sum([board_list[i] for i in board_list],[])
 
-
-# ROMFS file list "groups"
-# To include a file in a ROMFS build, include it in a group here (or create one
-# if you need) and make sure the group is included on your platform's file_list
-# definition (right after this).
-
-# The following table will be left here just as an example
-# eLua examples were removed from the distro since v0.8
-#romfs = { 'bisect' : [ 'bisect.lua' ],
-#          'hangman' : [ 'hangman.lua' ],
-#          'lhttpd' : [ 'index.pht', 'lhttpd.lua', 'test.lua' ],
-#          'led' : [ 'led.lua' ],
-#          'piano' : [ 'piano.lua' ],
-#          'pwmled' : [ 'pwmled.lua' ],
-#          'tvbgone' : [ 'tvbgone.lua', 'codes.bin' ],
-#          'hello' : [ 'hello.lua' ],
-#          'info' : [ 'info.lua' ],
-#          'morse' : [ 'morse.lua' ],
-#          'dualpwm' : [ 'dualpwm.lua' ],
-#          'adcscope' : [ 'adcscope.lua' ],
-#          'adcpoll' : [ 'adcpoll.lua' ],
-#          'life' : [ 'life.lua' ],
-#          'logo' : ['logo.lua', 'logo.bin' ],
-#          'pong' : [ 'pong.lua' ],
-#          'spaceship' : [ 'spaceship.lua' ],
-#          'tetrives' : [ 'tetrives.lua' ],
-#          'snake' : [ 'snake.lua' ],
-#          'dataflash' : [ 'dataflash.lua' ],
-#          'pachube' : [ 'pachube_demo.lua' ],
-#          'inttest' : [ 'inttest.lua' ]
-#        }
-
-romfs = {
-        }
-
-# List of board/romfs data combinations
-# The following table will be left here just as an example
-# eLua examples were removed from the distro since v0.8
-#file_list = { 'SAM7-EX256' : [ 'bisect', 'hangman' , 'led', 'piano', 'hello', 'info', 'morse' ],
-#              'EK-LM3S1968' : [ 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'spaceship', 'tetrives', 'snake' ],
-#              'EK-LM3S8962' : [ 'lhttpd','bisect', 'led', 'pachube' ],
-#              'EK-LM3S6965' : [ 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'tetrives' ],
-#              'EK-LM3S9B92' : [ 'bisect', 'hangman', 'led', 'pwmled', 'hello', 'info', 'adcscope','adcpoll', 'life' ],
-#              'STR9-COMSTICK' : [ 'bisect', 'hangman', 'led', 'hello', 'info' ],
-#              'STR-E912' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'piano', 'adcscope' ],
-#              'PC' : [ 'bisect', 'hello', 'info', 'life', 'hangman' ],
-#              'SIM' : [ 'bisect', 'hello', 'info', 'life', 'hangman' ],
-#              'LPC-H2888' : [ 'bisect', 'hangman', 'led', 'hello', 'info' ],
-#              'MOD711' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'dualpwm' ],
-#              'STM3210E-EVAL' : [ 'bisect', 'hello', 'info' ],
-#              'ATEVK1100' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'dataflash' ],
-#              'ATEVK1101' : [ 'bisect', 'led', 'hello', 'info', 'dataflash' ],
-#              'ET-STM32' : [ 't' ],
-#              'EAGLE-100' : [ 'bisect', 'hangman', 'lhttpd', 'led', 'hello', 'info' ],
-#              'ELUA-PUC' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'pwmled', 'adcscope', 'adcpoll', 'inttest' ],
-#              'MBED' : [ 'bisect', 'hangman', 'hello', 'info', 'led', 'pwmled', 'dualpwm', 'life', 'adcscope', 'adcpoll' ],
-#              'MIZAR32' : [ ],
-#              'NETDUINO': [ ],
-#}
-
-file_list = { 'SAM7-EX256' : [ ],
-              'EK-LM3S1968' : [ ],
-              'EK-LM3S8962' : [ ],
-              'EK-LM3S6965' : [ ],
-              'EK-LM3S9B92' : [ ],
-              'STR9-COMSTICK' : [ ],
-              'STR-E912' : [ ],
-              'PC' : [ ],
-              'SIM' : [ ],
-              'LPC-H2888' : [ ],
-              'MOD711' : [ ],
-              'STM3210E-EVAL' : [ ],
-              'ATEVK1100' : [ ],
-              'ATEVK1101' : [ ],
-              'ET-STM32' : [ ],
-              'EAGLE-100' : [ ],
-              'ELUA-PUC' : [ ],
-              'MBED' : [ ],
-              'MIZAR32' : [ ],
-              'NETDUINO': [ ],
-}
-
-
 comp = Environment( tools = [],
                     OBJSUFFIX = ".o",
                     PROGSUFFIX = ".elf",
@@ -469,12 +387,11 @@ if not GetOption( 'help' ):
   # Make ROM File System first
   if not GetOption( 'clean' ):
     print "Building ROM File System..."
-    romdir = "romfs"
     flist = []
-    for sample in file_list[ comp['board'] ]:
+    for sample in glob.glob("romfs/*"):
-      flist += romfs[ sample ]
+      flist += [ sample ]
     import mkfs
-    mkfs.mkfs( romdir, "romfiles", flist, comp['romfs'], compcmd )
+    mkfs.mkfs( ".", "romfiles", flist, comp['romfs'], compcmd )
     print
     if os.path.exists( "inc/romfiles.h" ): 
       os.remove( "inc/romfiles.h" )

build_elua.lua

@@ -205,96 +205,6 @@ for k, v in pairs( board_list ) do
   end
 end
 
--- ROMFS file list "groups"
--- To include a file in a ROMFS build, include it in a group here (or create one
--- if you need) and make sure the group is included on your platform's file_list
--- definition (right after this).
-
--- The following table will be left here just as an example
--- eLua examples were removed from the distro since v0.8
---[[
-local romfs = 
-{
-  bisect = { 'bisect.lua' },
-  hangman = { 'hangman.lua' },
-  lhttpd = { 'index.pht', 'lhttpd.lua', 'test.lua' },
-  led = { 'led.lua' },
-  piano = { 'piano.lua' },
-  pwmled = { 'pwmled.lua' },
-  tvbgone = { 'tvbgone.lua', 'codes.bin' },
-  hello = { 'hello.lua' },
-  info = { 'info.lua' },
-  morse = { 'morse.lua' },
-  dualpwm = { 'dualpwm.lua' },
-  adcscope = { 'adcscope.lua' },
-  adcpoll = { 'adcpoll.lua' },
-  life = { 'life.lua' },
-  logo = {'logo.lua', 'logo.bin' },
-  pong = { 'pong.lua' },
-  spaceship = { 'spaceship.lua' },
-  tetrives = { 'tetrives.lua' },
-  snake = { 'snake.lua' },
-  dataflash = { 'dataflash.lua' },
-  pachube = { 'pachube_demo.lua' },
-  inttest = { 'inttest.lua' }
-}
---]]
-
-local romfs = {}
-
--- List of board/romfs data combinations
--- The following table will be left here just as an example
--- eLua examples were removed from the distro since v0.8
---[[
-local file_list = 
-{ 
-  [ 'SAM7-EX256' ] = { 'bisect', 'hangman' , 'led', 'piano', 'hello', 'info', 'morse' },
-  [ 'EK-LM3S1968' ]  = { 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'spaceship', 'tetrives', 'snake' },
-  [ 'EK-LM3S8962' ]  = { 'lhttpd','bisect', 'led', 'pachube' },
-  [ 'EK-LM3S6965' ]  = { 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'tetrives' },
-  [ 'EK-LM3S9B92' ]  = { 'bisect', 'hangman', 'led', 'pwmled', 'hello', 'info', 'adcscope','adcpoll', 'life' },
-  [ 'STR9-COMSTICK' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info' },
-  [ 'STR-E912' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info', 'piano', 'adcscope' },
-  [ 'PC' ]  = { 'bisect', 'hello', 'info', 'life', 'hangman' },
-  [ 'SIM' ]  = { 'bisect', 'hello', 'info', 'life', 'hangman' },
-  [ 'LPC-H2888' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info' },
-  [ 'MOD711' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info', 'dualpwm' },
-  [ 'STM3210E-EVAL' ]  = { 'bisect', 'hello', 'info' },
-  [ 'ATEVK1100' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info', 'dataflash' },
-  [ 'ATEVK1101' ]  = { 'bisect', 'led', 'hello', 'info', 'dataflash' },
-  [ 'ET-STM32' ]  = { 't' },
-  [ 'EAGLE-100' ]  = { 'bisect', 'hangman', 'lhttpd', 'led', 'hello', 'info' },
-  [ 'ELUA-PUC' ]  = { 'bisect', 'hangman', 'led', 'hello', 'info', 'pwmled', 'adcscope', 'adcpoll', 'inttest' },
-  [ 'MBED' ]  = { 'bisect', 'hangman', 'hello', 'info', 'led', 'pwmled', 'dualpwm', 'life', 'adcscope', 'adcpoll' },
-  [ 'MIZAR32' ]  = { },
-  [ 'NETDUINO' ] = { },
-}
---]]
-
-local file_list = 
-{ 
-  [ 'SAM7-EX256' ]      = {},
-  [ 'EK-LM3S1968' ]     = {},
-  [ 'EK-LM3S8962' ]     = {},
-  [ 'EK-LM3S6965' ]     = {},
-  [ 'EK-LM3S9B92' ]     = {},
-  [ 'STR9-COMSTICK' ]   = {},
-  [ 'STR-E912' ]        = {},
-  [ 'PC' ]              = {},
-  [ 'SIM' ]             = {},
-  [ 'LPC-H2888' ]       = {},
-  [ 'MOD711' ]          = {},
-  [ 'STM3210E-EVAL' ]   = {},
-  [ 'ATEVK1100' ]       = {},
-  [ 'ATEVK1101' ]       = {},
-  [ 'ET-STM32' ]        = {},
-  [ 'EAGLE-100' ]       = {},
-  [ 'ELUA-PUC' ]        = {},
-  [ 'MBED' ]            = {},
-  [ 'MIZAR32' ]         = {},
-  [ 'NETDUINO']         = {},
-}
-
 builder:add_option( 'target', 'build "regular" float lua or integer-only "lualong"', 'lua', { 'lua', 'lualong' } )
 builder:add_option( 'cpu', 'build for the specified CPU (board will be inferred, if possible)', 'auto', { cpu_list, 'auto' } )
 builder:add_option( 'allocator', 'select memory allocator', 'auto', { 'newlib', 'multiple', 'simple', 'auto' } )
@@ -489,13 +399,10 @@ source_files = source_files .. uip_files .. specific_files
 -- ROM file system builder
 local function make_romfs()
   print "Building ROM file system ..."
-  local romdir = "romfs"
   local flist = {}
-  for _, sample in pairs( file_list[ comp.board:upper() ] ) do
+  flist = utils.string_to_table( utils.get_files( 'romfs', function( fname ) return not fname:find( "%.gitignore" ) end ) )
-    table.insert( flist, romfs[ sample ] )
-  end
   flist = utils.linearize_array( flist )  
-  if not mkfs.mkfs( romdir, "romfiles", flist, comp.romfs, fscompcmd ) then return -1 end
+  if not mkfs.mkfs( ".", "romfiles", flist, comp.romfs, fscompcmd ) then return -1 end
   if utils.is_file( "inc/romfiles.h" ) then
     -- Read both the old and the new file
     local oldfile = io.open( "inc/romfiles.h", "rb" )

inc/desktop/platform_conf.h

@@ -10,7 +10,10 @@
 #define LUARPC_ENABLE_SERIAL
 
 #define LUA_PLATFORM_LIBS_ROM \
-  _ROM( AUXLIB_RPC, luaopen_rpc, rpc_map )
+  _ROM( AUXLIB_RPC, luaopen_rpc, rpc_map )\
+  _ROM( AUXLIB_BITARRAY, luaopen_bitarray, bitarray_map )\
+  _ROM( AUXLIB_PACK, luaopen_pack, pack_map )\
+  _ROM( AUXLIB_BIT, luaopen_bit, bit_map )
 #endif
 
 

mux.lua

@@ -6,13 +6,13 @@ builder:init( args )
 builder:set_build_mode( builder.BUILD_DIR_LINEARIZED )
 
 local flist = "main.c"
-local rfs_flist = "main.c server.c log.c deskutils.c"
+local rfs_flist = "main.c server.c log.c deskutils.c rfs_transports.c"
 local cdefs = "RFS_UDP_TRANSPORT RFS_INSIDE_MUX_MODE"
 local socklib
 if utils.is_windows() then
   cdefs = cdefs .. " WIN32_BUILD"
   rfs_flist = rfs_flist .. " os_io_win32.c serial_win32.c net_win32.c"
-  exeprefix = "exe"
+  exeprefix = ".exe"
   socklib = "ws2_32"
 else
   rfs_flist = rfs_flist .. " os_io_posix.c serial_posix.c net_posix.c"

mux.py

@@ -1,7 +1,7 @@
 import os, sys, platform
 
 flist = "main.c"
-rfs_flist = "main.c server.c log.c deskutils.c"
+rfs_flist = "main.c server.c log.c deskutils.c rfs_transports.c"
 cdefs = "-DRFS_UDP_TRANSPORT -DRFS_INSIDE_MUX_MODE"
 socklib = ''
 ptlib = ''

mux_src/main.c

@@ -145,7 +145,12 @@ static int parse_transport( const char* s )
 #define FIRST_SERVICE_IDX     3
 #define MIN_ARGC_COUNT        4
 
+#ifdef _MSC_VER
+#define strcasecmp _stricmp
+int main( int argc, char *argv[] )
+#else
 int main( int argc, char **argv )
+#endif
 {
   unsigned i;
   SERVICE_DATA *tservice;
@@ -165,9 +170,9 @@ int main( int argc, char **argv )
     log_err( "Usage: %s <mode> <transport> <vcom1> [<vcom2>] ... [<vcomn>] [-v]\n", argv[ 0 ] );
     log_err( "  mode: \n" );
     log_err( "    'mux':                 serial multiplexer mode\n" );
-    log_err( "    'rfsmux:<directory>:   combined RFS and multiplexer mode.\n" );
+    log_err( "    'rfsmux:<directory>':  combined RFS and multiplexer mode.\n" );
-    log_err( "  transport: '<port>,<baud>,<flow> ('flow' specifies the flow control type and can be 'none' or 'rtscts').\n" );
+    log_err( "  transport: '<port>,<baud>,<flow>' ('flow' specifies the flow control type and can be 'none' or 'rtscts').\n" );
-    log_err( "  vcom1, ..., vcomn: multiplexer serial ports." );
+    log_err( "  vcom1, ..., vcomn: multiplexer serial ports.\n" );
     log_err( "  Use '-v' for verbose output.\n" );
     return 1;
   }

mux_src/mux.vcxproj

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\rfs_server_src\deskutils.h" />
+    <ClInclude Include="..\rfs_server_src\log.h" />
+    <ClInclude Include="..\rfs_server_src\net.h" />
+    <ClInclude Include="..\rfs_server_src\rfs.h" />
+    <ClInclude Include="..\rfs_server_src\rfs_transports.h" />
+    <ClInclude Include="..\rfs_server_src\serial.h" />
+    <ClInclude Include="..\rfs_server_src\server.h" />
+    <ClInclude Include="config.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\rfs_server_src\deskutils.c" />
+    <ClCompile Include="..\rfs_server_src\log.c" />
+    <ClCompile Include="..\rfs_server_src\net_win32.c" />
+    <ClCompile Include="..\rfs_server_src\os_io_win32.c" />
+    <ClCompile Include="..\rfs_server_src\rfs_transports.c" />
+    <ClCompile Include="..\rfs_server_src\serial_win32.c" />
+    <ClCompile Include="..\rfs_server_src\server.c" />
+    <ClCompile Include="..\src\eluarpc.c" />
+    <ClCompile Include="..\src\remotefs\remotefs.c" />
+    <ClCompile Include="main.c" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{68EE7183-C1E2-41A9-AADA-3456B4773685}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>mux</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\rfs_server_src;..\inc;..\inc\remotefs;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\rfs_server_src;..\inc;..\inc\remotefs;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32_BUILD;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <EntryPointSymbol>
+      </EntryPointSymbol>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32_BUILD;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

mux_src/mux.vcxproj.filters

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\rfs_server_src\deskutils.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\server.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\eluarpc.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\log.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="main.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\net_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\os_io_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\remotefs\remotefs.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\rfs_transports.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\rfs_server_src\serial_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="config.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\deskutils.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\log.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\net.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\rfs.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\rfs_transports.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\serial.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\rfs_server_src\server.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="source">
+      <UniqueIdentifier>{edd07642-0c4f-4725-9e8f-641858b5e631}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="headers">
+      <UniqueIdentifier>{7234826d-2dcc-404c-9472-998da14f1314}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

rfs_server.lua

@@ -20,12 +20,12 @@ if utils.is_windows() then
     print "SIM target not supported under Windows"
     os.exit( 1 )
   end
-  flist = "main.c server.c os_io_win32.c log.c net_win32.c serial_win32.c deskutils.c"
+  flist = "main.c server.c os_io_win32.c log.c net_win32.c serial_win32.c deskutils.c rfs_transports.c"
   cdefs = cdefs .. " WIN32_BUILD"
-  exeprefix = "exe"
+  exeprefix = ".exe"
   socklib = 'ws2_32'
 else
-  flist = mainname .. " server.c os_io_posix.c log.c net_posix.c serial_posix.c deskutils.c"
+  flist = mainname .. " server.c os_io_posix.c log.c net_posix.c serial_posix.c deskutils.c rfs_transports.c"
 end
 
 local output = sim == 0 and 'rfs_server' or 'rfs_sim_server'

rfs_server.py

@@ -13,12 +13,12 @@ if platform.system() == "Windows":
   if sim == '1':
     print "SIM target not supported under Windows"
     os.exit( 1 )
-  flist = "main.c server.c os_io_win32.c log.c net_win32.c serial_win32.c deskutils.c"
+  flist = "main.c server.c os_io_win32.c log.c net_win32.c serial_win32.c deskutils.c rfs_transports.c"
   cdefs = cdefs + " -DWIN32_BUILD"
   exeprefix = ".exe"
   socklib = '-lws2_32'
 else:
-  flist = "%s server.c os_io_posix.c log.c net_posix.c serial_posix.c deskutils.c" % mainname
+  flist = "%s server.c os_io_posix.c log.c net_posix.c serial_posix.c deskutils.c rfs_transports.c" % mainname
   exeprefix = ""
 
 if sim == '0':

rfs_server_src/main.c

@@ -15,413 +15,7 @@
 #include <string.h>
 #include "rfs.h"
 #include "deskutils.h"
-
+#include "rfs_transports.h"
-// ****************************************************************************
-// Local definitions
-
-typedef void ( *p_read_request )( void );
-typedef void ( *p_send_response )( void );
-typedef void ( *p_cleanup )( void );
-typedef struct
-{
-  p_read_request f_read_request;
-  p_send_response f_send_response;
-  p_cleanup f_cleanup;
-} RFS_TRANSPORT_DATA;
-
-// ****************************************************************************
-// Local variables
-
-#define   MAX_PACKET_SIZE     4096
-static u8 rfs_buffer[ MAX_PACKET_SIZE + ELUARPC_WRITE_REQUEST_EXTRA ];
-static const RFS_TRANSPORT_DATA *p_transport_data; 
-
-// ****************************************************************************
-// Serial transport implementation
-
-static ser_handler ser;
-
-static void flush_serial()
-{
-  // Flush all data in serial port
-  while( ser_read_byte( ser, SER_NO_TIMEOUT ) != -1 );
-}
-
-// Read a packet from the serial port
-static void ser_read_request_packet()
-{
-  u16 temp16;
-  u32 readbytes;
-
-  while( 1 )
-  {
-    // First read the length
-    if( ( readbytes = ser_read( ser, rfs_buffer, ELUARPC_START_OFFSET, SER_INF_TIMEOUT ) ) != ELUARPC_START_OFFSET )
-    {
-      log_msg( "read_request_packet: ERROR reading packet length. Requested %d bytes, got %d bytes\n", ELUARPC_START_OFFSET, readbytes );
-      flush_serial();
-      continue;
-    }
-
-    if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
-    {
-      log_msg( "read_request_packet: ERROR getting packet size.\n" );
-      flush_serial();
-      continue;
-    }
-
-    // Then the rest of the data
-    if( ( readbytes = ser_read( ser, rfs_buffer + ELUARPC_START_OFFSET, temp16 - ELUARPC_START_OFFSET, SER_INF_TIMEOUT ) ) != temp16 - ELUARPC_START_OFFSET )
-    {
-      log_msg( "read_request_packet: ERROR reading full packet, got %u bytes, expected %u bytes\n", ( unsigned )readbytes, ( unsigned )temp16 - ELUARPC_START_OFFSET );
-      flush_serial();
-      continue;
-    }
-    else
-      break;
-  }
-}
-
-// Send a packet to the serial port
-static void ser_send_response_packet()
-{
-  u16 temp16;
-
-  // Send request
-  if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) != ELUARPC_ERR )
-  {
-    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )temp16 );
-    ser_write( ser, rfs_buffer, temp16 );
-  }
-}
-
-static int ser_server_init( const char *portname, int serspeed, int flow )
-{
-  // Setup serial port
-  if( ( ser = ser_open( portname ) ) == SER_HANDLER_INVALID )
-  {
-    log_err( "Cannot open port %s\n", portname );
-    return 0;
-  }
-  if( ser_setup( ser, ( u32 )serspeed, SER_DATABITS_8, SER_PARITY_NONE, SER_STOPBITS_1, flow ) != SER_OK )
-  {
-    log_err( "Unable to initialize serial port\n" );
-    return 0;
-  }  
-  flush_serial();
-  
-  // User report
-  log_msg( "Running RFS server on serial port %s (%u baud).\n", portname, ( unsigned )serspeed );
-  return 1; 
-}
-
-static void ser_cleanup()
-{
-  ser_close( ser );
-}
-
-static const RFS_TRANSPORT_DATA ser_transport_data = { ser_read_request_packet, ser_send_response_packet, ser_cleanup };
-
-// ****************************************************************************
-// UDP transport implementation
-
-static NET_SOCKET trans_socket = INVALID_SOCKET_VALUE;
-static struct sockaddr_in trans_from;
-
-// Helper: read (blocking) the specified number of bytes
-
-static void udp_read_helper( u8 *dest, u32 size )
-{
-  socklen_t fromlen;
-  int readbytes;
-
-  while( size )
-  {
-    fromlen = sizeof( trans_from );
-    readbytes = net_recvfrom( trans_socket, ( char* )dest, size, 0, ( struct sockaddr* )&trans_from, &fromlen, NET_INF_TIMEOUT );
-    size -= readbytes;
-    if( size == 0 )
-      break;
-    dest += readbytes;
-  }
-}
-
-static void udp_read_request_packet()
-{
-  u16 temp16;
- 
-  while( 1 )
-  {
-    // First read the length
-    udp_read_helper( rfs_buffer, ELUARPC_START_OFFSET );
-
-    if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
-    {
-      log_msg( "read_request_packet: ERROR getting packet size.\n" );
-      continue;
-    }
-
-    // Then the rest of the data
-    udp_read_helper( rfs_buffer + ELUARPC_START_OFFSET, temp16 - ELUARPC_START_OFFSET );
-    break;
-  }
-}
-
-static void udp_send_response_packet()
-{
-  u16 temp16;
-  
-  // Send request
-  if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) != ELUARPC_ERR )
-  {
-    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )temp16 );
-    net_sendto( trans_socket, ( char* )rfs_buffer, temp16, 0, ( struct sockaddr* )&trans_from, sizeof( trans_from ) );
-  }  
-}
-
-static int udp_server_init( unsigned server_port )
-{
-  int length;
-  struct sockaddr_in server;
-     
-  if( ( trans_socket = net_create_socket( AF_INET, SOCK_DGRAM, 0 ) ) == INVALID_SOCKET_VALUE )
-  {
-    log_err( "Unable to create socket\n" );
-    return 1;
-  }
-  length = sizeof( server );
-  memset( &server, 0, sizeof( server ) );
-  server.sin_family = AF_INET;
-  server.sin_addr.s_addr = INADDR_ANY;
-  server.sin_port = htons( server_port );
-  if( bind( net_socket( trans_socket ), ( struct sockaddr * )&server, length ) < 0 )
-  {
-   log_err( "Unable to bind socket\n" );
-   return 0; 
-  }
-  log_msg( "Running RFS server on UDP port %u.\n", ( unsigned )server_port );
-  return 1;    
-}
-
-static void udp_cleanup()
-{
-  net_close( trans_socket );
-}
-
-static const RFS_TRANSPORT_DATA udp_transport_data = { udp_read_request_packet, udp_send_response_packet, udp_cleanup };
-
-// ****************************************************************************
-// Memory transport implementation
-
-// Read state machine
-enum
-{
-  MEM_STATE_READ_LENGTH,
-  MEM_STATE_READ_REQUEST,
-  MEM_STATE_REQUEST_DONE
-};
-
-static int mem_read_len;
-static int mem_expected_len;
-static int mem_read_state;
-static int mem_response_flag;
-
-void rfs_mem_start_request()
-{
-  mem_read_state = MEM_STATE_READ_LENGTH;
-  mem_read_len = mem_expected_len = 0;
-  mem_response_flag = 0;
-}
-
-int rfs_mem_read_request_packet( int c )
-{
-  u16 temp16;
-  int res = 1;
-  
-  if( c == -1 )
-  {
-    rfs_mem_start_request();
-    return 0;
-  }
-  
-  switch( mem_read_state )
-  {
-    case MEM_STATE_READ_LENGTH:
-      rfs_buffer[ mem_read_len ++ ] = c;
-      if( mem_read_len == ELUARPC_START_OFFSET )
-      {
-        mem_read_len = 0;
-        if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
-        {
-          log_msg( "RFS read_request_packet: ERROR getting packet size.\n" );
-          mem_read_state = MEM_STATE_REQUEST_DONE;
-          res = 0;
-        }
-        else
-        {
-          mem_read_state = MEM_STATE_READ_REQUEST;
-          mem_expected_len = temp16 - ELUARPC_START_OFFSET;
-        }        
-      }
-      break;
-      
-    case MEM_STATE_READ_REQUEST:
-      rfs_buffer[ ELUARPC_START_OFFSET + mem_read_len ] = c;
-      mem_read_len ++;
-      if( mem_read_len == mem_expected_len )  
-      {
-        mem_read_state = MEM_STATE_REQUEST_DONE;
-        mem_response_flag = 1;
-      }     
-      break;
-  }
-  
-  return res;
-}
-
-int rfs_mem_has_response()
-{
-  return mem_response_flag;
-}
-
-void rfs_mem_write_response( u16 *plen, u8 **pdata )
-{  
-  // Execute request  
-  server_execute_request( rfs_buffer );
-  
-  // Send response
-  if( eluarpc_get_packet_size( rfs_buffer, plen ) != ELUARPC_ERR )
-  {
-    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )*plen );
-    *pdata = rfs_buffer;    
-  } 
-  else
-  {
-    log_msg( "ERROR in send_response_packet!\n" );
-    *plen = 0;
-  }
-}
-
-static int mem_server_init()
-{
-  rfs_mem_start_request();  
-  log_msg( "RFS: using memory transport.\n" );
-  return 1;   
-}
-
-static const RFS_TRANSPORT_DATA mem_transport_data = { NULL, NULL, NULL };
-
-// ****************************************************************************
-// Helper functions
-
-// Transport parser
-static int parse_transport_and_init( const char* s )
-{
-  const char *c, *c2;
-  char *temps, *tempb;
-  long tempi;
-  int flow;
-  
-  if( strstr( s, "ser:" ) == s )
-  {
-    p_transport_data = &ser_transport_data;
-    s += strlen( "ser:" );
-    if( ( c = strchr( s, ',' ) ) == NULL )
-    {
-      log_err( "Invalid serial transport syntax\n" );
-      return 0;
-    }
-    temps = l_strndup( s, c - s );
-    if( ( c2 = strchr( c + 1, ',' ) ) == NULL )
-    {
-      log_err( "Invalid serial transport syntax.\n" );
-      return 0;
-    }
-    tempb = l_strndup( c + 1, c2 - c - 1 );
-    if( secure_atoi( tempb, &tempi ) == 0 )
-    {
-      log_err( "Invalid port speed\n" );
-      return 0;
-    }
-    free( tempb );   
-    if( !strcmp( c2 + 1, "none" ) )
-      flow = SER_FLOW_NONE;
-    else if( !strcmp( c2 + 1, "rtscts" ) )
-      flow = SER_FLOW_RTSCTS;
-    else
-    {
-      log_err( "Invalid flow control type.\n" );
-      return 0;
-    }
-    tempi = ser_server_init( temps, tempi, flow );
-    free( temps );    
-    return tempi;
-  }
-  else if( strstr( s, "udp:" ) == s )
-  {
-    p_transport_data = &udp_transport_data;
-    s += strlen( "udp:" );
-    if( secure_atoi( s, &tempi ) == 0 )
-    {
-      log_err( "Invalid port number\n" );
-      return 0;
-    }    
-    if( net_init() == 0 )
-    { 
-      log_err( "Unable to initialize network\n" );
-      return 0;
-    }
-    return udp_server_init( tempi );   
-  }
-  else if( !strcmp( s, "mem" ) )
-  {
-    // Direct memory transport, only used with mux in rfsmux mode
-    p_transport_data = &mem_transport_data;
-    return mem_server_init( tempi ); 
-  }  
-  log_err( "Error: unsupported transport\n" );
-  return 0;
-}
-
-// *****************************************************************************
-// Entry point
-
-#define TRANSPORT_ARG_IDX     1
-#define DIRNAME_ARG_IDX       2
-#define VERBOSE_ARG_IDX       3
-#define MIN_ARGC_COUNT        3
-#define VERBOSE_ARGC_COUNT    4
-
-int rfs_init( int argc, const char **argv )
-{
-  setvbuf( stdout, NULL, _IONBF, 0 );
-  if( argc < MIN_ARGC_COUNT )
-  {
-    log_err( "Usage: %s <transport> <dirname> [-v]\n", argv[ 0 ] );
-    log_err( "  Serial transport: 'ser:<sername>,<serspeed>,<flow> ('flow' defines the flow control and can be either 'none' or 'rtscts')\n" );
-    log_err( "  UDP transport: 'udp:<port>'\n" );
-    log_err( "Use -v for verbose output.\n" );
-    return 1;
-  }
-  
-  if( ( argc >= VERBOSE_ARGC_COUNT ) && !strcmp( argv[ VERBOSE_ARG_IDX ], "-v" ) )
-    log_init( LOG_ALL );
-  else
-    log_init( LOG_NONE );  
-  
-  if( !os_isdir( argv[ DIRNAME_ARG_IDX ] ) )
-  {
-    log_err( "Invalid directory %s\n", argv[ DIRNAME_ARG_IDX ] );
-    return 1;
-  }  
-  if( parse_transport_and_init( argv[ TRANSPORT_ARG_IDX ] ) == 0 )
-    return 1;
-    
-    // Setup RFS server
-  server_setup( argv[ DIRNAME_ARG_IDX ] );   
-  log_msg( "Sharing directory %s\n", argv[ DIRNAME_ARG_IDX ] );
-  return 0;
-} 
 
 #ifdef RFS_STANDALONE_MODE
 int main( int argc, const char **argv )

rfs_server_src/rfs_server.vcxproj

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\src\eluarpc.c" />
+    <ClCompile Include="..\src\remotefs\remotefs.c" />
+    <ClCompile Include="deskutils.c" />
+    <ClCompile Include="log.c" />
+    <ClCompile Include="main.c" />
+    <ClCompile Include="net_win32.c" />
+    <ClCompile Include="os_io_win32.c" />
+    <ClCompile Include="rfs_transports.c" />
+    <ClCompile Include="serial_win32.c" />
+    <ClCompile Include="server.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="deskutils.h" />
+    <ClInclude Include="log.h" />
+    <ClInclude Include="net.h" />
+    <ClInclude Include="rfs.h" />
+    <ClInclude Include="rfs_transports.h" />
+    <ClInclude Include="serial.h" />
+    <ClInclude Include="server.h" />
+    <ClInclude Include="type.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4A3A33C6-6A0C-4C82-8C07-A6896BAFB4FA}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>rfs_server</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>.\;..\inc;..\inc\remotefs;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>.\;..\inc;..\inc\remotefs;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>RFS_STANDALONE_MODE;WIN32_BUILD;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>RFS_STANDALONE_MODE;WIN32_BUILD;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

rfs_server_src/rfs_server.vcxproj.filters

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="server.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="deskutils.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\eluarpc.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="log.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="main.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="net_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="os_io_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\remotefs\remotefs.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="rfs_transports.c">
+      <Filter>source</Filter>
+    </ClCompile>
+    <ClCompile Include="serial_win32.c">
+      <Filter>source</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="deskutils.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="rfs_transports.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="serial.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="server.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="type.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="net.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="rfs.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+    <ClInclude Include="log.h">
+      <Filter>headers</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="headers">
+      <UniqueIdentifier>{337cdfd6-7a94-45a7-9773-202c632d5000}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="source">
+      <UniqueIdentifier>{ed41819a-7341-42c2-b1ee-525a54aeeee1}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

rfs_server_src/rfs_transports.c

@@ -0,0 +1,413 @@
+// Remote FS server
+
+#include "net.h"
+#include "remotefs.h"
+#include "eluarpc.h"
+#include "serial.h"
+#include "server.h"
+#include "type.h"
+#include "log.h"
+#include "os_io.h"
+#include <stdio.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rfs.h"
+#include "deskutils.h"
+#include "rfs_transports.h"
+
+// ****************************************************************************
+// Local variables
+
+
+u8 rfs_buffer[ MAX_PACKET_SIZE + ELUARPC_WRITE_REQUEST_EXTRA ];
+const RFS_TRANSPORT_DATA *p_transport_data; 
+
+// ****************************************************************************
+// Serial transport implementation
+
+static ser_handler ser;
+
+static void flush_serial()
+{
+  // Flush all data in serial port
+  while( ser_read_byte( ser, SER_NO_TIMEOUT ) != -1 );
+}
+
+// Read a packet from the serial port
+static void ser_read_request_packet()
+{
+  u16 temp16;
+  u32 readbytes;
+
+  while( 1 )
+  {
+    // First read the length
+    if( ( readbytes = ser_read( ser, rfs_buffer, ELUARPC_START_OFFSET, SER_INF_TIMEOUT ) ) != ELUARPC_START_OFFSET )
+    {
+      log_msg( "read_request_packet: ERROR reading packet length. Requested %d bytes, got %d bytes\n", ELUARPC_START_OFFSET, readbytes );
+      flush_serial();
+      continue;
+    }
+
+    if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
+    {
+      log_msg( "read_request_packet: ERROR getting packet size.\n" );
+      flush_serial();
+      continue;
+    }
+
+    // Then the rest of the data
+    if( ( readbytes = ser_read( ser, rfs_buffer + ELUARPC_START_OFFSET, temp16 - ELUARPC_START_OFFSET, SER_INF_TIMEOUT ) ) != temp16 - ELUARPC_START_OFFSET )
+    {
+      log_msg( "read_request_packet: ERROR reading full packet, got %u bytes, expected %u bytes\n", ( unsigned )readbytes, ( unsigned )temp16 - ELUARPC_START_OFFSET );
+      flush_serial();
+      continue;
+    }
+    else
+      break;
+  }
+}
+
+// Send a packet to the serial port
+static void ser_send_response_packet()
+{
+  u16 temp16;
+
+  // Send request
+  if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) != ELUARPC_ERR )
+  {
+    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )temp16 );
+    ser_write( ser, rfs_buffer, temp16 );
+  }
+}
+
+static int ser_server_init( const char *portname, int serspeed, int flow )
+{
+  // Setup serial port
+  if( ( ser = ser_open( portname ) ) == SER_HANDLER_INVALID )
+  {
+    log_err( "Cannot open port %s\n", portname );
+    return 0;
+  }
+  if( ser_setup( ser, ( u32 )serspeed, SER_DATABITS_8, SER_PARITY_NONE, SER_STOPBITS_1, flow ) != SER_OK )
+  {
+    log_err( "Unable to initialize serial port\n" );
+    return 0;
+  }  
+  flush_serial();
+  
+  // User report
+  log_msg( "Running RFS server on serial port %s (%u baud).\n", portname, ( unsigned )serspeed );
+  return 1; 
+}
+
+static void ser_cleanup()
+{
+  ser_close( ser );
+}
+
+const RFS_TRANSPORT_DATA ser_transport_data = { ser_read_request_packet, ser_send_response_packet, ser_cleanup };
+
+// ****************************************************************************
+// UDP transport implementation
+
+static NET_SOCKET trans_socket = INVALID_SOCKET_VALUE;
+static struct sockaddr_in trans_from;
+
+// Helper: read (blocking) the specified number of bytes
+
+static void udp_read_helper( u8 *dest, u32 size )
+{
+  socklen_t fromlen;
+  int readbytes;
+
+  while( size )
+  {
+    fromlen = sizeof( trans_from );
+    readbytes = net_recvfrom( trans_socket, ( char* )dest, size, 0, ( struct sockaddr* )&trans_from, &fromlen, NET_INF_TIMEOUT );
+    size -= readbytes;
+    if( size == 0 )
+      break;
+    dest += readbytes;
+  }
+}
+
+static void udp_read_request_packet()
+{
+  u16 temp16;
+ 
+  while( 1 )
+  {
+    // First read the length
+    udp_read_helper( rfs_buffer, ELUARPC_START_OFFSET );
+
+    if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
+    {
+      log_msg( "read_request_packet: ERROR getting packet size.\n" );
+      continue;
+    }
+
+    // Then the rest of the data
+    udp_read_helper( rfs_buffer + ELUARPC_START_OFFSET, temp16 - ELUARPC_START_OFFSET );
+    break;
+  }
+}
+
+static void udp_send_response_packet()
+{
+  u16 temp16;
+  
+  // Send request
+  if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) != ELUARPC_ERR )
+  {
+    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )temp16 );
+    net_sendto( trans_socket, ( char* )rfs_buffer, temp16, 0, ( struct sockaddr* )&trans_from, sizeof( trans_from ) );
+  }  
+}
+
+static int udp_server_init( unsigned server_port )
+{
+  int length;
+  struct sockaddr_in server;
+     
+  if( ( trans_socket = net_create_socket( AF_INET, SOCK_DGRAM, 0 ) ) == INVALID_SOCKET_VALUE )
+  {
+    log_err( "Unable to create socket\n" );
+    return 1;
+  }
+  length = sizeof( server );
+  memset( &server, 0, sizeof( server ) );
+  server.sin_family = AF_INET;
+  server.sin_addr.s_addr = INADDR_ANY;
+  server.sin_port = htons( server_port );
+  if( bind( net_socket( trans_socket ), ( struct sockaddr * )&server, length ) < 0 )
+  {
+   log_err( "Unable to bind socket\n" );
+   return 0; 
+  }
+  log_msg( "Running RFS server on UDP port %u.\n", ( unsigned )server_port );
+  return 1;    
+}
+
+static void udp_cleanup()
+{
+  net_close( trans_socket );
+}
+
+const RFS_TRANSPORT_DATA udp_transport_data = { udp_read_request_packet, udp_send_response_packet, udp_cleanup };
+
+// ****************************************************************************
+// Memory transport implementation
+
+// Read state machine
+enum
+{
+  MEM_STATE_READ_LENGTH,
+  MEM_STATE_READ_REQUEST,
+  MEM_STATE_REQUEST_DONE
+};
+
+static int mem_read_len;
+static int mem_expected_len;
+static int mem_read_state;
+static int mem_response_flag;
+
+void rfs_mem_start_request()
+{
+  mem_read_state = MEM_STATE_READ_LENGTH;
+  mem_read_len = mem_expected_len = 0;
+  mem_response_flag = 0;
+}
+
+int rfs_mem_read_request_packet( int c )
+{
+  u16 temp16;
+  int res = 1;
+  
+  if( c == -1 )
+  {
+    rfs_mem_start_request();
+    return 0;
+  }
+  
+  switch( mem_read_state )
+  {
+    case MEM_STATE_READ_LENGTH:
+      rfs_buffer[ mem_read_len ++ ] = c;
+      if( mem_read_len == ELUARPC_START_OFFSET )
+      {
+        mem_read_len = 0;
+        if( eluarpc_get_packet_size( rfs_buffer, &temp16 ) == ELUARPC_ERR )
+        {
+          log_msg( "RFS read_request_packet: ERROR getting packet size.\n" );
+          mem_read_state = MEM_STATE_REQUEST_DONE;
+          res = 0;
+        }
+        else
+        {
+          mem_read_state = MEM_STATE_READ_REQUEST;
+          mem_expected_len = temp16 - ELUARPC_START_OFFSET;
+        }        
+      }
+      break;
+      
+    case MEM_STATE_READ_REQUEST:
+      rfs_buffer[ ELUARPC_START_OFFSET + mem_read_len ] = c;
+      mem_read_len ++;
+      if( mem_read_len == mem_expected_len )  
+      {
+        mem_read_state = MEM_STATE_REQUEST_DONE;
+        mem_response_flag = 1;
+      }     
+      break;
+  }
+  
+  return res;
+}
+
+int rfs_mem_has_response()
+{
+  return mem_response_flag;
+}
+
+void rfs_mem_write_response( u16 *plen, u8 **pdata )
+{  
+  // Execute request  
+  server_execute_request( rfs_buffer );
+  
+  // Send response
+  if( eluarpc_get_packet_size( rfs_buffer, plen ) != ELUARPC_ERR )
+  {
+    log_msg( "send_response_packet: sending response packet of %u bytes\n", ( unsigned )*plen );
+    *pdata = rfs_buffer;    
+  } 
+  else
+  {
+    log_msg( "ERROR in send_response_packet!\n" );
+    *plen = 0;
+  }
+}
+
+static int mem_server_init()
+{
+  rfs_mem_start_request();  
+  log_msg( "RFS: using memory transport.\n" );
+  return 1;   
+}
+
+const RFS_TRANSPORT_DATA mem_transport_data = { NULL, NULL, NULL };
+
+// ****************************************************************************
+// Helper functions
+
+// Transport parser
+static int parse_transport_and_init( const char* s )
+{
+  const char *c, *c2;
+  char *temps, *tempb;
+  long tempi = 0;
+  int flow;
+  
+  if( strstr( s, "ser:" ) == s )
+  {
+    p_transport_data = &ser_transport_data;
+    s += strlen( "ser:" );
+    if( ( c = strchr( s, ',' ) ) == NULL )
+    {
+      log_err( "Invalid serial transport syntax\n" );
+      return 0;
+    }
+    temps = l_strndup( s, c - s );
+    if( ( c2 = strchr( c + 1, ',' ) ) == NULL )
+    {
+      log_err( "Invalid serial transport syntax.\n" );
+      return 0;
+    }
+    tempb = l_strndup( c + 1, c2 - c - 1 );
+    if( secure_atoi( tempb, &tempi ) == 0 )
+    {
+      log_err( "Invalid port speed\n" );
+      return 0;
+    }
+    free( tempb );   
+    if( !strcmp( c2 + 1, "none" ) )
+      flow = SER_FLOW_NONE;
+    else if( !strcmp( c2 + 1, "rtscts" ) )
+      flow = SER_FLOW_RTSCTS;
+    else
+    {
+      log_err( "Invalid flow control type.\n" );
+      return 0;
+    }
+    tempi = ser_server_init( temps, tempi, flow );
+    free( temps );    
+    return tempi;
+  }
+  else if( strstr( s, "udp:" ) == s )
+  {
+    p_transport_data = &udp_transport_data;
+    s += strlen( "udp:" );
+    if( secure_atoi( s, &tempi ) == 0 )
+    {
+      log_err( "Invalid port number\n" );
+      return 0;
+    }    
+    if( net_init() == 0 )
+    { 
+      log_err( "Unable to initialize network\n" );
+      return 0;
+    }
+    return udp_server_init( tempi );   
+  }
+  else if( !strcmp( s, "mem" ) )
+  {
+    // Direct memory transport, only used with mux in rfsmux mode
+    p_transport_data = &mem_transport_data;
+    return mem_server_init( tempi ); 
+  }  
+  log_err( "Error: unsupported transport\n" );
+  return 0;
+}
+
+// *****************************************************************************
+// Entry point
+
+#define TRANSPORT_ARG_IDX     1
+#define DIRNAME_ARG_IDX       2
+#define VERBOSE_ARG_IDX       3
+#define MIN_ARGC_COUNT        3
+#define VERBOSE_ARGC_COUNT    4
+
+int rfs_init( int argc, const char **argv )
+{
+  setvbuf( stdout, NULL, _IONBF, 0 );
+  if( argc < MIN_ARGC_COUNT )
+  {
+    log_err( "Usage: %s <transport> <dirname> [-v]\n", argv[ 0 ] );
+    log_err( "  Serial transport: 'ser:<sername>,<serspeed>,<flow> ('flow' defines the flow control and can be either 'none' or 'rtscts')\n" );
+    log_err( "  UDP transport: 'udp:<port>'\n" );
+    log_err( "Use -v for verbose output.\n" );
+    return 1;
+  }
+  
+  if( ( argc >= VERBOSE_ARGC_COUNT ) && !strcmp( argv[ VERBOSE_ARG_IDX ], "-v" ) )
+    log_init( LOG_ALL );
+  else
+    log_init( LOG_NONE );  
+  
+  if( !os_isdir( argv[ DIRNAME_ARG_IDX ] ) )
+  {
+    log_err( "Invalid directory %s\n", argv[ DIRNAME_ARG_IDX ] );
+    return 1;
+  }  
+  if( parse_transport_and_init( argv[ TRANSPORT_ARG_IDX ] ) == 0 )
+    return 1;
+    
+    // Setup RFS server
+  server_setup( argv[ DIRNAME_ARG_IDX ] );   
+  log_msg( "Sharing directory %s\n", argv[ DIRNAME_ARG_IDX ] );
+  return 0;
+} 
+

rfs_server_src/rfs_transports.h

@@ -0,0 +1,22 @@
+#ifndef _RFS_TRANSPORTS_H
+#define _RFS_TRANSPORTS_H
+
+typedef void ( *p_read_request )( void );
+typedef void ( *p_send_response )( void );
+typedef void ( *p_cleanup )( void );
+typedef struct
+{
+  p_read_request f_read_request;
+  p_send_response f_send_response;
+  p_cleanup f_cleanup;
+} RFS_TRANSPORT_DATA;
+
+#define   MAX_PACKET_SIZE     4096
+
+extern const RFS_TRANSPORT_DATA *p_transport_data; 
+extern const RFS_TRANSPORT_DATA mem_transport_data;
+extern const RFS_TRANSPORT_DATA udp_transport_data;
+extern const RFS_TRANSPORT_DATA ser_transport_data;
+extern u8 rfs_buffer[ MAX_PACKET_SIZE + ELUARPC_WRITE_REQUEST_EXTRA ];
+
+#endif

rfs_server_src/serial_win32.c

@@ -8,11 +8,18 @@
 #include "serial.h"
 
 #define WIN_ERROR     ( HANDLE )-1
-#define WIN_MAX_PORT_NAME   1024
+#define WIN_MAX_PORT_NAME   MAX_PATH
 #define MAX_HANDLES   1024
 
-static HANDLE sel_handlers[ MAX_HANDLES ];
+static HANDLE sel_handlers[ MAX_HANDLES ]; // XXX: consider making this an static variable of ser_select_byte
-static int sel_handler_map[ MAX_HANDLES ];
+static int sel_handler_map[ MAX_HANDLES ]; // XXX: consider making this an static variable of ser_select_byte
+
+static void init_ov( OVERLAPPED* o )
+{
+  HANDLE temp = o->hEvent;
+  memset( o, 0, sizeof( OVERLAPPED ) );
+  o->hEvent = temp;
+}
 
 // Helper: set timeout
 static int ser_win32_set_timeouts( HANDLE hComm, DWORD ri, DWORD rtm, DWORD rtc, DWORD wtm, DWORD wtc )
@@ -56,7 +63,7 @@ ser_handler ser_open( const char* sername )
   HANDLE hComm;
   ser_handler hnd;
 
-  portname[ 0 ] = portname[ WIN_MAX_PORT_NAME ] = '\0';
+  portname[ WIN_MAX_PORT_NAME ] = '\0';
   _snprintf( portname, WIN_MAX_PORT_NAME, "\\\\.\\%s", sername );
   hComm = CreateFile( portname, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0 );
   if( hComm == INVALID_HANDLE_VALUE )
@@ -71,9 +78,16 @@ ser_handler ser_open( const char* sername )
   hnd->hnd = hComm;
   hnd->fWaitingOnRead = FALSE;
   if( ( hnd->o.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) == NULL ) 
+  {
+    free( hnd );
     return SER_HANDLER_INVALID;
+  }
   if( ( hnd->o_wr.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) == NULL ) 
+  {
+    free( hnd );
+    CloseHandle( hnd->o.hEvent );
     return SER_HANDLER_INVALID;
+  }
   return hnd;
 }
 
@@ -90,6 +104,7 @@ int ser_setup( ser_handler id, u32 baud, int databits, int parity, int stopbits,
 {
   HANDLE hComm = id->hnd;
   DCB dcb;
+  dcb.DCBlength = sizeof(DCB);
 
   if( GetCommState( hComm, &dcb ) == FALSE )
   {
@@ -120,7 +135,7 @@ int ser_setup( ser_handler id, u32 baud, int databits, int parity, int stopbits,
     dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
     dcb.fOutxCtsFlow = TRUE;
   }
-  if( SetCommState( hComm, &dcb ) == 0 )
+  if( SetCommState( hComm, &dcb ) == FALSE )
   {
     CloseHandle( hComm );
     return SER_ERR;
@@ -137,27 +152,10 @@ int ser_setup( ser_handler id, u32 baud, int databits, int parity, int stopbits,
   return SER_OK;
 }
 
-// Read up to the specified number of bytes, return bytes actually read
+static u32 ser_read_internal( ser_handler id, u32 timeout )
-u32 ser_read( ser_handler id, u8* dest, u32 maxsize, u32 timeout )
 {
   HANDLE hComm = id->hnd;
   DWORD readbytes = 0;
-  
-  if( !id->fWaitingOnRead )
-  {
-    if( ReadFile( hComm, dest, maxsize, &readbytes, &id->o ) == FALSE )
-    {
-      if( GetLastError() != ERROR_IO_PENDING )   
-        return 0;
-      else
-        id->fWaitingOnRead = TRUE;
-    }
-    else
-      return readbytes;
-  }
-      
-  if( id->fWaitingOnRead )
-  {
   DWORD dwRes = WaitForSingleObject( id->o.hEvent, timeout == SER_INF_TIMEOUT ? INFINITE : timeout );
   if( dwRes == WAIT_OBJECT_0 )
   {
@@ -171,6 +169,27 @@ u32 ser_read( ser_handler id, u8* dest, u32 maxsize, u32 timeout )
     readbytes = 0;
   }
   ResetEvent( id->o.hEvent );
+  return readbytes;
+}
+
+// Read up to the specified number of bytes, return bytes actually read
+u32 ser_read( ser_handler id, u8* dest, u32 maxsize, u32 timeout )
+{
+  DWORD readbytes = 0;
+  if( id->fWaitingOnRead )
+  {
+    readbytes = ser_read_internal( id, timeout );
+    dest[0] = id->databuf;
+  }
+  else
+  {
+    init_ov( &id->o );
+    if( ReadFile( id->hnd, dest, maxsize, &readbytes, &id->o ) )
+      return readbytes;
+    if( GetLastError() != ERROR_IO_PENDING )
+      return 0;
+    id->fWaitingOnRead = TRUE; // XXX: consider removing statement
+    readbytes = ser_read_internal( id, timeout );
   }
   id->fWaitingOnRead = FALSE;
   return readbytes;
@@ -180,39 +199,23 @@ u32 ser_read( ser_handler id, u8* dest, u32 maxsize, u32 timeout )
 int ser_read_byte( ser_handler id, u32 timeout )
 {
   u8 data;
-  int res = ser_read( id, &data, 1, timeout );
+  return ser_read( id, &data, 1, timeout ) == 1 ? data : -1;
-
-  return res == 1 ? data : -1;
 }
 
 // Write up to the specified number of bytes, return bytes actually written
 u32 ser_write( ser_handler id, const u8 *src, u32 size )
 {
   HANDLE hComm = id->hnd;
-  DWORD written = 0;
+  DWORD written;
-  BOOL fWaitingOnWrite = FALSE;
-	HANDLE temp = id->o_wr.hEvent;
 
-	memset( &id->o_wr, 0, sizeof( OVERLAPPED ) );
+  init_ov( &id->o_wr );
-	id->o_wr.hEvent = temp;
+  if( WriteFile( hComm, src, size, &written, &id->o_wr ) )
-  if( WriteFile( hComm, src, size, &written, &id->o_wr ) == FALSE )
+    return written;
-  {
   if( GetLastError() != ERROR_IO_PENDING )
     return 0;
-    else
+  if( !GetOverlappedResult( hComm, &id->o_wr, &written, TRUE ) )
-      fWaitingOnWrite = TRUE;
-  }
-  else
-    return written;
-
-  if( fWaitingOnWrite )
-  {                              
-    DWORD dwRes = WaitForSingleObject( id->o_wr.hEvent, INFINITE );      
-    if( dwRes == WAIT_OBJECT_0 )
-      if( !GetOverlappedResult( hComm, &id->o_wr, &written, FALSE ) )
     written = 0;
   ResetEvent( id->o_wr.hEvent );
-  }
 
   return written;
 }
@@ -228,54 +231,38 @@ u32 ser_write_byte( ser_handler id, u8 data )
 // otherwise
 int ser_select_byte( ser_handler *pobjects, unsigned nobjects, int timeout )
 {
-  int i, idx;
+  int i;
-  DWORD readbytes;
+  DWORD readbytes, dwRes;
   int res = -1;
   unsigned num_wait = 0;
   ser_handler hnd;
-  HANDLE temp;
+
+  if( nobjects >= MAXIMUM_WAIT_OBJECTS )
+    return -1;
 
   // Try to read directly first
   for( i = 0; i < nobjects; i ++ )
   {
-    temp = pobjects[ i ]->o.hEvent;
-    memset( &pobjects[ i ]->o, 0, sizeof( OVERLAPPED ) );
-    pobjects[ i ]->o.hEvent = temp;
     if( !pobjects[ i ]->fWaitingOnRead )
     {
-      if( ReadFile( pobjects[ i ]->hnd, &pobjects[ i ]->databuf, 1, &readbytes, &pobjects[ i ]->o ) == FALSE )
+      init_ov( &pobjects[ i ]->o );
-      {
+      if( ReadFile( pobjects[ i ]->hnd, &pobjects[ i ]->databuf, 1, &readbytes, &pobjects[ i ]->o ) )
+        return readbytes != 1 ? -1 : pobjects[ i ]->databuf | ( i << 8 );
       if( GetLastError() != ERROR_IO_PENDING )
         return -1;
-        else
-        {
       pobjects[ i ]->fWaitingOnRead = TRUE;
+    }
     sel_handler_map[ num_wait ] = i;
     sel_handlers[ num_wait ++ ] = pobjects[ i ]->o.hEvent;
   }
-      }
-      else
-      {
-        if( readbytes == 1 )
-          return pobjects[ i ]->databuf | ( i << 8 );
-        else
-          return -1;
-      }    
-    }  
-    else
-    {
-      sel_handler_map[ num_wait ] = i;
-      sel_handlers[ num_wait ++ ] = pobjects[ i ]->o.hEvent;
-    }  
-  }
 
-  if( num_wait > 0 )
+  if( num_wait == 0 )
-  {
+    return -1;
-    idx = -1;
+
-    DWORD dwRes = WaitForMultipleObjects( num_wait, sel_handlers, FALSE, timeout == SER_INF_TIMEOUT ? INFINITE : timeout );
+  dwRes = WaitForMultipleObjects( num_wait, sel_handlers, FALSE, timeout == SER_INF_TIMEOUT ? INFINITE : timeout );
   if( dwRes >= WAIT_OBJECT_0 && dwRes < WAIT_OBJECT_0 + num_wait )
   {
-      i = idx = dwRes - WAIT_OBJECT_0;
+    i = dwRes - WAIT_OBJECT_0;
     hnd = pobjects[ sel_handler_map[ i ] ];
     hnd->fWaitingOnRead = FALSE;
     if( GetOverlappedResult( hnd->hnd, &hnd->o, &readbytes, TRUE ) && readbytes == 1 )
@@ -289,10 +276,10 @@ int ser_select_byte( ser_handler *pobjects, unsigned nobjects, int timeout )
       hnd = pobjects[ sel_handler_map[ i ] ];
       hnd->fWaitingOnRead = FALSE;
       CancelIo( hnd->hnd );
-        GetOverlappedResult( hnd->hnd, &hnd->o, &readbytes, TRUE );
-        ResetEvent( hnd->o.hEvent );
-      } 
     }
+    WaitForMultipleObjects( num_wait, sel_handlers, TRUE, INFINITE );
+    for( i = 0; i < num_wait; i ++ )
+      ResetEvent( pobjects[ sel_handler_map[ i ] ]->o.hEvent );
   }
 
   return res;

romfs/.gitignore

@@ -0,0 +1,3 @@
+*
+!.gitignore
+

rpc-lua.py

@@ -1,33 +1,35 @@
 import os, sys, platform
 
 output = 'luarpc'
-cdefs = ['-DLUA_CROSS_COMPILER','-DLUA_RPC']
+cdefs = "-DLUA_CROSS_COMPILER -DLUA_RPC"
 
 # Lua source files and include path
 lua_files = """lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c lmem.c lobject.c lopcodes.c
    lparser.c lstate.c lstring.c ltable.c ltm.c lundump.c lvm.c lzio.c lauxlib.c lbaselib.c
    ldblib.c liolib.c lmathlib.c loslib.c ltablib.c lstrlib.c loadlib.c linit.c lua.c print.c lrotable.c"""
 lua_full_files = " " + " ".join( [ "src/lua/%s" % name for name in lua_files.split() ] )
-lua_full_files += " src/modules/luarpc.c src/luarpc_desktop_serial.c "
+lua_full_files += " src/modules/luarpc.c src/modules/lpack.c src/modules/bitarray.c src/modules/bit.c src/luarpc_desktop_serial.c "
 
-external_libs = ['m']
+external_libs = '-lm'
 
 if platform.system() == "Windows":
   lua_full_files += " src/serial/serial_win32.c"
-  cdefs.append("-DWIN32_BUILD")
+  cdefs += " -DWIN32_BUILD"
 else:
   lua_full_files += " src/serial/serial_posix.c"
-  external_libs += ['readline']
+  external_libs += " -lreadline"
-  cdefs.append("-DLUA_USE_READLINE")
+  cdefs += " -DLUA_USE_READLINE"
 
-local_include = ['src/lua', 'inc', 'src/modules', 'inc/desktop'];
+local_include = "-Isrc/lua -Iinc -Isrc/modules -Iinc/desktop"
+
+# Compiler/linker options
+cccom = "gcc -O2 -g %s -Wall %s -c $SOURCE -o $TARGET" % ( local_include, cdefs )
+linkcom = "gcc -o $TARGET $SOURCES %s" % external_libs
 
 # Env for building the program
-comp = Environment( CPPPATH = local_include,
+comp = Environment( CCCOM = cccom,
-                    CCFLAGS = cdefs,
+                    LINKCOM = linkcom,
                     ENV = os.environ )
 # Debug
-comp.PrependUnique(CCFLAGS=['-g'])
-
 Decider( 'MD5-timestamp' )                  
-Default( comp.Program( output, Split( lua_full_files ), LIBS=external_libs ) )
+Default( comp.Program( output, Split( lua_full_files ) ) )

src/common_uart.c

@@ -148,8 +148,13 @@ static elua_int_c_handler prev_uart_rx_handler;
 
 static void cmn_uart_rx_inthandler( elua_int_resnum resnum )
 {
+  int data;
+
   if( buf_is_enabled( BUF_ID_UART, resnum ) || resnum == SERMUX_PHYS_ID )
-    cmn_rx_handler( resnum, platform_s_uart_recv( resnum, 0 ) );
+  {
+    while( -1 != ( data = platform_s_uart_recv( resnum, 0 ) ) )
+      cmn_rx_handler( resnum, ( u8 )data );
+  }
 
   // Chain to previous handler
   if( prev_uart_rx_handler != NULL )

src/elua_uip.c

@@ -40,13 +40,7 @@ static u32 periodic_timer, arp_timer;
 
 static void device_driver_send()
 {
-  if( uip_len <= TOTAL_HEADER_LENGTH )
   platform_eth_send_packet( uip_buf, uip_len );
-  else
-  {
-    platform_eth_send_packet( uip_buf, TOTAL_HEADER_LENGTH );
-    platform_eth_send_packet( ( u8* )uip_appdata, uip_len - TOTAL_HEADER_LENGTH );
-  }
 }
 
 // This gets called on both Ethernet RX interrupts and timer requests,
@@ -202,7 +196,7 @@ static int elua_uip_telnet_socket = -1;
 // Utility function for TELNET: parse input buffer, skipping over
 // TELNET specific sequences
 // Returns the length of the buffer after processing
-static void elua_uip_telnet_handle_input( struct elua_uip_state* s )
+static void elua_uip_telnet_handle_input( volatile struct elua_uip_state* s )
 {
   u8 *dptr = ( u8* )uip_appdata;
   char *orig = ( char* )s->ptr;
@@ -272,7 +266,7 @@ volatile static elua_net_ip elua_uip_accept_remote;
 
 void elua_uip_appcall()
 {
-  struct elua_uip_state *s;
+  volatile struct elua_uip_state *s;
   elua_net_size temp;
   int sockno;
   

src/luarpc_desktop_serial.c

@@ -41,7 +41,7 @@ void transport_open( Transport *tpt, const char *path )
   }
   
   ser_setup( tpt->fd, 115200, SER_DATABITS_8, SER_PARITY_NONE, SER_STOPBITS_1 );
-  ser_set_timeout_ms( tpt->fd, 1000 );
+  ser_set_timeout_ms( tpt->fd, 10000 );
 }
 
 // Open Listener / Server 

src/modules/bitarray.c

@@ -3,7 +3,7 @@
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
-#include "platform.h"
+#include "type.h"
 #include "auxmods.h"
 #include "lrotable.h"
 #include <string.h>
@@ -175,15 +175,15 @@ static int bitarray_set( lua_State *L )
     switch( pa->elsize )
     {
       case 8:
-        pa->values[ idx ] = val;;
+        pa->values[ idx ] = ( u8 )newval;
         break;
         
       case 16:
-        *( ( u16* )pa->values + idx ) = val;
+        *( ( u16* )pa->values + idx ) = ( u16 )newval;
         break;
         
       case 32:
-        *( ( u32* )pa->values + idx ) = val;
+        *( ( u32* )pa->values + idx ) = ( u32 )newval;
         break;  
     }    
   return 0;

src/modules/spi.c

@@ -58,7 +58,7 @@ static int spi_rw_helper( lua_State *L, int withread )
 {
   spi_data_type value;
   const char *sval; 
-  int total = lua_gettop( L ), i, id;
+  int total = lua_gettop( L ), i, j, id;
   size_t len, residx = 1;
   
   id = luaL_checkinteger( L, 1 );
@@ -79,9 +79,9 @@ static int spi_rw_helper( lua_State *L, int withread )
     else if( lua_isstring( L, i ) )
     {
       sval = lua_tolstring( L, i, &len );
-      for( i = 0; i < len; i ++ )
+      for( j = 0; j < len; j ++ )
       {
-        value = platform_spi_send_recv( id, sval[ i ] );
+        value = platform_spi_send_recv( id, sval[ j ] );
         if( withread )
         {
           lua_pushnumber( L, value );

src/platform/avr32/EVK1100/evk1100_conf.h

@@ -23,6 +23,10 @@
 //#define BUILD_SERMUX
 #define BUILD_ADC
 
+#define BUILD_UIP
+//#define BUILD_DHCPC
+#define BUILD_DNS
+
 // *****************************************************************************
 // UART/Timer IDs configuration data (used in main.c)
 
@@ -66,6 +70,11 @@
 #else
 #define ADCLINE
 #endif
+#ifdef BUILD_UIP
+#define NETLINE  _ROM( AUXLIB_NET, luaopen_net, net_map )
+#else
+#define NETLINE
+#endif
 
 #if defined( BUILD_RPC ) 
 #define RPCLINE _ROM( AUXLIB_RPC, luaopen_rpc, rpc_map )
@@ -80,8 +89,9 @@
   _ROM( AUXLIB_PWM, luaopen_pwm, pwm_map )\
   _ROM( AUXLIB_SPI, luaopen_spi, spi_map )\
   _ROM( AUXLIB_TMR, luaopen_tmr, tmr_map )\
-  ADCLINE\
   _ROM( AUXLIB_TERM, luaopen_term, term_map )\
+  ADCLINE\
+  NETLINE\
   _ROM( AUXLIB_CPU, luaopen_cpu, cpu_map )\
   _ROM( AUXLIB_ELUA, luaopen_elua, elua_map )\
   RPCLINE\
@@ -174,4 +184,26 @@
 // *****************************************************************************
 // CPU constants that should be exposed to the eLua "cpu" module
 
+
+// Static TCP/IP configuration
+#define ELUA_CONF_IPADDR0     192
+#define ELUA_CONF_IPADDR1     168
+#define ELUA_CONF_IPADDR2     1
+#define ELUA_CONF_IPADDR3     10
+
+#define ELUA_CONF_NETMASK0    255
+#define ELUA_CONF_NETMASK1    255
+#define ELUA_CONF_NETMASK2    255
+#define ELUA_CONF_NETMASK3    0
+
+#define ELUA_CONF_DEFGW0      192
+#define ELUA_CONF_DEFGW1      168
+#define ELUA_CONF_DEFGW2      1
+#define ELUA_CONF_DEFGW3      1
+
+#define ELUA_CONF_DNS0        192
+#define ELUA_CONF_DNS1        168
+#define ELUA_CONF_DNS2        1
+#define ELUA_CONF_DNS3        1
+
 #endif // #ifndef __EVK1100_CONF_H__

src/platform/avr32/MIZAR32/mizar32_conf.h

@@ -8,6 +8,7 @@
 #define __MIZAR32_CONF_H__
 
 #include "sdramc.h"
+#include "sermux.h"
 #include "buf.h"
 
 // *****************************************************************************
@@ -15,18 +16,27 @@
 
 #define BUILD_MMCFS
 //#define BUILD_XMODEM
-//#define BUILD_SHELL
+#define BUILD_SHELL
-//#define BUILD_ROMFS
+#define BUILD_ROMFS
 //#define BUILD_TERM
-#define BUILD_CON_GENERIC
+//#define BUILD_CON_GENERIC
 //#define BUILD_RPC
 #define BUF_ENABLE_UART
 #define BUILD_C_INT_HANDLERS
 //#define BUILD_ADC
+#define BUILA_LUA_INT_HANDLERS
+//#define BUILD_RFS
+//#define BUILD_SERMUX
+
+#define BUILD_UIP
+//#define BUILD_DHCPC
+#define BUILD_DNS
+#define BUILD_CON_TCP
 
 // *****************************************************************************
 // UART/Timer IDs configuration data (used in main.c)
 
+//#define CON_UART_ID         ( SERMUX_SERVICE_ID_FIRST + 1 )
 #define CON_UART_ID         0
 #define CON_UART_SPEED      115200
 #define CON_TIMER_ID        0
@@ -65,6 +75,11 @@
 #else
 #define ADCLINE
 #endif
+#ifdef BUILD_UIP
+#define NETLINE  _ROM( AUXLIB_NET, luaopen_net, net_map )
+#else
+#define NETLINE
+#endif
 
 #if defined( BUILD_RPC ) 
 #define RPCLINE _ROM( AUXLIB_RPC, luaopen_rpc, rpc_map )
@@ -77,8 +92,9 @@
   _ROM( AUXLIB_UART, luaopen_uart, uart_map )\
   _ROM( AUXLIB_PIO, luaopen_pio, pio_map )\
   _ROM( AUXLIB_PWM, luaopen_pwm, pwm_map )\
+  _ROM( AUXLIB_SPI, luaopen_spi, spi_map )\
   _ROM( AUXLIB_TMR, luaopen_tmr, tmr_map )\
-  _ROM( AUXLIB_TERM, luaopen_term, term_map )\
+  NETLINE\
   _ROM( AUXLIB_CPU, luaopen_cpu, cpu_map )\
   _ROM( AUXLIB_ELUA, luaopen_elua, elua_map )\
   ADCLINE\
@@ -87,11 +103,14 @@
   _ROM( AUXLIB_PACK, luaopen_pack, pack_map )\
   _ROM( LUA_MATHLIBNAME, luaopen_math, math_map )
 
+#if MINIMAL_ROM_MODULES_TO_FIT_IN_120KB
 /* Minimal ROM modules, to fit in 120KB */
 #undef  LUA_PLATFORM_LIBS_ROM
 #define LUA_PLATFORM_LIBS_ROM\
   _ROM( AUXLIB_PIO, luaopen_pio, pio_map )\
   _ROM( AUXLIB_TMR, luaopen_tmr, tmr_map )\
+  NETLINE
+#endif
 
 // *****************************************************************************
 // Configuration data
@@ -165,12 +184,49 @@
 // Interrupt queue size
 #define PLATFORM_INT_QUEUE_LOG_SIZE 5
 
+#define RFS_BUFFER_SIZE       BUF_SIZE_512
+#define RFS_UART_ID           ( SERMUX_SERVICE_ID_FIRST )
+#define RFS_TIMER_ID          0
+#define RFS_TIMEOUT           100000
+#define RFS_UART_SPEED        115200
+
+//#define SERMUX_PHYS_ID        0
+//#define SERMUX_PHYS_SPEED     115200
+//#define SERMUX_NUM_VUART      2
+//#define SERMUX_BUFFER_SIZES   { RFS_BUFFER_SIZE, CON_BUF_SIZE }
+
 // Interrupt list
 #define INT_UART_RX           ELUA_INT_FIRST_ID
 #define INT_ELUA_LAST         INT_UART_RX
 
+#define PLATFORM_CPU_CONSTANTS\
+ _C( INT_UART_RX )
+
 // *****************************************************************************
 // CPU constants that should be exposed to the eLua "cpu" module
 
+
+// Static TCP/IP configuration
+
+#define ELUA_CONF_IPADDR0     192
+#define ELUA_CONF_IPADDR1     168
+#define ELUA_CONF_IPADDR2     1
+#define ELUA_CONF_IPADDR3     10
+
+#define ELUA_CONF_NETMASK0    255
+#define ELUA_CONF_NETMASK1    255
+#define ELUA_CONF_NETMASK2    255
+#define ELUA_CONF_NETMASK3    0
+
+#define ELUA_CONF_DEFGW0      192
+#define ELUA_CONF_DEFGW1      168
+#define ELUA_CONF_DEFGW2      1
+#define ELUA_CONF_DEFGW3      1
+
+#define ELUA_CONF_DNS0        192
+#define ELUA_CONF_DNS1        168
+#define ELUA_CONF_DNS2        1
+#define ELUA_CONF_DNS3        1
+
 #endif // #ifndef __MIZAR32_CONF_H__
 

src/platform/avr32/conf.lua

@@ -1,6 +1,6 @@
 -- Configuration file for the AVR32 microcontrollers
 
-specific_files = "crt0.s trampoline.s platform.c exception.s intc.c pm.c flashc.c pm_conf_clocks.c usart.c gpio.c tc.c spi.c platform_int.c adc.c pwm.c"
+specific_files = "crt0.s trampoline.s platform.c exception.s intc.c pm.c flashc.c pm_conf_clocks.c usart.c gpio.c tc.c spi.c platform_int.c adc.c pwm.c ethernet.c"
 addm( "FORAVR32" )
 
 -- See board.h for possible BOARD values.

src/platform/avr32/conf.py

@@ -1,6 +1,6 @@
 # Configuration file for the AVR32 microcontrollers
 
-specific_files = "crt0.s trampoline.s platform.c exception.s intc.c pm.c flashc.c pm_conf_clocks.c usart.c gpio.c tc.c spi.c platform_int.c adc.c pwm.c"
+specific_files = "crt0.s trampoline.s platform.c exception.s intc.c pm.c flashc.c pm_conf_clocks.c usart.c gpio.c tc.c spi.c platform_int.c adc.c pwm.c ethernet.c"
 comp.Append(CPPDEFINES = 'FORAVR32')
 
 # See board.h for possible BOARD values.

src/platform/avr32/ethernet.c

@@ -0,0 +1,814 @@
+/* This source file is part of the ATMEL AVR32-UC3-SoftwareFramework-1.6.0 Release */
+
+/*This file has been prepared for Doxygen automatic documentation generation.*/
+/*! \file *********************************************************************
+ *
+ * \brief MACB driver for EVK1100 board.
+ *
+ * This file defines a useful set of functions for the MACB interface on
+ * AVR32 devices.
+ *
+ * - Compiler:           IAR EWAVR32 and GNU GCC for AVR32
+ * - Supported devices:  All AVR32 devices with a MACB module can be used.
+ * - AppNote:
+ *
+ * \author               Atmel Corporation: http://www.atmel.com \n
+ *                       Support and FAQ: http://support.atmel.no/
+ *
+ *****************************************************************************/
+
+/* Copyright (c) 2009 Atmel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an Atmel
+ * AVR product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ *
+ */
+/*
+ * ported on elua world by nuccio raciti <raciti.nuccio@gmail.com>, enjoy.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <avr32/io.h>
+
+#include "compiler.h"
+
+#include "platform_conf.h"
+
+#ifdef BUILD_UIP
+
+#include "ethernet.h"
+
+/* Size of each receive buffer - DO NOT CHANGE. */
+#define RX_BUFFER_SIZE    128
+
+
+/* The buffer addresses written into the descriptors must be aligned so the
+last two bits are zero.  These bits have special meaning for the MACB
+peripheral and cannot be used as part of the address. */
+#define ADDRESS_MASK      ( ( unsigned long ) 0xFFFFFFFC )
+
+/* Bit used within the address stored in the descriptor to mark the last
+descriptor in the array. */
+#define RX_WRAP_BIT       ( ( unsigned long ) 0x02 )
+
+/* A short delay is used to wait for a buffer to become available, should
+one not be immediately available when trying to transmit a frame. */
+#define BUFFER_WAIT_DELAY   ( 2 )
+
+#include "ethernet.h"
+#include "intc.h"
+#include "elua_uip.h"
+
+#ifndef FREERTOS_USED
+#define portENTER_CRITICAL           Disable_global_interrupt
+#define portEXIT_CRITICAL            Enable_global_interrupt
+#define portENTER_SWITCHING_ISR()
+#define portEXIT_SWITCHING_ISR()
+#endif
+
+#define TIMEOUT 500
+
+
+/* Buffer written to by the MACB DMA.  Must be aligned as described by the
+comment above the ADDRESS_MASK definition. */
+
+static volatile char pcRxBuffer[ ETHERNET_CONF_NB_RX_BUFFERS * RX_BUFFER_SIZE ] __attribute__ ((aligned (4)));
+/* Buffer read by the MACB DMA.  Must be aligned as described by the comment
+above the ADDRESS_MASK definition. */
+
+static volatile char pcTxBuffer[ ETHERNET_CONF_NB_TX_BUFFERS * ETHERNET_CONF_TX_BUFFER_SIZE ] __attribute__ ((aligned (4)));
+
+/* Descriptors used to communicate between the program and the MACB peripheral.
+These descriptors hold the locations and state of the Rx and Tx buffers.
+Alignment value chosen from RBQP and TBQP registers description in datasheet. */
+
+static volatile AVR32_TxTdDescriptor xTxDescriptors[ ETHERNET_CONF_NB_TX_BUFFERS ] __attribute__ ((aligned (8)));
+static volatile AVR32_RxTdDescriptor xRxDescriptors[ ETHERNET_CONF_NB_RX_BUFFERS ] __attribute__ ((aligned (8)));
+
+/* The IP and Ethernet addresses are read from the header files. */
+unsigned char cMACAddress[ 6 ] = { ETHERNET_CONF_ETHADDR0,ETHERNET_CONF_ETHADDR1,ETHERNET_CONF_ETHADDR2,ETHERNET_CONF_ETHADDR3,ETHERNET_CONF_ETHADDR4,ETHERNET_CONF_ETHADDR5 };
+
+/*-----------------------------------------------------------*/
+
+/* See the header file for descriptions of public functions. */
+
+/*
+ * Prototype for the MACB interrupt function - called by the asm wrapper.
+ */
+
+__attribute__((__interrupt__)) void vMACB_ISR(void);
+
+
+/*
+ * Initialise both the Tx and Rx descriptors used by the MACB.
+ */
+static void prvSetupDescriptors(volatile avr32_macb_t *macb);
+
+//
+// Restore ownership of all Rx buffers to the MACB.
+//
+static void vResetMacbRxFrames( void );
+
+/*
+ * Write our MAC address into the MACB.
+ */
+static void prvSetupMACAddress(volatile avr32_macb_t *macb);
+
+/*
+ * Configure the MACB for interrupts.
+ */
+static void prvSetupMACBInterrupt(volatile avr32_macb_t *macb);
+
+/*
+ * Some initialisation functions.
+ */
+static Bool prvProbePHY(volatile avr32_macb_t *macb);
+static unsigned long ulReadMDIO(volatile avr32_macb_t *macb, unsigned short usAddress);
+static void vWriteMDIO(volatile avr32_macb_t *macb, unsigned short usAddress, unsigned short usValue);
+
+
+/* Holds the index to the next buffer from which data will be read. */
+volatile unsigned long ulNextRxBuffer = 0;
+
+
+long lMACBSend(volatile avr32_macb_t *macb, const void *pvFrom, unsigned long ulLength, long lEndOfFrame)
+{
+  const unsigned char *pcFrom = pvFrom;
+  static unsigned long uxTxBufferIndex = 0;
+  void *pcBuffer;
+  unsigned long ulLastBuffer, ulDataBuffered = 0, ulDataRemainingToSend, ulLengthToSend;
+
+  /* If the length of data to be transmitted is greater than each individual
+  transmit buffer then the data will be split into more than one buffer.
+  Loop until the entire length has been buffered. */
+  while( ulDataBuffered < ulLength )
+  {
+    // Is a buffer available ?
+    while( !( xTxDescriptors[ uxTxBufferIndex ].U_Status.status & AVR32_TRANSMIT_OK ) )
+    {
+      // There is no room to write the Tx data to the Tx buffer.
+      // Wait a short while, then try again.
+      __asm__ __volatile__ ("nop");
+    }
+
+    portENTER_CRITICAL();
+    {
+      // Get the address of the buffer from the descriptor,
+      // then copy the data into the buffer.
+      pcBuffer = ( void * ) xTxDescriptors[ uxTxBufferIndex ].addr;
+
+      // How much can we write to the buffer ?
+      ulDataRemainingToSend = ulLength - ulDataBuffered;
+      if( ulDataRemainingToSend <= ETHERNET_CONF_TX_BUFFER_SIZE )
+      {
+        // We can write all the remaining bytes.
+        ulLengthToSend = ulDataRemainingToSend;
+      }
+      else
+      {
+        // We can't write more than ETH_TX_BUFFER_SIZE in one go.
+        ulLengthToSend = ETHERNET_CONF_TX_BUFFER_SIZE;
+      }
+      // Copy the data into the buffer.
+      memcpy( pcBuffer, &( pcFrom[ ulDataBuffered ] ), ulLengthToSend );
+      ulDataBuffered += ulLengthToSend;
+      // Is this the last data for the frame ?
+      if( lEndOfFrame && ( ulDataBuffered >= ulLength ) )
+      {
+        // No more data remains for this frame so we can start the transmission.
+        ulLastBuffer = AVR32_LAST_BUFFER;
+      }
+      else
+      {
+        // More data to come for this frame.
+        ulLastBuffer = 0;
+      }
+      // Fill out the necessary in the descriptor to get the data sent,
+      // then move to the next descriptor, wrapping if necessary.
+      if( uxTxBufferIndex >= ( ETHERNET_CONF_NB_TX_BUFFERS - 1 ) )
+      {
+        xTxDescriptors[ uxTxBufferIndex ].U_Status.status =   ( ulLengthToSend & ( unsigned long ) AVR32_LENGTH_FRAME )
+                                    | ulLastBuffer
+                                    | AVR32_TRANSMIT_WRAP;
+        uxTxBufferIndex = 0;
+      } else
+      {
+        xTxDescriptors[ uxTxBufferIndex ].U_Status.status =   ( ulLengthToSend & ( unsigned long ) AVR32_LENGTH_FRAME )
+                                    | ulLastBuffer;
+        uxTxBufferIndex++;
+      }
+      /* If this is the last buffer to be sent for this frame we can
+         start the transmission. */
+      if( ulLastBuffer )
+        macb->ncr |=  AVR32_MACB_TSTART_MASK;
+
+    }
+    portEXIT_CRITICAL();
+  }
+
+  return PASS;
+}
+
+
+unsigned long ulMACBInputLength(void)
+{
+  register unsigned long ulIndex , ulLength = 0;
+  unsigned int uiTemp;
+  volatile unsigned long ulEventStatus;
+
+  // Check if the MACB encountered a problem.
+  ulEventStatus = AVR32_MACB.rsr;
+  if( ulEventStatus & AVR32_MACB_RSR_BNA_MASK )
+  {     // MACB couldn't get ownership of a buffer. This could typically
+        // happen if the total numbers of Rx buffers is tailored too small
+        // for a noisy network with big frames.
+        // We might as well restore ownership of all buffers to the MACB to
+        // restart from a clean state.
+    vResetMacbRxFrames();
+    return( ulLength );
+  }
+
+  // Skip any fragments.  We are looking for the first buffer that contains
+  // data and has the SOF (start of frame) bit set.
+  while( ( xRxDescriptors[ ulNextRxBuffer ].addr & AVR32_OWNERSHIP_BIT )
+        && !( xRxDescriptors[ ulNextRxBuffer ].U_Status.status & AVR32_SOF ) )
+  {
+    // Ignoring this buffer.  Mark it as free again.
+    uiTemp = xRxDescriptors[ ulNextRxBuffer ].addr;
+    xRxDescriptors[ ulNextRxBuffer ].addr = uiTemp & ~( AVR32_OWNERSHIP_BIT );
+    ulNextRxBuffer++;
+    if( ulNextRxBuffer >= ETHERNET_CONF_NB_RX_BUFFERS )
+    {
+      ulNextRxBuffer = 0;
+    }
+  }
+
+  // We are going to walk through the descriptors that make up this frame,
+  // but don't want to alter ulNextRxBuffer as this would prevent vMACBRead()
+  // from finding the data.  Therefore use a copy of ulNextRxBuffer instead.
+  ulIndex = ulNextRxBuffer;
+
+  // Walk through the descriptors until we find the last buffer for this frame.
+  // The last buffer will give us the length of the entire frame.
+  while ( xRxDescriptors[ ulIndex ].addr & AVR32_OWNERSHIP_BIT )
+  {
+    ulLength = xRxDescriptors[ ulIndex ].U_Status.status & AVR32_LENGTH_FRAME;
+    if (ulLength) break; //return ulLength
+
+    // Increment to the next buffer, wrapping if necessary.
+    if( ++ulIndex >= ETHERNET_CONF_NB_RX_BUFFERS ) ulIndex = 0;
+
+    // Is the descriptor valid?
+    if (!(xRxDescriptors[ ulIndex ].addr & AVR32_OWNERSHIP_BIT)) break; //return 0
+
+    // Is it a SOF? If so, the head packet is bad and should be discarded
+    if (xRxDescriptors[ ulIndex ].U_Status.status & AVR32_SOF)
+    {
+      // Mark the buffers of the CURRENT, FAULTY packet available.
+      unsigned int i = ulNextRxBuffer;
+      do{
+        // Ignore the faulty frame. Mark its buffers as owned by the MACB.
+        uiTemp = xRxDescriptors[ i ].addr;
+        xRxDescriptors[ i ].addr = uiTemp & ~(AVR32_OWNERSHIP_BIT);
+        if (++i>=ETHERNET_CONF_NB_RX_BUFFERS) i=0;
+      }while (i!=ulIndex);
+      ulNextRxBuffer=ulIndex;
+      // We have the start of a new packet, look at that one instead.
+    }
+  }
+  return ulLength;
+}
+/*-----------------------------------------------------------*/
+
+void vMACBRead(void *pvTo, unsigned long ulSectionLength, unsigned long ulTotalFrameLength)
+{
+  unsigned char *pcTo = pvTo;
+  static unsigned long ulSectionBytesReadSoFar = 0, ulBufferPosition = 0, ulFrameBytesReadSoFar = 0;
+  static const unsigned char *pcSource;
+  register unsigned long ulBytesRemainingInBuffer, ulRemainingSectionBytes;
+  unsigned int uiTemp;
+
+  // Read ulSectionLength bytes from the Rx buffers.
+  // This is not necessarily any correspondence between the length of our Rx buffers,
+  // and the length of the data we are returning or the length of the data being requested.
+  // Therefore, between calls  we have to remember not only which buffer we are currently
+  // processing, but our position within that buffer.
+  // This would be greatly simplified if PBUF_POOL_BUFSIZE could be guaranteed to be greater
+  // than the size of each Rx buffer, and that memory fragmentation did not occur.
+
+  // This function should only be called after a call to ulMACBInputLength().
+  // This will ensure ulNextRxBuffer is set to the correct buffer. */
+
+  // vMACBRead is called with pcTo set to NULL to indicate that we are about
+  // to read a new frame.  Any fragments remaining in the frame we were
+  // processing during the last call should be dropped.
+  if( pcTo == NULL )
+  {
+    // How many bytes are indicated as being in this buffer?
+    // If none then the buffer is completely full and the frame is contained within more
+    // than one buffer.
+    // Reset our state variables ready for the next read from this buffer.
+    pcSource = ( unsigned char * )( xRxDescriptors[ ulNextRxBuffer ].addr & ADDRESS_MASK );
+    ulFrameBytesReadSoFar = ( unsigned long ) 0;
+    ulBufferPosition = ( unsigned long ) 0;
+  }
+  else
+  {
+    // Loop until we have obtained the required amount of data.
+    ulSectionBytesReadSoFar = 0;
+    while( ulSectionBytesReadSoFar < ulSectionLength )
+    {
+      // We may have already read some data from this buffer.
+      // How much data remains in the buffer?
+      ulBytesRemainingInBuffer = ( RX_BUFFER_SIZE - ulBufferPosition );
+
+      // How many more bytes do we need to read before we have the
+      // required amount of data?
+      ulRemainingSectionBytes = ulSectionLength - ulSectionBytesReadSoFar;
+
+      // Do we want more data than remains in the buffer?
+      if( ulRemainingSectionBytes > ulBytesRemainingInBuffer )
+      {
+        // We want more data than remains in the buffer so we can
+        // write the remains of the buffer to the destination, then move
+        // onto the next buffer to get the rest.
+        memcpy( &( pcTo[ ulSectionBytesReadSoFar ] ), &( pcSource[ ulBufferPosition ] ), ulBytesRemainingInBuffer );
+        ulSectionBytesReadSoFar += ulBytesRemainingInBuffer;
+        ulFrameBytesReadSoFar += ulBytesRemainingInBuffer;
+
+        // Mark the buffer as free again.
+        uiTemp = xRxDescriptors[ ulNextRxBuffer ].addr;
+        xRxDescriptors[ ulNextRxBuffer ].addr = uiTemp & ~( AVR32_OWNERSHIP_BIT );
+        // Move onto the next buffer.
+        ulNextRxBuffer++;
+
+        if( ulNextRxBuffer >= ETHERNET_CONF_NB_RX_BUFFERS )
+        {
+          ulNextRxBuffer = ( unsigned long ) 0;
+        }
+
+        // Reset the variables for the new buffer.
+        pcSource = ( unsigned char * )( xRxDescriptors[ ulNextRxBuffer ].addr & ADDRESS_MASK );
+        ulBufferPosition = ( unsigned long ) 0;
+      }
+      else
+      {
+        // We have enough data in this buffer to send back.
+        // Read out enough data and remember how far we read up to.
+        memcpy( &( pcTo[ ulSectionBytesReadSoFar ] ), &( pcSource[ ulBufferPosition ] ), ulRemainingSectionBytes );
+
+        // There may be more data in this buffer yet.
+        // Increment our position in this buffer past the data we have just read.
+        ulBufferPosition += ulRemainingSectionBytes;
+        ulSectionBytesReadSoFar += ulRemainingSectionBytes;
+        ulFrameBytesReadSoFar += ulRemainingSectionBytes;
+
+        // Have we now finished with this buffer?
+        if( ( ulBufferPosition >= RX_BUFFER_SIZE ) || ( ulFrameBytesReadSoFar >= ulTotalFrameLength ) )
+        {
+          // Mark the buffer as free again.
+          uiTemp = xRxDescriptors[ ulNextRxBuffer ].addr;
+          xRxDescriptors[ ulNextRxBuffer ].addr = uiTemp & ~( AVR32_OWNERSHIP_BIT );
+          // Move onto the next buffer.
+          ulNextRxBuffer++;
+
+          if( ulNextRxBuffer >= ETHERNET_CONF_NB_RX_BUFFERS )
+          {
+            ulNextRxBuffer = 0;
+          }
+
+          pcSource = ( unsigned char * )( xRxDescriptors[ ulNextRxBuffer ].addr & ADDRESS_MASK );
+          ulBufferPosition = 0;
+        }
+      }
+    }
+  }
+}
+
+/*-----------------------------------------------------------*/
+void vMACBFlushCurrentPacket(unsigned long ulTotalFrameLength)
+{
+   unsigned int   uiTemp;
+   long int lTotalFrameLen = (long int)ulTotalFrameLength;
+
+   while( lTotalFrameLen > 0 )
+   {
+      // Ignoring this buffer.  Mark it as free again.
+      uiTemp = xRxDescriptors[ ulNextRxBuffer ].addr;
+      xRxDescriptors[ ulNextRxBuffer ].addr = uiTemp & ~( AVR32_OWNERSHIP_BIT );
+
+      // Move on to the next buffer.
+      ulNextRxBuffer++;
+      ulNextRxBuffer = ulNextRxBuffer%ETHERNET_CONF_NB_RX_BUFFERS;
+
+      lTotalFrameLen -= RX_BUFFER_SIZE;
+   }
+}
+
+
+/*-----------------------------------------------------------*/
+void vMACBSetMACAddress(const unsigned char *MACAddress)
+{
+  memcpy(cMACAddress, MACAddress, sizeof(cMACAddress));
+}
+
+Bool xMACBInit(volatile avr32_macb_t *macb)
+{
+  Bool global_interrupt_enabled = Is_global_interrupt_enabled();
+  volatile unsigned long status;
+
+  //vDisableMACBOperations(macb);
+
+  // set up registers
+  macb->ncr = 0;
+  macb->tsr = ~0UL;
+  macb->rsr = ~0UL;
+
+  if (global_interrupt_enabled) Disable_global_interrupt();
+  macb->idr = ~0UL;
+  status = macb->isr;
+  if (global_interrupt_enabled) Enable_global_interrupt();
+
+  // RMII used, set 0 to the USRIO Register
+  macb->usrio &= ~AVR32_MACB_RMII_MASK;
+
+  // Load our MAC address into the MACB.
+  prvSetupMACAddress(macb);
+
+  // Setup the buffers and descriptors.
+  prvSetupDescriptors(macb);
+
+#if ETHERNET_CONF_SYSTEM_CLOCK <= 20000000
+  macb->ncfgr |= (AVR32_MACB_NCFGR_CLK_DIV8 << AVR32_MACB_NCFGR_CLK_OFFSET);
+#elif ETHERNET_CONF_SYSTEM_CLOCK <= 40000000
+  macb->ncfgr |= (AVR32_MACB_NCFGR_CLK_DIV16 << AVR32_MACB_NCFGR_CLK_OFFSET);
+#elif ETHERNET_CONF_SYSTEM_CLOCK <= 80000000
+  macb->ncfgr |= AVR32_MACB_NCFGR_CLK_DIV32 << AVR32_MACB_NCFGR_CLK_OFFSET;
+#elif ETHERNET_CONF_SYSTEM_CLOCK <= 160000000
+  macb->ncfgr |= AVR32_MACB_NCFGR_CLK_DIV64 << AVR32_MACB_NCFGR_CLK_OFFSET;
+#else
+# error System clock too fast
+#endif
+
+  // Are we connected?
+  if( prvProbePHY(macb) == TRUE )
+  {
+    // Enable the interrupt!
+    portENTER_CRITICAL();
+    {
+      prvSetupMACBInterrupt(macb);
+    }
+    portEXIT_CRITICAL();
+    // Enable Rx and Tx, plus the stats register.
+    macb->ncr = AVR32_MACB_NCR_TE_MASK | AVR32_MACB_NCR_RE_MASK;
+    return (TRUE);
+  }
+  return (FALSE);
+}
+
+void vDisableMACBOperations (volatile avr32_macb_t *macb)
+{
+  Bool global_interrupt_enabled = Is_global_interrupt_enabled();
+
+  // write the MACB control register : disable Tx & Rx
+  macb->ncr &= ~((1 << AVR32_MACB_RE_OFFSET) | (1 << AVR32_MACB_TE_OFFSET));
+
+  // We no more want to interrupt on Rx and Tx events.
+  if (global_interrupt_enabled) Disable_global_interrupt();
+  macb->idr = AVR32_MACB_IER_RCOMP_MASK | AVR32_MACB_IER_TCOMP_MASK;
+  macb->isr;
+  if (global_interrupt_enabled) Enable_global_interrupt();
+}
+
+
+void vClearMACBTxBuffer(void)
+{
+  static unsigned long uxNextBufferToClear = 0;
+
+  // Called on Tx interrupt events to set the AVR32_TRANSMIT_OK bit in each
+  // Tx buffer within the frame just transmitted.  This marks all the buffers
+  // as available again.
+
+  // The first buffer in the frame should have the bit set automatically. */
+  if( xTxDescriptors[ uxNextBufferToClear ].U_Status.status & AVR32_TRANSMIT_OK )
+  {
+    // Loop through the other buffers in the frame.
+    while( !( xTxDescriptors[ uxNextBufferToClear ].U_Status.status & AVR32_LAST_BUFFER ) )
+    {
+      uxNextBufferToClear++;
+
+      if( uxNextBufferToClear >= ETHERNET_CONF_NB_TX_BUFFERS )
+      {
+        uxNextBufferToClear = 0;
+      }
+
+      xTxDescriptors[ uxNextBufferToClear ].U_Status.status |= AVR32_TRANSMIT_OK;
+    }
+
+    // Start with the next buffer the next time a Tx interrupt is called.
+    uxNextBufferToClear++;
+
+    // Do we need to wrap back to the first buffer?
+    if( uxNextBufferToClear >= ETHERNET_CONF_NB_TX_BUFFERS )
+    {
+      uxNextBufferToClear = 0;
+    }
+  }
+}
+
+static void prvSetupDescriptors(volatile avr32_macb_t *macb)
+{
+  unsigned long xIndex;
+  unsigned long ulAddress;
+
+  // Initialise xRxDescriptors descriptor.
+  for( xIndex = 0; xIndex < ETHERNET_CONF_NB_RX_BUFFERS; ++xIndex )
+  {
+    // Calculate the address of the nth buffer within the array.
+    ulAddress = ( unsigned long )( pcRxBuffer + ( xIndex * RX_BUFFER_SIZE ) );
+
+    // Write the buffer address into the descriptor.
+    // The DMA will place the data at this address when this descriptor is being used.
+    // No need to mask off the bottom bits of the address (these have special meaning
+    // for the MACB) because pcRxBuffer is 4Bytes-aligned.
+    xRxDescriptors[ xIndex ].addr = ulAddress;
+  }
+
+  // The last buffer has the wrap bit set so the MACB knows to wrap back
+  // to the first buffer.
+  xRxDescriptors[ ETHERNET_CONF_NB_RX_BUFFERS - 1 ].addr |= RX_WRAP_BIT;
+
+  // Initialise xTxDescriptors.
+  for( xIndex = 0; xIndex < ETHERNET_CONF_NB_TX_BUFFERS; ++xIndex )
+  {
+    // Calculate the address of the nth buffer within the array.
+    ulAddress = ( unsigned long )( pcTxBuffer + ( xIndex * ETHERNET_CONF_TX_BUFFER_SIZE ) );
+
+    // Write the buffer address into the descriptor.
+    // The DMA will read data from here when the descriptor is being used.
+    xTxDescriptors[ xIndex ].addr = ulAddress;
+    xTxDescriptors[ xIndex ].U_Status.status = AVR32_TRANSMIT_OK;
+  }
+
+  // The last buffer has the wrap bit set so the MACB knows to wrap back
+  // to the first buffer.
+  xTxDescriptors[ ETHERNET_CONF_NB_TX_BUFFERS - 1 ].U_Status.status = AVR32_TRANSMIT_WRAP | AVR32_TRANSMIT_OK;
+
+  // Tell the MACB where to find the descriptors.
+  macb->rbqp =   ( unsigned long )xRxDescriptors;
+  macb->tbqp =   ( unsigned long )xTxDescriptors;
+
+  // Do not copy the FCS field of received frames to memory.
+  macb->ncfgr |= ( AVR32_MACB_NCFGR_DRFCS_MASK );
+
+}
+
+//!
+//! \brief Restore ownership of all Rx buffers to the MACB.
+//!
+static void vResetMacbRxFrames( void )
+{
+   register unsigned long  ulIndex;
+   unsigned int            uiTemp;
+
+
+   // Disable MACB frame reception.
+   AVR32_MACB.ncr &= ~(AVR32_MACB_NCR_RE_MASK);
+
+   // Restore ownership of all Rx buffers to the MACB.
+   for( ulIndex = 0; ulIndex < ETHERNET_CONF_NB_RX_BUFFERS; ++ulIndex )
+   {
+      // Mark the buffer as owned by the MACB.
+      uiTemp = xRxDescriptors[ ulIndex ].addr;
+      xRxDescriptors[ ulIndex ].addr = uiTemp & ~( AVR32_OWNERSHIP_BIT );
+   }
+
+   // Reset the Buffer-not-available bit and the overrun bit.
+   AVR32_MACB.rsr = AVR32_MACB_RSR_BNA_MASK | AVR32_MACB_RSR_OVR_MASK;  // Clear
+   AVR32_MACB.rsr; // We read to force the previous operation.
+
+   // Reset the MACB starting point.
+   AVR32_MACB.rbqp = ( unsigned long )xRxDescriptors;
+
+   // Reset the index to the next buffer from which data will be read.
+   ulNextRxBuffer = 0;
+
+   // Enable MACB frame reception.
+   AVR32_MACB.ncr |= AVR32_MACB_NCR_RE_MASK;
+}
+
+
+static void prvSetupMACAddress(volatile avr32_macb_t *macb)
+{
+  // Must be written SA1L then SA1H.
+  macb->sa1b =  ( ( unsigned long ) cMACAddress[ 3 ] << 24 ) |
+                ( ( unsigned long ) cMACAddress[ 2 ] << 16 ) |
+                ( ( unsigned long ) cMACAddress[ 1 ] << 8  ) |
+                                    cMACAddress[ 0 ];
+
+  macb->sa1t =  ( ( unsigned long ) cMACAddress[ 5 ] << 8 ) |
+                                    cMACAddress[ 4 ];
+}
+
+static void prvSetupMACBInterrupt(volatile avr32_macb_t *macb)
+{
+
+    // Setup the interrupt for MACB.
+    // Register the interrupt handler to the interrupt controller at interrupt level 2
+    INTC_register_interrupt((__int_handler)&vMACB_ISR, AVR32_MACB_IRQ, AVR32_INTC_INT2);
+
+    // We want to interrupt on Rx and Tx events
+    macb->ier = AVR32_MACB_IER_RCOMP_MASK | AVR32_MACB_IER_TCOMP_MASK ;
+}
+
+/*! Read a register on MDIO bus (access to the PHY)
+ *         This function is looping until PHY gets ready
+ *
+ * \param macb         Input. instance of the MACB to use
+ * \param usAddress    Input. register to set.
+ *
+ * \return unsigned long data that has been read
+ */
+static unsigned long ulReadMDIO(volatile avr32_macb_t *macb, unsigned short usAddress)
+{
+  unsigned long value, status;
+  u16 timeout = 0;
+
+  // initiate transaction : enable management port
+  macb->ncr |= AVR32_MACB_NCR_MPE_MASK;
+  // Write the PHY configuration frame to the MAN register
+  macb->man = (AVR32_MACB_SOF_MASK & (0x01<<AVR32_MACB_SOF_OFFSET))  // SOF
+            | (2 << AVR32_MACB_CODE_OFFSET)                          // Code
+            | (2 << AVR32_MACB_RW_OFFSET)                            // Read operation
+            | ((ETHERNET_CONF_PHY_ADDR & 0x1f) << AVR32_MACB_PHYA_OFFSET)  // Phy Add
+            | (usAddress << AVR32_MACB_REGA_OFFSET);                 // Reg Add
+  // wait for PHY to be ready
+  do {
+    status = macb->nsr;
+  } while (!(status & AVR32_MACB_NSR_IDLE_MASK) && (timeout++ < TIMEOUT));
+  // read the register value in maintenance register
+  value = macb->man & 0x0000ffff;
+  // disable management port
+  macb->ncr &= ~AVR32_MACB_NCR_MPE_MASK;
+  // return the read value
+  return (value);
+}
+
+/*! Write a given value to a register on MDIO bus (access to the PHY)
+ *         This function is looping until PHY gets ready
+ *
+ * \param *macb        Input. instance of the MACB to use
+ * \param usAddress    Input. register to set.
+ * \param usValue      Input. value to write.
+ *
+ */
+static void vWriteMDIO(volatile avr32_macb_t *macb, unsigned short usAddress, unsigned short usValue)
+{
+  unsigned long status;
+  u16 timeout = 0;
+
+  // initiate transaction : enable management port
+  macb->ncr |= AVR32_MACB_NCR_MPE_MASK;
+  // Write the PHY configuration frame to the MAN register
+  macb->man = (( AVR32_MACB_SOF_MASK & (0x01<<AVR32_MACB_SOF_OFFSET)) // SOF
+             | (2 << AVR32_MACB_CODE_OFFSET)                          // Code
+             | (1 << AVR32_MACB_RW_OFFSET)                            // Write operation
+             | ((ETHERNET_CONF_PHY_ADDR & 0x1f) << AVR32_MACB_PHYA_OFFSET)  // Phy Add
+             | (usAddress << AVR32_MACB_REGA_OFFSET))                 // Reg Add
+             | (usValue & 0xffff);                                    // Data
+  // wait for PHY to be ready
+  do {
+    status = macb->nsr;
+  } while (!(status & AVR32_MACB_NSR_IDLE_MASK) && (timeout++ < TIMEOUT));
+  // disable management port
+  macb->ncr &= ~AVR32_MACB_NCR_MPE_MASK;
+}
+
+static Bool prvProbePHY(volatile avr32_macb_t *macb)
+{
+  volatile unsigned long mii_status, phy_ctrl;
+  volatile unsigned long config;
+  unsigned long upper, lower, mode, advertise, lpa;
+  volatile unsigned long physID;
+
+  // Read Phy Identifier register 1 & 2
+  lower = ulReadMDIO(macb, PHY_PHYSID2);
+  upper = ulReadMDIO(macb, PHY_PHYSID1);
+  // get Phy ID, ignore Revision
+  physID = ((upper << 16) & 0xFFFF0000) | (lower & 0xFFF0);
+  // check if it match config
+  if (physID == ETHERNET_CONF_PHY_ID)
+  {
+    // read RBR
+    mode = ulReadMDIO(macb, PHY_RBR);
+    // set RMII mode if not done
+    if ((mode & RBR_RMII) != RBR_RMII)
+    {
+      // force RMII flag if strap options are wrong
+      mode |= RBR_RMII;
+      vWriteMDIO(macb, PHY_RBR, mode);
+    }
+
+    advertise = ADVERTISE_CSMA | ADVERTISE_ALL;
+    // write advertise register
+    vWriteMDIO(macb, PHY_ADVERTISE, advertise);
+    // read Control register
+    config = ulReadMDIO(macb, PHY_BMCR);
+    // read Phy Control register
+    phy_ctrl = ulReadMDIO(macb, PHY_PHYCR);
+    // enable Auto MDIX
+    phy_ctrl |= PHYCR_MDIX_EN;
+    // reset auto-negociation capability
+    config |= (BMCR_ANRESTART | BMCR_ANENABLE);
+    // update Phy ctrl register
+    vWriteMDIO(macb, PHY_PHYCR, phy_ctrl);
+
+    // update ctrl register
+    vWriteMDIO(macb, PHY_BMCR, config);
+
+    // loop while link status isn't OK
+    do {
+      mii_status = ulReadMDIO(macb, PHY_BMSR);
+    } while (!(mii_status & BMSR_LSTATUS));
+
+    // read the LPA configuration of the PHY
+    lpa = ulReadMDIO(macb, PHY_LPA);
+
+    // read the MACB config register
+    config = AVR32_MACB.ncfgr;
+
+    // if 100MB needed
+    if ((lpa & advertise) & (LPA_100HALF | LPA_100FULL))
+      config |= AVR32_MACB_SPD_MASK;
+    else
+      config &= ~(AVR32_MACB_SPD_MASK);
+
+    // if FULL DUPLEX needed
+    if ((lpa & advertise) & (LPA_10FULL | LPA_100FULL))
+      config |= AVR32_MACB_FD_MASK;
+    else
+      config &= ~(AVR32_MACB_FD_MASK);
+
+    // write the MACB config register
+    macb->ncfgr = config;
+
+    return TRUE;
+  }
+  return FALSE;
+}
+
+/*
+ * The MACB ISR.  Handles both Tx and Rx complete interrupts.
+ */
+__attribute__((__interrupt__)) void vMACB_ISR(void)
+{
+  // Variable definitions can be made now.
+  volatile unsigned long ulIntStatus, ulEventStatus;
+
+	  // Find the cause of the interrupt.
+  ulIntStatus = AVR32_MACB.isr;
+  ulEventStatus = AVR32_MACB.rsr;
+
+  if( ( ulIntStatus & AVR32_MACB_IDR_RCOMP_MASK ) || ( ulEventStatus & AVR32_MACB_REC_MASK ) )
+  {
+    // A frame has been received, signal the IP task so it can process
+    // the Rx descriptors.
+    elua_uip_mainloop();
+    AVR32_MACB.rsr =  AVR32_MACB_REC_MASK;  // Clear
+    AVR32_MACB.rsr; // Read to force the previous write
+  }
+
+  if( ulIntStatus & AVR32_MACB_TCOMP_MASK )
+  {
+    // A frame has been transmitted.  Mark all the buffers used by the
+    // frame just transmitted as free again.
+    vClearMACBTxBuffer();
+    AVR32_MACB.tsr =  AVR32_MACB_TSR_COMP_MASK; // Clear
+    AVR32_MACB.tsr; // Read to force the previous write
+  }
+}
+#endif

src/platform/avr32/ethernet.h

@@ -0,0 +1,492 @@
+/* This header file is part of the ATMEL AVR32-UC3-SoftwareFramework-1.6.0 Release */
+
+/*This file has been prepared for Doxygen automatic documentation generation.*/
+/*! \file *********************************************************************
+ *
+ * \brief MACB driver.
+ *
+ * This file defines a useful set of functions for the MACB interface on
+ * AVR32 devices.
+ *
+ * - Compiler:           IAR EWAVR32 and GNU GCC for AVR32
+ * - Supported devices:  All AVR32 devices with a MACB module can be used.
+ * - AppNote:
+ *
+ * \author               Atmel Corporation: http://www.atmel.com \n
+ *                       Support and FAQ: http://support.atmel.no/
+ *
+ *****************************************************************************/
+
+/* Copyright (c) 2009 Atmel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an Atmel
+ * AVR product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ *
+ */
+
+#ifndef AVR32_ETHERNET_H
+#define AVR32_ETHERNET_H
+
+#include <avr32/io.h>
+
+#include "compiler.h"
+
+
+/*! \name Rx Ring descriptor flags
+ */
+//! @{
+#define AVR32_MACB_RX_USED_OFFSET       0
+#define AVR32_MACB_RX_USED_SIZE         1
+#define AVR32_MACB_RX_WRAP_OFFSET       1
+#define AVR32_MACB_RX_WRAP_SIZE         1
+#define AVR32_MACB_RX_LEN_OFFSET        0
+#define AVR32_MACB_RX_LEN_SIZE         12
+#define AVR32_MACB_RX_OFFSET_OFFSET    12
+#define AVR32_MACB_RX_OFFSET_SIZE       2
+#define AVR32_MACB_RX_SOF_OFFSET       14
+#define AVR32_MACB_RX_SOF_SIZE          1
+#define AVR32_MACB_RX_EOF_OFFSET       15
+#define AVR32_MACB_RX_EOF_SIZE          1
+#define AVR32_MACB_RX_CFI_OFFSET       16
+#define AVR32_MACB_RX_CFI_SIZE          1
+//! @}
+
+/*! \name Tx Ring descriptor flags
+ */
+//! @{
+#define AVR32_MACB_TX_LEN_OFFSET        0
+#define AVR32_MACB_TX_LEN_SIZE         11
+#define AVR32_MACB_TX_EOF_OFFSET       15
+#define AVR32_MACB_TX_EOF_SIZE          1
+#define AVR32_MACB_TX_NOCRC_OFFSET     16
+#define AVR32_MACB_TX_NOCRC_SIZE        1
+#define AVR32_MACB_TX_EMF_OFFSET       27
+#define AVR32_MACB_TX_EMF_SIZE          1
+#define AVR32_MACB_TX_UNR_OFFSET       28
+#define AVR32_MACB_TX_UNR_SIZE          1
+#define AVR32_MACB_TX_MAXRETRY_OFFSET  29
+#define AVR32_MACB_TX_MAXRETRY_SIZE     1
+#define AVR32_MACB_TX_WRAP_OFFSET      30
+#define AVR32_MACB_TX_WRAP_SIZE         1
+#define AVR32_MACB_TX_USED_OFFSET      31
+#define AVR32_MACB_TX_USED_SIZE         1
+//! @}
+
+/*! \name Generic MII registers.
+ */
+//! @{
+#define PHY_BMCR            0x00        //!< Basic mode control register
+#define PHY_BMSR            0x01        //!< Basic mode status register
+#define PHY_PHYSID1         0x02        //!< PHYS ID 1
+#define PHY_PHYSID2         0x03        //!< PHYS ID 2
+#define PHY_ADVERTISE       0x04        //!< Advertisement control reg
+#define PHY_LPA             0x05        //!< Link partner ability reg
+//! @}
+
+
+#define PHY_RBR             0x17        //!< RMII Bypass reg
+#define PHY_MICR            0x11        //!< Interrupt Control reg
+#define PHY_MISR            0x12        //!< Interrupt Status reg
+#define PHY_PHYCR           0x19        //!< Phy CTRL reg
+
+/*! \name Basic mode control register.
+ */
+//! @{
+#define BMCR_RESV               0x007f  //!< Unused...
+#define BMCR_CTST               0x0080  //!< Collision test
+#define BMCR_FULLDPLX           0x0100  //!< Full duplex
+#define BMCR_ANRESTART          0x0200  //!< Auto negotiation restart
+#define BMCR_ISOLATE            0x0400  //!< Disconnect PHY from MII
+#define BMCR_PDOWN              0x0800  //!< Powerdown the PHY
+#define BMCR_ANENABLE           0x1000  //!< Enable auto negotiation
+#define BMCR_SPEED100           0x2000  //!< Select 100Mbps
+#define BMCR_LOOPBACK           0x4000  //!< TXD loopback bits
+#define BMCR_RESET              0x8000  //!< Reset the PHY
+//! @}
+
+/*! \name Basic mode status register.
+ */
+//! @{
+#define BMSR_ERCAP              0x0001  //!< Ext-reg capability
+#define BMSR_JCD                0x0002  //!< Jabber detected
+#define BMSR_LSTATUS            0x0004  //!< Link status
+#define BMSR_ANEGCAPABLE        0x0008  //!< Able to do auto-negotiation
+#define BMSR_RFAULT             0x0010  //!< Remote fault detected
+#define BMSR_ANEGCOMPLETE       0x0020  //!< Auto-negotiation complete
+#define BMSR_RESV               0x00c0  //!< Unused...
+#define BMSR_ESTATEN            0x0100  //!< Extended Status in R15
+#define BMSR_100FULL2           0x0200  //!< Can do 100BASE-T2 HDX
+#define BMSR_100HALF2           0x0400  //!< Can do 100BASE-T2 FDX
+#define BMSR_10HALF             0x0800  //!< Can do 10mbps, half-duplex
+#define BMSR_10FULL             0x1000  //!< Can do 10mbps, full-duplex
+#define BMSR_100HALF            0x2000  //!< Can do 100mbps, half-duplex
+#define BMSR_100FULL            0x4000  //!< Can do 100mbps, full-duplex
+#define BMSR_100BASE4           0x8000  //!< Can do 100mbps, 4k packets
+//! @}
+
+/*! \name Advertisement control register.
+ */
+//! @{
+#define ADVERTISE_SLCT          0x001f  //!< Selector bits
+#define ADVERTISE_CSMA          0x0001  //!< Only selector supported
+#define ADVERTISE_10HALF        0x0020  //!< Try for 10mbps half-duplex
+#define ADVERTISE_1000XFULL     0x0020  //!< Try for 1000BASE-X full-duplex
+#define ADVERTISE_10FULL        0x0040  //!< Try for 10mbps full-duplex
+#define ADVERTISE_1000XHALF     0x0040  //!< Try for 1000BASE-X half-duplex
+#define ADVERTISE_100HALF       0x0080  //!< Try for 100mbps half-duplex
+#define ADVERTISE_1000XPAUSE    0x0080  //!< Try for 1000BASE-X pause
+#define ADVERTISE_100FULL       0x0100  //!< Try for 100mbps full-duplex
+#define ADVERTISE_1000XPSE_ASYM 0x0100  //!< Try for 1000BASE-X asym pause
+#define ADVERTISE_100BASE4      0x0200  //!< Try for 100mbps 4k packets
+#define ADVERTISE_PAUSE_CAP     0x0400  //!< Try for pause
+#define ADVERTISE_PAUSE_ASYM    0x0800  //!< Try for asymetric pause
+#define ADVERTISE_RESV          0x1000  //!< Unused...
+#define ADVERTISE_RFAULT        0x2000  //!< Say we can detect faults
+#define ADVERTISE_LPACK         0x4000  //!< Ack link partners response
+#define ADVERTISE_NPAGE         0x8000  //!< Next page bit
+//! @}
+
+#define ADVERTISE_FULL (ADVERTISE_100FULL | ADVERTISE_10FULL | ADVERTISE_CSMA)
+#define ADVERTISE_ALL (ADVERTISE_10HALF | ADVERTISE_10FULL | \
+                       ADVERTISE_100HALF | ADVERTISE_100FULL)
+
+/*! \name Link partner ability register.
+ */
+//! @{
+#define LPA_SLCT                0x001f  //!< Same as advertise selector
+#define LPA_10HALF              0x0020  //!< Can do 10mbps half-duplex
+#define LPA_1000XFULL           0x0020  //!< Can do 1000BASE-X full-duplex
+#define LPA_10FULL              0x0040  //!< Can do 10mbps full-duplex
+#define LPA_1000XHALF           0x0040  //!< Can do 1000BASE-X half-duplex
+#define LPA_100HALF             0x0080  //!< Can do 100mbps half-duplex
+#define LPA_1000XPAUSE          0x0080  //!< Can do 1000BASE-X pause
+#define LPA_100FULL             0x0100  //!< Can do 100mbps full-duplex
+#define LPA_1000XPAUSE_ASYM     0x0100  //!< Can do 1000BASE-X pause asym
+#define LPA_100BASE4            0x0200  //!< Can do 100mbps 4k packets
+#define LPA_PAUSE_CAP           0x0400  //!< Can pause
+#define LPA_PAUSE_ASYM          0x0800  //!< Can pause asymetrically
+#define LPA_RESV                0x1000  //!< Unused...
+#define LPA_RFAULT              0x2000  //!< Link partner faulted
+#define LPA_LPACK               0x4000  //!< Link partner acked us
+#define LPA_NPAGE               0x8000  //!< Next page bit
+
+#define LPA_DUPLEX    (LPA_10FULL | LPA_100FULL)
+#define LPA_100       (LPA_100FULL | LPA_100HALF | LPA_100BASE4)
+//! @}
+
+
+/*! RMII Bypass Register */
+#define RBR_RMII                 0x0020  //!< RMII Mode
+/*! \name Interrupt Ctrl Register.
+ */
+//! @{
+#define MICR_INTEN               0x0002  //!< Enable interrupts
+#define MICR_INTOE               0x0001  //!< Enable INT output
+//! @}
+
+/*! \name Interrupt Status Register.
+ */
+//! @{
+#define MISR_ED_INT_EN           0x0040  //!< Energy Detect enabled
+#define MISR_LINK_INT_EN         0x0020  //!< Link status change enabled
+#define MISR_SPD_INT_EN          0x0010  //!< Speed change enabled
+#define MISR_DP_INT_EN           0x0008  //!< Duplex mode change enabled
+#define MISR_ANC_INT_EN          0x0004  //!< Auto-Neg complete enabled
+#define MISR_FHF_INT_EN          0x0002  //!< False Carrier enabled
+#define MISR_RHF_INT_EN          0x0001  //!< Receive Error enabled
+#define MISR_ED_INT              0x4000  //!< Energy Detect
+#define MISR_LINK_INT            0x2000  //!< Link status change
+#define MISR_SPD_INT             0x1000  //!< Speed change
+#define MISR_DP_INT              0x0800  //!< Duplex mode change
+#define MISR_ANC_INT             0x0400  //!< Auto-Neg complete
+#define MISR_FHF_INT             0x0200  //!< False Carrier
+#define MISR_RHF_INT             0x0100  //!< Receive Error
+//! @}
+
+/*! \name Phy Ctrl Register.
+ */
+//! @{
+#define PHYCR_MDIX_EN            0x8000  //!< Enable Auto MDIX
+#define PHYCR_MDIX_FORCE         0x4000  //!< Force MDIX crossed
+//! @}
+
+/* Size of each receive buffer - DO NOT CHANGE. */
+#define RX_BUFFER_SIZE    128
+
+
+/* The buffer addresses written into the descriptors must be aligned so the
+last two bits are zero.  These bits have special meaning for the MACB
+peripheral and cannot be used as part of the address. */
+#define ADDRESS_MASK      ( ( unsigned long ) 0xFFFFFFFC )
+
+/* Bit used within the address stored in the descriptor to mark the last
+descriptor in the array. */
+#define RX_WRAP_BIT       ( ( unsigned long ) 0x02 )
+
+/* A short delay is used to wait for a buffer to become available, should
+one not be immediately available when trying to transmit a frame. */
+#define BUFFER_WAIT_DELAY   ( 2 )
+
+
+/*! location of net config file on the file system */
+#define ETHERNET_CONFIG_FILE "A:/CFG/net.txt"
+
+/*! Phy Address (set through strap options) */
+#define ETHERNET_CONF_PHY_ADDR             0x01
+#define ETHERNET_CONF_PHY_ID               0x20005C90
+
+/*! Number of receive buffers. Max ethernet frame size is 1526. A Rx buffer is
+128 Bytes long. So 12 Rx buffers are necessary to store one max sized frame.
+Multiply that by 2 for performance. */
+#define ETHERNET_CONF_NB_RX_BUFFERS        24
+
+/*! USE_RMII_INTERFACE must be defined as 1 to use an RMII interface, or 0
+to use an MII interface. */
+#define ETHERNET_CONF_USE_RMII_INTERFACE   1
+
+/*! Number of Transmit buffers */
+#define ETHERNET_CONF_NB_TX_BUFFERS        10
+
+/*! Size of each Transmit buffer. */
+#define ETHERNET_CONF_TX_BUFFER_SIZE       512
+
+/*! Clock definition */
+#define ETHERNET_CONF_SYSTEM_CLOCK         60000000
+
+/*! Allow Auto Negociation */
+#define ETHERNET_CONF_AN_ENABLE            1
+
+/*! Use auto cross capability. Used by default. */
+#define ETHERNET_CONF_AUTO_CROSS_ENABLE    1
+/*! Use direct cable. Ignored when ETHERNET_CONF_AN_ENABLE and
+    ETHERNET_CONF_AUTO_CROSS_ENABLE are enabled. */
+#define ETHERNET_CONF_CROSSED_LINK         0
+
+/* ethernet default parameters */
+/*! MAC address definition.  The MAC address must be unique on the network. */
+#define ETHERNET_CONF_ETHADDR0   0x00
+#define ETHERNET_CONF_ETHADDR1   0x04
+#define ETHERNET_CONF_ETHADDR2   0x25
+#define ETHERNET_CONF_ETHADDR3   0x00
+#define ETHERNET_CONF_ETHADDR4   0x01
+#define ETHERNET_CONF_ETHADDR5   0x02
+
+
+
+/*! set to 1 if Phy status changes handle an interrupt */
+#define ETHERNET_CONF_USE_PHY_IT           0
+
+
+/*! Packet structure.
+ */
+//! @{
+typedef struct
+{
+  unsigned char *data;
+  unsigned int len;
+} macb_packet_t;
+//! @}
+
+/*! Receive Transfer descriptor structure.
+ */
+//! @{
+typedef struct  _AVR32_RxTdDescriptor {
+  unsigned int addr;
+  union
+  {
+    unsigned int status;
+    struct {
+      unsigned int BroadCast:1;
+      unsigned int MultiCast:1;
+      unsigned int UniCast:1;
+      unsigned int ExternalAdd:1;
+      unsigned int Res1:1;
+      unsigned int Sa1Match:1;
+      unsigned int Sa2Match:1;
+      unsigned int Sa3Match:1;
+      unsigned int Sa4Match:1;
+      unsigned int TypeID:1;
+      unsigned int VlanTag:1;
+      unsigned int PriorityTag:1;
+      unsigned int VlanPriority:3;
+      unsigned int Cfi:1;
+      unsigned int EndOfFrame:1;
+      unsigned int StartOfFrame:1;
+      unsigned int Rxbuf_off:2;
+      unsigned int Res0:1;
+      unsigned int Length:11;
+    }S_Status;
+  }U_Status;
+}AVR32_RxTdDescriptor, *AVR32P_RxTdDescriptor;
+//! @}
+
+/*! Transmit Transfer descriptor structure.
+ */
+//! @{
+typedef struct _AVR32_TxTdDescriptor {
+  unsigned int addr;
+  union
+  {
+    unsigned int status;
+    struct {
+      unsigned int BuffUsed:1;
+      unsigned int Wrap:1;
+      unsigned int TransmitError:1;
+      unsigned int TransmitUnderrun:1;
+      unsigned int BufExhausted:1;
+      unsigned int Res1:10;
+      unsigned int NoCrc:1;
+      unsigned int LastBuff:1;
+      unsigned int Res0:4;
+      unsigned int Length:11;
+    }S_Status;
+  }U_Status;
+}AVR32_TxTdDescriptor, *AVR32P_TxTdDescriptor;
+//! @}
+
+
+/*! Mask for frame used. */
+#define AVR32_OWNERSHIP_BIT   0x00000001
+
+/*! Receive status defintion.
+ */
+//! @{
+#define AVR32_BROADCAST_ADDR  ((unsigned int) (1 << 31))  //* Broadcat address detected
+#define AVR32_MULTICAST_HASH  ((unsigned int) (1 << 30))  //* MultiCast hash match
+#define AVR32_UNICAST_HASH    ((unsigned int) (1 << 29))  //* UniCast hash match
+#define AVR32_EXTERNAL_ADDR   ((unsigned int) (1 << 28))  //* External Address match
+#define AVR32_SA1_ADDR        ((unsigned int) (1 << 26))  //* Specific address 1 match
+#define AVR32_SA2_ADDR        ((unsigned int) (1 << 25))  //* Specific address 2 match
+#define AVR32_SA3_ADDR        ((unsigned int) (1 << 24))  //* Specific address 3 match
+#define AVR32_SA4_ADDR        ((unsigned int) (1 << 23))  //* Specific address 4 match
+#define AVR32_TYPE_ID         ((unsigned int) (1 << 22))  //* Type ID match
+#define AVR32_VLAN_TAG        ((unsigned int) (1 << 21))  //* VLAN tag detected
+#define AVR32_PRIORITY_TAG    ((unsigned int) (1 << 20))  //* PRIORITY tag detected
+#define AVR32_VLAN_PRIORITY   ((unsigned int) (7 << 17))  //* PRIORITY Mask
+#define AVR32_CFI_IND         ((unsigned int) (1 << 16))  //* CFI indicator
+#define AVR32_EOF             ((unsigned int) (1 << 15))  //* EOF
+#define AVR32_SOF             ((unsigned int) (1 << 14))  //* SOF
+#define AVR32_RBF_OFFSET      ((unsigned int) (3 << 12))  //* Receive Buffer Offset Mask
+#define AVR32_LENGTH_FRAME    ((unsigned int) 0x0FFF)     //* Length of frame
+//! @}
+
+/* Transmit Status definition */
+//! @{
+#define AVR32_TRANSMIT_OK     ((unsigned int) (1 << 31))  //*
+#define AVR32_TRANSMIT_WRAP   ((unsigned int) (1 << 30))  //* Wrap bit: mark the last descriptor
+#define AVR32_TRANSMIT_ERR    ((unsigned int) (1 << 29))  //* RLE:transmit error
+#define AVR32_TRANSMIT_UND    ((unsigned int) (1 << 28))  //* Transmit Underrun
+#define AVR32_BUF_EX          ((unsigned int) (1 << 27))  //* Buffers exhausted in mid frame
+#define AVR32_TRANSMIT_NO_CRC ((unsigned int) (1 << 16))  //* No CRC will be appended to the current frame
+#define AVR32_LAST_BUFFER     ((unsigned int) (1 << 15))  //*
+//! @}
+
+
+/**
+ * \brief Initialise the MACB driver.
+ *
+ * \param *macb Base address of the MACB
+ *
+ * \return TRUE if success, FALSE otherwise.
+ */
+extern Bool xMACBInit(volatile avr32_macb_t *macb);
+
+/**
+ * \brief Send ulLength bytes from pcFrom. This copies the buffer to one of the
+ * MACB Tx buffers, then indicates to the MACB that the buffer is ready.
+ * If lEndOfFrame is true then the data being copied is the end of the frame
+ * and the frame can be transmitted.
+ *
+ * \param *macb        Base address of the MACB
+ * \param *pvFrom      Address of the data buffer
+ * \param ulLength     Length of the frame
+ * \param lEndOfFrame  Flag for End Of Frame
+ *
+ * \return length sent.
+ */
+extern long lMACBSend(volatile avr32_macb_t *macb, const void *pvFrom, unsigned long ulLength, long lEndOfFrame);
+
+/**
+ * \brief Frames can be read from the MACB in multiple sections.
+ * Read ulSectionLength bytes from the MACB receive buffers to pcTo.
+ * ulTotalFrameLength is the size of the entire frame.  Generally vMACBRead
+ * will be repetedly called until the sum of all the ulSectionLenths totals
+ * the value of ulTotalFrameLength.
+ *
+ * \param *pvTo               Address of the buffer
+ * \param ulSectionLength     Length of the buffer
+ * \param ulTotalFrameLength  Length of the frame
+ */
+extern void vMACBRead(void *pvTo, unsigned long ulSectionLength, unsigned long ulTotalFrameLength);
+
+/**
+ * \brief Flush the current received packet.
+ *
+ * \param ulTotalFrameLength  Length of the packet to flush
+ */
+extern void vMACBFlushCurrentPacket(unsigned long ulTotalFrameLength);
+
+/**
+ * \brief Called by the Tx interrupt, this function traverses the buffers used to
+ * hold the frame that has just completed transmission and marks each as
+ * free again.
+ */
+extern void vClearMACBTxBuffer(void);
+
+/**
+ * \brief Suspend on a semaphore waiting either for the semaphore to be obtained
+ * or a timeout.  The semaphore is used by the MACB ISR to indicate that
+ * data has been received and is ready for processing.
+ *
+ * \param ulTimeOut    time to wait for an input
+ *
+ */
+extern void vMACBWaitForInput(unsigned long ulTimeOut);
+
+/**
+ * \brief Function to get length of the next frame in the receive buffers
+ *
+ * \return the length of the next frame in the receive buffers.
+ */
+extern unsigned long ulMACBInputLength(void);
+
+/**
+ * \brief Set the MACB Physical address (SA1B & SA1T registers).
+ *
+ * \param *MACAddress the MAC address to set.
+ */
+extern void vMACBSetMACAddress(const unsigned char *MACAddress);
+
+/**
+ * \brief Disable MACB operations (Tx and Rx).
+ *
+ * \param *macb        Base address of the MACB
+ */
+extern void vDisableMACBOperations(volatile avr32_macb_t *macb);
+
+
+#endif

src/platform/avr32/platform.c

@@ -15,6 +15,17 @@
 #include "platform_conf.h"
 #include "common.h"
 #include "buf.h"
+#include "spi.h"
+#ifdef BUILD_MMCFS
+#include "diskio.h"
+#endif
+
+#ifdef  BUILD_UIP
+#include "ethernet.h"
+#include "uip_arp.h"
+#include "elua_uip.h"
+#include "uip-conf.h"
+#endif
 
 // Platform-specific includes
 #include <avr32/io.h>
@@ -30,8 +41,21 @@
 #include "adc.h"
 #include "pwm.h"
 
+// UIP sys tick data
+// NOTE: when using virtual timers, SYSTICKHZ and VTMR_FREQ_HZ should have the
+// same value, as they're served by the same timer (the systick)
+#define SYSTICKHZ               4
+#define SYSTICKMS               (1000 / SYSTICKHZ)
+
+#ifdef BUILD_UIP
+static int eth_timer_fired;
+#endif
+
 // ****************************************************************************
 // Platform initialization
+#ifdef BUILD_UIP
+u32  platform_ethernet_setup(void);
+#endif
 
 extern int pm_configure_clocks( pm_freq_param_t *param );
 
@@ -51,6 +75,19 @@ __attribute__((__interrupt__)) static void tmr_int_handler()
 
   tc_read_sr( tc, VTMR_CH );
   cmn_virtual_timer_cb();
+
+#ifdef BUILD_MMCFS
+  disk_timerproc();
+#endif
+
+#ifdef BUILD_UIP
+  // Indicate that a SysTick interrupt has occurred.
+  eth_timer_fired = 1;
+
+  // Generate a fake Ethernet interrupt.  This will perform the actual work
+  // of incrementing the timers and taking the appropriate actions.
+  platform_eth_force_interrupt();
+#endif
 }                                
 #endif
 
@@ -188,6 +225,11 @@ int platform_init()
   pwm_init();
 #endif
 
+
+#ifdef BUILD_UIP
+    platform_ethernet_setup();
+#endif
+
 #ifdef ELUA_BOARD_MIZAR32
   // If BUF_ENABLE_UART is enabled on Mizar32 (which it is by default) but the
   // serial board is not plugged in, we get an infinite number of interrupts
@@ -814,7 +856,6 @@ int platform_adc_start_sequence( )
 
 #endif
 
-
 // ****************************************************************************
 // PWM functions
 
@@ -964,3 +1005,87 @@ u32 platform_pwm_op( unsigned id, int op, u32 data)
   }
   return 0;
 }
+
+// ****************************************************************************
+// Network support
+
+#ifdef BUILD_UIP
+static const gpio_map_t MACB_GPIO_MAP =
+{
+  {AVR32_MACB_MDC_0_PIN,    AVR32_MACB_MDC_0_FUNCTION   },
+  {AVR32_MACB_MDIO_0_PIN,   AVR32_MACB_MDIO_0_FUNCTION  },
+  {AVR32_MACB_RXD_0_PIN,    AVR32_MACB_RXD_0_FUNCTION   },
+  {AVR32_MACB_TXD_0_PIN,    AVR32_MACB_TXD_0_FUNCTION   },
+  {AVR32_MACB_RXD_1_PIN,    AVR32_MACB_RXD_1_FUNCTION   },
+  {AVR32_MACB_TXD_1_PIN,    AVR32_MACB_TXD_1_FUNCTION   },
+  {AVR32_MACB_TX_EN_0_PIN,  AVR32_MACB_TX_EN_0_FUNCTION },
+  {AVR32_MACB_RX_ER_0_PIN,  AVR32_MACB_RX_ER_0_FUNCTION },
+  {AVR32_MACB_RX_DV_0_PIN,  AVR32_MACB_RX_DV_0_FUNCTION },
+  {AVR32_MACB_TX_CLK_0_PIN, AVR32_MACB_TX_CLK_0_FUNCTION}
+};
+
+u32  platform_ethernet_setup()
+{
+	  static struct uip_eth_addr sTempAddr;
+	  // Assign GPIO to MACB
+	  gpio_enable_module(MACB_GPIO_MAP, sizeof(MACB_GPIO_MAP) / sizeof(MACB_GPIO_MAP[0]));
+
+	  // initialize MACB & Phy Layers
+	  if (xMACBInit(&AVR32_MACB) == FALSE ) {
+		  return PLATFORM_ERR;
+	  }
+
+	  sTempAddr.addr[0] = ETHERNET_CONF_ETHADDR0;
+	  sTempAddr.addr[1] = ETHERNET_CONF_ETHADDR1;
+	  sTempAddr.addr[2] = ETHERNET_CONF_ETHADDR2;
+	  sTempAddr.addr[3] = ETHERNET_CONF_ETHADDR3;
+	  sTempAddr.addr[4] = ETHERNET_CONF_ETHADDR4;
+	  sTempAddr.addr[5] = ETHERNET_CONF_ETHADDR5;
+
+	  // Initialize the eLua uIP layer
+   elua_uip_init( &sTempAddr );
+   return PLATFORM_OK;
+}  
+
+void platform_eth_send_packet( const void* src, u32 size )
+{
+   lMACBSend(&AVR32_MACB,src, size, TRUE);
+}
+
+u32 platform_eth_get_packet_nb( void* buf, u32 maxlen )
+{
+	u32    len;
+
+    /* Obtain the size of the packet. */
+    len = ulMACBInputLength();
+
+    if (len > maxlen) {
+    	return 0;
+    }
+
+    if( len ) {
+        /* Let the driver know we are going to read a new packet. */
+    	vMACBRead( NULL, 0, len );
+    	vMACBRead( buf, len, len );
+    }
+
+ return len;
+}
+
+void platform_eth_force_interrupt()
+{
+    elua_uip_mainloop();
+}
+
+u32 platform_eth_get_elapsed_time()
+{
+    if( eth_timer_fired )
+    {
+      eth_timer_fired = 0;
+      return SYSTICKMS;
+    }
+    else
+      return 0;
+}
+
+#endif

src/platform/avr32/uip-conf.h

@@ -0,0 +1,137 @@
+//*****************************************************************************
+//
+// uip-conf.h - uIP Project Specific Configuration File
+//
+//*****************************************************************************
+
+#ifndef __UIP_AVR32_CONF_H__
+#define __UIP_AVR32_CONF_H__
+
+#include "platform_conf.h"
+
+//
+// 8 bit datatype
+// This typedef defines the 8-bit type used throughout uIP.
+//
+typedef unsigned char u8_t;
+
+//
+// 16 bit datatype
+// This typedef defines the 16-bit type used throughout uIP.
+//
+typedef unsigned short u16_t;
+
+//
+// Statistics datatype
+// This typedef defines the dataype used for keeping statistics in
+// uIP.
+//
+typedef unsigned short uip_stats_t;
+
+//
+// Ping IP address assignment
+// Use first incoming "ping" packet to derive host IP address
+//
+#define UIP_CONF_PINGADDRCONF       0
+
+// 
+// TCP support on or off
+//
+#define UIP_CONF_TCP                1
+
+//
+// UDP support on or off
+//
+#define UIP_CONF_UDP                1
+
+//
+// UDP checksums on or off
+// (not currently supported ... should be 0)
+//
+#define UIP_CONF_UDP_CHECKSUMS      1
+
+//
+// UDP Maximum Connections
+//
+#define UIP_CONF_UDP_CONNS          4
+
+//
+// Maximum number of TCP connections.
+//
+#define UIP_CONF_MAX_CONNECTIONS    4
+
+//
+// Maximum number of listening TCP ports.
+//
+#define UIP_CONF_MAX_LISTENPORTS    4
+
+//
+// Size of advertised receiver's window
+//
+//#define UIP_CONF_RECEIVE_WINDOW     400
+
+//
+// Size of ARP table
+//
+#define UIP_CONF_ARPTAB_SIZE        4
+
+//
+// uIP buffer size.
+//
+#define UIP_CONF_BUFFER_SIZE        1024
+
+//
+// uIP statistics on or off
+//
+#define UIP_CONF_STATISTICS         0
+
+//
+// Logging on or off
+//
+#define UIP_CONF_LOGGING            0
+
+//
+// Broadcast Support
+//
+#define UIP_CONF_BROADCAST          1
+
+//
+// Link-Level Header length
+//
+#define UIP_CONF_LLH_LEN            14
+
+//
+// CPU byte order.
+//
+#define UIP_CONF_BYTE_ORDER         UIP_BIG_ENDIAN
+
+//
+// Here we include the header file for the application we are using in
+// this example
+#include "elua_uip.h"
+#include "dhcpc.h"
+
+//
+// Define the uIP Application State type (both TCP and UDP)
+//
+typedef struct elua_uip_state uip_tcp_appstate_t;
+typedef struct dhcpc_state uip_udp_appstate_t;
+
+//
+// UIP_APPCALL: the name of the application function. This function
+// must return void and take no arguments (i.e., C type "void
+// appfunc(void)").
+//
+#ifndef UIP_APPCALL
+#define UIP_APPCALL                 elua_uip_appcall
+#endif
+
+#ifndef UIP_ADP_APPCALL
+#define UIP_UDP_APPCALL             elua_uip_udp_appcall
+#endif
+
+// Added for eLua: DHCP TIMER ID
+#define ELUA_DHCP_TIMER_ID          1
+#define CLOCK_SECOND                1000000UL
+
+#endif // __UIP_CONF_H_

src/platform/lpc17xx/platform_conf.h

@@ -16,7 +16,7 @@
 #define BUILD_CON_GENERIC
 #define BUILD_ADC
 #define BUILD_SEMIFS
-#define BUILD_LUARPC
+#define BUILD_RPC
 
 // *****************************************************************************
 // UART/Timer IDs configuration data (used in main.c)
@@ -36,6 +36,13 @@
 #define ADCLINE
 #endif
 
+// RPC
+#if defined( BUILD_RPC ) 
+#define RPCLINE _ROM( AUXLIB_RPC, luaopen_rpc, rpc_map )
+#else
+#define RPCLINE
+#endif
+
 // The name of the platform specific libs table
 #define PS_LIB_TABLE_NAME   "mbed"
 
@@ -50,6 +57,7 @@
   _ROM( AUXLIB_BIT, luaopen_bit, bit_map )\
   _ROM( AUXLIB_CPU, luaopen_cpu, cpu_map )\
   _ROM( AUXLIB_PWM, luaopen_pwm, pwm_map )\
+  RPCLINE\
   _ROM( LUA_MATHLIBNAME, luaopen_math, math_map )\
   _ROM( AUXLIB_ELUA, luaopen_elua, elua_map )\
   _ROM( PS_LIB_TABLE_NAME, luaopen_platform, platform_map )

src/platform/str9/91x_ssp.c

@@ -0,0 +1,466 @@
+/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
+* File Name          : 91x_ssp.c
+* Author             : MCD Application Team
+* Version            : V2.1
+* Date               : 12/22/2008
+* Description        : This file provides all the SSP firmware functions.
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+
+/* Includes ------------------------------------------------------------------*/
+#include "91x_ssp.h"
+#include "91x_scu.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+
+/* SSP peripheral Enable */
+#define SSP_Enable   0x0002
+#define SSP_Disable  0xFFFD
+
+/* SSP Loop Back Mode Enable */
+#define SSP_LoopBackMode_Enable   0x0001
+#define SSP_LoopBackMode_Disable  0xFFFE
+
+/* SSP Flag Mask */
+#define SSP_Flag_Mask  0x001F
+
+/* SSP DMA transmit/ receive enable/disable Masks */
+#define SSP_DMA_TransmitEnable   0x0002
+#define SSP_DMA_TransmitDisable  0xFFFD
+#define SSP_DMA_ReceiveEnable    0x0001
+#define SSP_DMA_ReceiveDisable   0xFFFE
+
+/* SSP Masks */
+#define SSP_FrameFormat_Mask     0xFFCF
+#define SSP_DataSize_Mask        0xFFF0
+#define SSP_ClockRate_Mask       0x00FF
+#define SSP_ClockPrescaler_Mask  0xFF00
+
+/* Private function prototypes -----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+
+/*******************************************************************************
+* Function Name  : SSP_DeInit
+* Description    : Deinitializes the SSPx peripheral registers to their default
+*                  reset values.
+* Input          : SSPx: where x can be 0 or 1 to select the SSP peripheral.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_DeInit(SSP_TypeDef* SSPx)
+{
+  if(SSPx == SSP0)
+  {
+    /* Reset the SSP0 registers values*/
+    SCU_APBPeriphReset(__SSP0,ENABLE);
+    SCU_APBPeriphReset(__SSP0,DISABLE);
+  }
+  else if (SSPx == SSP1)
+  {
+    /* Reset the SSP1 registers values*/
+    SCU_APBPeriphReset(__SSP1,ENABLE);
+    SCU_APBPeriphReset(__SSP1,DISABLE);
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_Init
+* Description    : Initializes the SSPx  peripheral according to the specified
+*                  parameters in the SSP_InitTypeDef structure.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_InitStruct: pointer to a SSP_InitTypeDef structure that
+*                    contains the configuration information for the specified SSP
+*                    peripheral.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_Init(SSP_TypeDef* SSPx, SSP_InitTypeDef* SSP_InitStruct)
+{
+  if(SSP_InitStruct->SSP_FrameFormat == SSP_FrameFormat_Motorola)
+  {
+    /* Set the Motorola frame format */
+    SSPx->CR0 &= SSP_FrameFormat_Motorola;
+    /* Configure the Clock polarity */
+    if(SSP_InitStruct->SSP_CPOL == SSP_CPOL_High)
+    {
+      /* SCK is held high when no data is being transfered */
+      SSPx->CR0 |= SSP_CPOL_High;
+    }
+    else
+    {
+      /* SCK is held low when no data is being transfered */
+      SSPx->CR0 &= SSP_CPOL_Low;
+    }
+    /* Configure the Clock Phase */
+    if(SSP_InitStruct->SSP_CPHA == SSP_CPHA_2Edge)
+    {
+      /* Data captured on second clock edge */
+      SSPx->CR0 |= SSP_CPHA_2Edge;
+    }
+    else
+    {
+      /* Data captured on first clock edge */
+      SSPx->CR0 &= SSP_CPHA_1Edge;
+    }
+  }
+   /* Configure the Frame format */
+  else
+  {
+    /* Clear the FRF[1:0] bits */
+    SSPx->CR0 &= SSP_FrameFormat_Mask;
+    /* Set the TI frame format */
+    SSPx->CR0 |= SSP_InitStruct->SSP_FrameFormat;
+  }
+  /* Configure the Mode */
+  if(SSP_InitStruct->SSP_Mode == SSP_Mode_Slave)
+  {
+    /* Set the slave mode */
+    SSPx->CR1 |= SSP_Mode_Slave;
+    /* Configure the Slave output */
+    if(SSP_InitStruct->SSP_SlaveOutput == SSP_SlaveOutput_Disable)
+    {
+      /* Slave output disabled */
+      SSPx->CR1 |= SSP_SlaveOutput_Disable;
+    }
+    else
+    {
+      /* Slave output enabled */
+      SSPx->CR1 &= SSP_SlaveOutput_Enable;
+    }
+  }
+  else
+  {
+    /* Set the master mode */
+    SSPx->CR1 &= SSP_Mode_Master;
+    /* Clear clock rate SCR[7:0] bits */
+    SSPx->CR0 &= SSP_ClockRate_Mask;
+    /* Set the serial clock rate */
+    SSPx->CR0 |= (SSP_InitStruct->SSP_ClockRate<<8);
+    /* Clear clock prescaler CPSDVSR[7:0] bits */
+    SSPx->PR &= SSP_ClockPrescaler_Mask;
+    /* Set the serial clock prescaler */
+    SSPx->PR |= SSP_InitStruct->SSP_ClockPrescaler;
+  }
+
+  /* Clear data size DSS[3:0] bits */
+  SSPx->CR0 &= SSP_DataSize_Mask;
+  /* Set the data size */
+  SSPx->CR0 |= SSP_InitStruct->SSP_DataSize;
+}
+/*******************************************************************************
+* Function Name  : SSP_StructInit
+* Description    : Fills in a SSP_InitTypeDef structure with the reset value of
+*                  each parameter.
+* Input          : SSP_InitStruct : pointer to a SSP_InitTypeDef structure
+                   which will be initialized.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_StructInit(SSP_InitTypeDef* SSP_InitStruct)
+{
+  /* Initialize the SSP_FrameFormat member */
+  SSP_InitStruct->SSP_FrameFormat = SSP_FrameFormat_Motorola;
+
+  /* Initialize the SSP_Mode member */
+  SSP_InitStruct->SSP_Mode = SSP_Mode_Master;
+
+  /* Initialize the SSP_CPOL member */
+  SSP_InitStruct->SSP_CPOL = SSP_CPOL_Low;
+
+  /* Initialize the SSP_CPHA member */
+  SSP_InitStruct->SSP_CPHA = SSP_CPHA_1Edge;
+
+  /* Initialize the SSP_DataSize member */
+  SSP_InitStruct->SSP_DataSize = SSP_DataSize_8b;
+
+  /* Initialize the SSP_SlaveOutput member */
+  SSP_InitStruct->SSP_SlaveOutput = SSP_SlaveOutput_Enable;
+
+  /* Initialize the SSP_ClockRate member */
+  SSP_InitStruct->SSP_ClockRate = 0;
+
+  /* Initialize the SSP_ClockPrescaler member */
+  SSP_InitStruct->SSP_ClockPrescaler = 0;
+}
+
+/*******************************************************************************
+* Function Name  : SSP_Cmd
+* Description    : Enables or disables the specified SSP peripheral.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - NewState: new state of the  SSPx peripheral. This parameter
+*                    can be: ENABLE or DISABLE.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_Cmd(SSP_TypeDef* SSPx, FunctionalState NewState)
+{
+  if(NewState == ENABLE)
+  {
+    /* Enable the SSP peripheral */
+    SSPx->CR1 |= SSP_Enable;
+  }
+  else
+  {
+    /* Disable the SSP peripheral */
+    SSPx->CR1 &= SSP_Disable;
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_ITConfig
+* Description    : Enables or disables the specified SSP interrupts.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_IT: specifies the SSP interrupts sources to be enabled
+*                    or disabled. This parameter can be any combination of the
+*                    following values:
+*                         - SSP_IT_TxFifo: Transmit FIFO half empty or less interrupt
+*                         - SSP_IT_RxFifo: Receive FIFO half full or less interrupt
+*                         - SSP_IT_RxTimeOut: Receive timeout interrupt
+*                         - SSP_IT_RxOverrun: Receive overrun interrupt
+*                  - NewState: new state of the specified SSP interrupts.
+*                    This parameter can be: ENABLE or DISABLE.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_ITConfig(SSP_TypeDef* SSPx, u16 SSP_IT, FunctionalState NewState)
+{
+  if(NewState == ENABLE)
+  {
+    /* Enable the selected SSP interrupts */
+    SSPx->IMSCR |= SSP_IT;
+  }
+  else
+  {
+    /* Disable the selected SSP interrupts */
+    SSPx->IMSCR &= ~SSP_IT;
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_DMACmd
+* Description    : Configures the SSP0 DMA interface.
+* Input          :  - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                   - SSP_DMATransfert : specifies the DMA transfert to be
+*                    enabled or disabled. This parameter can be one of the
+*                    following values:
+*                         - SSP_DMA_Transmit: transmit Fifo DMA transfert
+*                         - SSP_DMA_Receive : receive Fifo DMA transfert
+*                  - NewState: new state of the DMA transfert.
+*                    This parameter can be: ENABLE or DISABLE.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_DMACmd(SSP_TypeDef* SSPx, u16 SSP_DMATransfert, FunctionalState NewState)
+{
+  if(NewState == ENABLE)
+  {
+    if(SSP_DMATransfert == SSP_DMA_Transmit)
+    {
+      /* Enable DMA for the transmit FIFO */
+      SSPx->DMACR |= SSP_DMA_TransmitEnable;
+    }
+    else
+    {
+      /* Enable DMA for the receive FIFO */
+      SSPx->DMACR |= SSP_DMA_ReceiveEnable;
+    }
+  }
+  else
+  {
+    if(SSP_DMATransfert == SSP_DMA_Transmit)
+    {
+      /* Disable DMA for the transmit FIFO */
+      SSPx->DMACR &= SSP_DMA_TransmitDisable;
+    }
+    else
+    {
+      /* Disable DMA for the receive FIFO */
+      SSPx->DMACR &= SSP_DMA_ReceiveDisable;
+    }
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_SendData.
+* Description    : Transmits a Data through the SSP peripheral.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - Data : Data to be transmitted.
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_SendData(SSP_TypeDef* SSPx, u16 Data)
+{
+  /* Write in the DR register the data to be sent */
+  SSPx->DR = Data;
+}
+
+/*******************************************************************************
+* Function Name  : SSP_ReceiveData.
+* Description    : Returns the most recent received data by the SSP peripheral.
+* Input          : SSPx: where x can be 0 or 1 to select the SSP peripheral.
+* Output         : None
+* Return         : The value of the received data.
+*******************************************************************************/
+u16 SSP_ReceiveData(SSP_TypeDef* SSPx)
+{
+  /* Return the data in the DR register */	
+  return SSPx->DR;
+}
+
+/*******************************************************************************
+* Function Name  : SSP_LoopBackConfig
+* Description    : Enable or disable the Loop back mode for the selected SSPx peripheral.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - NewState: new state of the Loop Back mode.
+*                    This parameter can be: ENABLE or DISABLE.
+* Output         : None
+* Return         : None.
+*******************************************************************************/
+void SSP_LoopBackConfig(SSP_TypeDef* SSPx, FunctionalState NewState)
+{
+  if(NewState == ENABLE)
+  {
+    /* Enable loop back mode */
+    SSPx->CR1 |= SSP_LoopBackMode_Enable;
+  }
+  else
+  {
+    /* Disable loop back mode */
+    SSPx->CR1 &= SSP_LoopBackMode_Disable;
+  }
+}
+
+
+
+/*******************************************************************************
+* Function Name  : SSP_GetFlagStatus
+* Description    : Checks whether the specified SSP flag is set or not.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_FLAG: flag to check. This parameter can be one of the
+*                    following values:
+*                         - SSP_FLAG_Busy: busy flag
+*                         - SSP_FLAG_RxFifoFull: Receive FIFO full flag
+*                         - SSP_FLAG_RxFifoNotEmpty: Receive FIFO not empty flag
+*                         - SSP_FLAG_TxFifoNotFull: Transmit FIFO not full flag
+*                         - SSP_FLAG_TxFifoEmpty: Transmit FIFO empty flag
+*                         - SSP_FLAG_TxFifo: Transmit FIFO half empty or less flag
+*                         - SSP_FLAG_RxFifo: Receive FIFO half full or less flag
+*                         - SSP_FLAG_RxTimeOut: Receive timeout flag
+*                         - SSP_FLAG_RxOverrun: Receive overrun flag
+* Output         : None
+* Return         : The new state of SSP_Flag (SET or RESET).
+*******************************************************************************/
+FlagStatus SSP_GetFlagStatus(SSP_TypeDef* SSPx, u16 SSP_FLAG)
+{
+    u32 SSPReg = 0, FlagPos = 0;
+    u32 StatusReg = 0;
+
+  /* Get the SSP register index */
+  SSPReg = SSP_FLAG >> 5;
+
+  /* Get the flag position */
+  FlagPos = SSP_FLAG & SSP_Flag_Mask;
+
+  /* Find the register of the flag to check */
+  if(SSPReg == 1)
+  {
+    /* The flag to check is in SR register */
+    StatusReg = SSPx->SR;  	
+  }
+  else if (SSPReg == 2)
+  {
+    /* The flag to check is in RISR register */
+    StatusReg = SSPx->RISR;
+  }
+
+  /* Check the status of the specified SSP flag */
+  if((StatusReg & (1 << FlagPos)) != RESET)
+  {
+    /* Return SET if the SSP flag is set */
+    return SET;
+  }
+  else
+  {
+    /* Return RESET if the SSP flag is reset */
+    return RESET;
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_ClearFlag
+* Description    : Clears the SSPx flags.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_FLAG: flags to clear. This parameter one of the
+*                    following values:
+*                         - SSP_FLAG_RxTimeOut: Receive timeout flag
+*                         - SSP_FLAG_RxOverrun: Receive overrun flag
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_ClearFlag(SSP_TypeDef* SSPx, u16 SSP_FLAG)
+{
+    u8 FlagPos = 0;
+
+  /* Get the flag position */
+  FlagPos = SSP_FLAG & SSP_Flag_Mask;
+
+  /* Clear the selected SSP flag */
+  SSPx->ICR = (1 << FlagPos);
+}
+
+/*******************************************************************************
+* Function Name  : SSP_GetITStatus
+* Description    : Checks whether the specified SSP interrupt flag is set or not.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_IT: interrupt flag to check. This parameter can be one
+*                    of the following values:
+*                         - SSP_IT_TxFifo: Transmit FIFO half empty or less interrupt
+*                         - SSP_IT_RxFifo: Receive FIFO half full or less interrupt
+*                         - SSP_IT_RxTimeOut: Receive timeout interrupt
+*                         - SSP_IT_RxOverrun: Receive overrun interrupt
+* Output         : None
+* Return         : The new state of SSP_IT flag (SET or RESET).
+*******************************************************************************/
+ITStatus SSP_GetITStatus(SSP_TypeDef* SSPx, u16 SSP_IT)
+{
+  /* Check the status of the specified interrupt flag */
+  if((SSPx->MISR & SSP_IT) != RESET)
+  {
+    /* Return SET if the SSP interrupt flag is set */
+    return SET;
+  }
+  else
+  {
+    /* Return RESET if SSP interrupt flag is reset */
+    return RESET;
+  }
+}
+
+/*******************************************************************************
+* Function Name  : SSP_ClearITPendingBit
+* Description    : Clears the pending interrupt flags.
+* Input          : - SSPx: where x can be 0 or 1 to select the SSP peripheral.
+*                  - SSP_IT: interrupts pending bits to clear. This parameter
+*                    can be any combination of the following values:
+*                         - SSP_IT_RxTimeOut: Receive timeout interrupt
+*                         - SSP_IT_RxOverrun: Receive overrun interrupt
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void SSP_ClearITPendingBit(SSP_TypeDef* SSPx, u16 SSP_IT)
+{
+  /* Clear the selected SSP interrupts pending bits */
+  SSPx->ICR = SSP_IT;
+}
+
+/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
+

src/platform/str9/91x_ssp.h

@@ -0,0 +1,116 @@
+/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
+* File Name          : 91x_ssp.h
+* Author             : MCD Application Team
+* Version            : V2.1
+* Date               : 12/22/2008
+* Description        : This file contains all the functions prototypes for the
+*                      SSP firmware library.
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __91x_SSP_H
+#define __91x_SSP_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "91x_map.h"
+
+/* Exported types ------------------------------------------------------------*/
+/* SSP Init structure definition */
+typedef struct
+{
+  u16 SSP_FrameFormat ;
+  u16 SSP_Mode ;	
+  u16 SSP_CPOL ;
+  u16 SSP_CPHA ;
+  u16 SSP_DataSize ;
+  u16 SSP_SlaveOutput ;	
+  u8 SSP_ClockRate ;
+  u8 SSP_ClockPrescaler ;
+}SSP_InitTypeDef;
+
+/* Exported constants --------------------------------------------------------*/
+/* SSP Frame Format Select */
+#define SSP_FrameFormat_TI         0x0010
+#define SSP_FrameFormat_Motorola   0xFFCF
+#define SSP_FrameFormat_Microwire  0x0020
+
+/* SSP Master/Slave Select */
+#define SSP_Mode_Master   0xFFFB
+#define SSP_Mode_Slave    0x0004
+
+/* SSP Clock Polarity */
+#define SSP_CPOL_Low    0xFFBF
+#define SSP_CPOL_High   0x0040
+
+/* SSP Clock Phase */
+#define SSP_CPHA_1Edge   0xFF7F
+#define SSP_CPHA_2Edge   0x0080
+
+/* SSP Data Size */
+#define SSP_DataSize_16b   0x000F
+#define SSP_DataSize_15b   0x000E
+#define SSP_DataSize_14b   0x000D
+#define SSP_DataSize_13b   0x000C
+#define SSP_DataSize_12b   0x000B
+#define SSP_DataSize_11b   0x000A
+#define SSP_DataSize_10b   0x0009
+#define SSP_DataSize_9b	   0x0008
+#define SSP_DataSize_8b	   0x0007
+#define SSP_DataSize_7b    0x0006
+#define SSP_DataSize_6b	   0x0005
+#define SSP_DataSize_5b    0x0004
+#define SSP_DataSize_4b	   0x0003
+
+/* SSP Slave output config */
+#define SSP_SlaveOutput_Enable   0xFFF7
+#define SSP_SlaveOutput_Disable  0x0008
+
+/* SSP Interrupts */
+#define SSP_IT_TxFifo	    0x0008
+#define SSP_IT_RxFifo	    0x0004
+#define SSP_IT_RxTimeOut    0x0002
+#define SSP_IT_RxOverrun    0x0001
+
+/* SSP Flags */
+#define SSP_FLAG_Busy	         0x0024
+#define SSP_FLAG_RxFifoFull	 0x0023
+#define SSP_FLAG_RxFifoNotEmpty	 0x0022
+#define SSP_FLAG_TxFifoNotFull	 0x0021
+#define SSP_FLAG_TxFifoEmpty	 0x0020
+#define SSP_FLAG_TxFifo	         0x0043
+#define SSP_FLAG_RxFifo	         0x0042
+#define SSP_FLAG_RxTimeOut	 0x0041
+#define SSP_FLAG_RxOverrun	 0x0040
+
+/* SSP DMA Requests */
+#define SSP_DMA_Transmit  0x0002
+#define SSP_DMA_Receive   0x0001
+
+/* Exported macro ------------------------------------------------------------*/
+/* Exported functions ------------------------------------------------------- */
+
+void SSP_DeInit(SSP_TypeDef* SSPx);
+void SSP_Init(SSP_TypeDef* SSPx, SSP_InitTypeDef* SSP_InitStruct);
+void SSP_StructInit(SSP_InitTypeDef* SSP_InitStruct);
+void SSP_Cmd(SSP_TypeDef* SSPx, FunctionalState NewState);
+void SSP_ITConfig(SSP_TypeDef* SSPx, u16 SSP_IT, FunctionalState NewState);
+void SSP_DMACmd(SSP_TypeDef* SSPx, u16 SSP_DMATransfert, FunctionalState NewState);
+void SSP_SendData(SSP_TypeDef* SSPx, u16 Data);
+u16 SSP_ReceiveData(SSP_TypeDef* SSPx);
+void SSP_LoopBackConfig(SSP_TypeDef* SSPx, FunctionalState NewState);
+FlagStatus SSP_GetFlagStatus(SSP_TypeDef* SSPx, u16 SSP_FLAG);
+void SSP_ClearFlag(SSP_TypeDef* SSPx, u16 SSP_FLAG);
+ITStatus SSP_GetITStatus(SSP_TypeDef* SSPx, u16 SSP_IT);
+void SSP_ClearITPendingBit(SSP_TypeDef* SSPx, u16 SSP_IT);
+
+#endif /* __91x_SSP_H */
+
+/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
+

src/platform/str9/conf.lua

@@ -2,7 +2,7 @@
 
 local cpumode = ( builder:get_option( 'cpumode' ) or 'arm' ):lower()
 
-specific_files = "startup912.s startup_generic.s platform.c 91x_scu.c 91x_fmi.c 91x_gpio.c 91x_uart.c 91x_tim.c 91x_vic.c interrupt.c str9_pio.c 91x_i2c.c 91x_wiu.c 91x_adc.c platform_int.c"
+specific_files = "startup912.s startup_generic.s platform.c 91x_scu.c 91x_fmi.c 91x_gpio.c 91x_uart.c 91x_tim.c 91x_vic.c interrupt.c str9_pio.c 91x_i2c.c 91x_wiu.c 91x_adc.c platform_int.c 91x_ssp.c"
 
 local ldscript = "str912fw44.lds"
 

src/platform/str9/conf.py

@@ -2,7 +2,7 @@
 
 cpumode = ARGUMENTS.get( 'cpumode', 'arm' ).lower()
 
-specific_files = "startup912.s startup_generic.s platform.c 91x_scu.c 91x_fmi.c 91x_gpio.c 91x_uart.c 91x_tim.c 91x_vic.c interrupt.c str9_pio.c 91x_i2c.c 91x_wiu.c 91x_adc.c platform_int.c"
+specific_files = "startup912.s startup_generic.s platform.c 91x_scu.c 91x_fmi.c 91x_gpio.c 91x_uart.c 91x_tim.c 91x_vic.c interrupt.c str9_pio.c 91x_i2c.c 91x_wiu.c 91x_adc.c platform_int.c 91x_ssp.c"
 
 # Check CPU
 if comp[ 'cpu' ] == 'STR912FAW44':

src/platform/str9/platform.c

@@ -24,6 +24,8 @@
 #include "buf.h"
 #include "elua_adc.h"
 #include "91x_adc.h"
+#include "91x_ssp.h"
+#include "utils.h"
 
 // ****************************************************************************
 // Platform initialization
@@ -51,6 +53,8 @@ static void platform_config_scu()
   SCU_PCLKDivisorConfig(SCU_PCLK_Div2);
   /* Set the HCLK Clock to MCLK */
   SCU_HCLKDivisorConfig(SCU_HCLK_Div1);
+  /* Set the BRCLK Clock to MCLK */
+  SCU_BRCLKDivisorConfig(SCU_BRCLK_Div1);
   
   // Enable VIC clock
   SCU_AHBPeriphClockConfig(__VIC, ENABLE);
@@ -80,6 +84,12 @@ static void platform_config_scu()
   
   // Enable the ADC clocks
   SCU_APBPeriphClockConfig(__ADC, ENABLE);
+
+  // Enable the SSP clocks
+  SCU_APBPeriphClockConfig(__SSP0,ENABLE);
+  SCU_APBPeriphReset(__SSP0,DISABLE);
+  SCU_APBPeriphClockConfig(__SSP1,ENABLE);
+  SCU_APBPeriphReset(__SSP1,DISABLE);
 }
 
 // Port/pin definitions of the eLua UART connection for different boards
@@ -142,12 +152,13 @@ int platform_init()
     TIM_CounterCmd( base, TIM_START );
   }
   
+ cmn_platform_init();
+
 #ifdef BUILD_ADC
   // Setup ADCs
   platform_setup_adcs();
 #endif
  
-  cmn_platform_init();
 #ifdef VTMR_TIMER_ID
   platform_s_timer_set_match_int( VTMR_TIMER_ID, 1000000 / VTMR_FREQ_HZ, PLATFORM_TIMER_INT_CYCLIC );
 #endif
@@ -785,6 +796,99 @@ int platform_i2c_recv_byte( unsigned id, int ack )
   return I2C_ReceiveData( pi2c );
 }
 
+// ****************************************************************************
+// SPI
+
+#define SPI_MAX_PRESCALER     ( 254 * 256 )
+#define SPI_MIN_PRESCALER     2
+
+u32 platform_spi_setup( unsigned id, int mode, u32 clock, unsigned cpol, unsigned cpha, unsigned databits )
+{
+  const u32 basefreq = CPU_FREQUENCY;
+  u32 prescaler, divider = 1, temp, mindiff = 0xFFFFFFFF, minp;
+  GPIO_InitTypeDef  GPIO_InitStructure;
+  SSP_InitTypeDef SSP_InitStructure;
+
+  clock = UMIN( clock, basefreq >> 1 );
+  prescaler = UMIN( basefreq / clock, SPI_MAX_PRESCALER );
+  if( basefreq / prescaler > clock )
+    prescaler ++;
+  if( prescaler & 1 )
+    prescaler ++;
+  if( prescaler > 254 )
+  {
+    temp = prescaler;
+    for( prescaler = minp = 2; prescaler <= 254; prescaler += 2 )
+    {
+      divider = temp / prescaler;
+      if( divider <= 255 )
+      {
+        if( ABSDIFF( divider * prescaler, temp ) < mindiff )
+        {
+          mindiff = ABSDIFF( divider * prescaler, temp );
+          minp = prescaler;
+          if( mindiff == 0 )
+            break;
+        }
+      }
+    }
+    prescaler = minp;
+    divider = temp / prescaler;
+  }
+
+  // GPIO setup
+  // Fixed assignment:
+  // P5.4 - SCLK
+  // P5.5 - MOSI
+  // P5.6 - MISO
+  // P5.7 - CS (not explicitly handled by the SPI module)
+  GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
+  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5;
+  GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
+  GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2  ;
+  GPIO_Init(GPIO5, &GPIO_InitStructure);
+  GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
+  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
+  GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
+  GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1  ;
+  GPIO_Init(GPIO5, &GPIO_InitStructure);
+
+  // Actual SPI setup
+  SSP_DeInit(SSP0);
+  SSP_InitStructure.SSP_FrameFormat = SSP_FrameFormat_Motorola;
+  SSP_InitStructure.SSP_Mode = SSP_Mode_Master;
+  SSP_InitStructure.SSP_CPOL = cpol == 0 ? SSP_CPOL_Low : SSP_CPOL_High;
+  SSP_InitStructure.SSP_CPHA = cpha == 0 ? SSP_CPHA_1Edge : SSP_CPHA_2Edge;
+  SSP_InitStructure.SSP_DataSize = databits - 1;
+  SSP_InitStructure.SSP_ClockRate = divider - 1;
+  SSP_InitStructure.SSP_ClockPrescaler = prescaler;
+  SSP_Init(SSP0, &SSP_InitStructure);
+
+  // Enable peripheral   
+  SSP_Cmd(SSP0, ENABLE);
+  
+  // All done
+  return basefreq / ( prescaler * divider );
+}
+
+spi_data_type platform_spi_send_recv( unsigned id, spi_data_type data )
+{
+  // Send byte through the SSP0 peripheral
+  SSP0->DR = data;
+  // Loop while Transmit FIFO is full
+  while(SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoEmpty) == RESET);
+  // Loop while Receive FIFO is empty
+  while(SSP_GetFlagStatus(SSP0, SSP_FLAG_RxFifoNotEmpty) == RESET); 
+  // Return the byte read from the SSP bus
+  return SSP0->DR;
+}
+
+void platform_spi_select( unsigned id, int is_select )
+{
+  id = id;
+  is_select = is_select;
+}
+
 // ****************************************************************************
 // Platform specific modules go here
 
@@ -811,7 +915,6 @@ LUALIB_API int luaopen_platform( lua_State *L )
   lua_newtable( L );
   luaL_register( L, NULL, str9_pio_map );
   lua_setfield( L, -2, "pio" );
-
   return 1;
 #endif // #if LUA_OPTIMIZE_MEMORY > 0
 }

src/platform/str9/platform_conf.h

@@ -46,7 +46,7 @@
 
 // Number of resources (0 if not available/not implemented)
 #define NUM_PIO               10
-#define NUM_SPI               0
+#define NUM_SPI               1
 #define NUM_UART              3
 #define NUM_PWM               4
 #define NUM_ADC               8
@@ -130,6 +130,8 @@ u32 SCU_GetMCLKFreqValue();
   _ROM( AUXLIB_CPU, luaopen_cpu, cpu_map)\
   _ROM( AUXLIB_CPU, luaopen_elua, elua_map)\
   _ROM( AUXLIB_I2C, luaopen_i2c, i2c_map)\
+  _ROM( AUXLIB_SPI, luaopen_spi, spi_map)\
+  _ROM( AUXLIB_ELUA, luaopen_elua, elua_map)\
   RPCLINE\
   _ROM( AUXLIB_PWM, luaopen_pwm, pwm_map)\
   _ROM( LUA_MATHLIBNAME, luaopen_math, math_map )\

src/platform/str9/startup912.s

@@ -135,8 +135,6 @@ DAbt_Handler:       B       DAbt_Handler
 IRQ_Handler:        B       ASM_IRQ_Handler       /* should never get here as IRQ is via VIC slot... */
 FIQ_Handler:        B       FIQ_Handler
 
-          .text
-
 # Generic IRQ handler
 ASM_IRQ_Handler:
             sub       lr, lr ,#4