Added support for solution level extensibility for communication transports via generic transport interfaces

- Added new GENERIC_TRANSPORT
- Added new case to all COM redirector APIs to support GENERIC_TRANSPORT handles redirecting to GenericPort_xxx APIS
- Added new GenericPort_xxx APIS to lookup an interface in a table based on the port number and then call through the interface 's function pointer. This allows extensibility without requiring the definition of new transport types.
- added Common CortexMx ITM trace port channel 0 Generic port implementation
- Added support for using ITM0 Generic port to MCBSTM32F400

Author: smaillet-ms

DeviceCode/Cores/arm/Processors/CortexMx/GlobalLock/dotNetMF.proj

@@ -2,10 +2,10 @@
     <PropertyGroup>
         <AssemblyName>GlobalLock_hal_Cortex</AssemblyName>
         <ProjectGuid>{A839EEC5-C737-48C5-958B-BBF12920AA41}</ProjectGuid>
-        <Description>Cortex-M3 Global lock</Description>
+        <Description>Cortex-Mx Global lock</Description>
         <Level>HAL</Level>
         <LibraryFile>GlobalLock_hal_Cortex.$(LIB_EXT)</LibraryFile>
-        <ProjectPath>$(SPOCLIENT)\DeviceCode\Cores\arm\Processors\CortexMx\dotNetMF.proj</ProjectPath>
+        <ProjectPath>$(SPOCLIENT)\DeviceCode\Cores\arm\Processors\CortexMx\GlobalLock\dotNetMF.proj</ProjectPath>
         <ManifestFile>GlobalLock_hal_Cortex.$(LIB_EXT).manifest</ManifestFile>
         <Documentation>
         </Documentation>

DeviceCode/Cores/arm/Processors/CortexMx/ItmPort/ItmPort.cpp

@@ -0,0 +1,49 @@
+#include <tinyhal.h>
+
+#include "cmsis_generic.h"
+
+// only one "generic" port supported for ITM tracing messages to hardware debugger
+// so pInstance is ignored
+static int ItmPort_Write( void* pInstance, const char* Data, size_t size )
+{
+    for( int i = 0; i< size; ++i )
+        ITM_SendChar( Data[i] );
+    
+    return size;
+}
+
+static IGenericPort const ItmPortItf =
+{
+    // default returns TRUE
+    NULL, //BOOL (*Initialize)( void* pInstance );
+    
+    // default returns TRUE
+    NULL, //BOOL (*Uninitialize)( void* pInstance );
+    
+    // default return 0
+    ItmPort_Write, //int (*Write)( void* pInstance, const char* Data, size_t size );
+    
+    // defualt return 0
+    NULL, //int (*Read)( void* pInstance, char* Data, size_t size );
+    
+    // default return TRUE
+    NULL, //BOOL (*Flush)( void* pInstance );
+    
+    // default do nothing
+    NULL, //void (*ProtectPins)( void* pInstance, BOOL On ); 
+    
+    // default return FALSE
+    NULL, //BOOL (*IsSslSupported)( void* pInstance );
+    
+    // default return FALSE
+    NULL, //BOOL (*UpgradeToSsl)( void* pInstance, const UINT8* pCACert, UINT32 caCertLen, const UINT8* pDeviceCert, UINT32 deviceCertLen, LPCSTR szTargetHost );
+    
+    // default return FALSE
+    NULL, //BOOL (*IsUsingSsl)( void* pInstance );
+};
+
+extern const GenericPortTableEntry Itm0GenericPort =
+{
+    ItmPortItf,
+    NULL
+};

DeviceCode/Cores/arm/Processors/CortexMx/ItmPort/dotNetMF.proj

@@ -0,0 +1,27 @@
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <AssemblyName>CortexMx_ItmPort</AssemblyName>
+        <ProjectGuid>{E30D2587-7481-4ECB-A961-16A8BA3DECB9}</ProjectGuid>
+        <Description>Cortex-Mx Generic ITM port</Description>
+        <Level>HAL</Level>
+        <LibraryFile>CortexMx_ItmPort.$(LIB_EXT)</LibraryFile>
+        <ProjectPath>$(SPOCLIENT)\DeviceCode\Cores\arm\Processors\CortexMx\ItmPort\dotNetMF.proj</ProjectPath>
+        <ManifestFile>CortexMx_ItmPort.$(LIB_EXT).manifest</ManifestFile>
+        <Documentation>
+        </Documentation>
+        <PlatformIndependent>False</PlatformIndependent>
+        <Required>False</Required>
+        <IgnoreDefaultLibPath>False</IgnoreDefaultLibPath>
+        <IsStub>False</IsStub>
+        <Directory>DeviceCode\Cores\arm\Processors\CortexMx</Directory>
+        <OutputType>Library</OutputType>
+        <PlatformIndependentBuild>false</PlatformIndependentBuild>
+        <Version>4.0.0.0</Version>
+    </PropertyGroup>
+    <Import Project="$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings" />
+    <PropertyGroup />
+    <ItemGroup>
+        <Compile Include="ItmPort.cpp" />
+    </ItemGroup>
+    <Import Project="$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Targets" />
+</Project>

DeviceCode/Targets/Native/STM32F4/processor_selector.h

@@ -22,7 +22,7 @@
 #elif defined(PLATFORM_ARM_STM32F4)
 #define STM32F4XX
 #else
-ERROR - WE SHOULD NOT INCLUDE THIS HEADER IF NOT BUILDING A STM32F2/F4 PLATFORM
+ERROR - WE SHOULD NOT INCLUDE THIS HEADER IF NOT BUILDING AN STM32F2/F4 PLATFORM
 #endif
 
 /////////////////////////////////////////////////////////
@@ -61,9 +61,11 @@ ERROR - WE SHOULD NOT INCLUDE THIS HEADER IF NOT BUILDING A STM32F2/F4 PLATFORM
 //
 
 // Port definitions
-#define ITM_VIRTUAL_COMPORTNUM 0
+#ifndef ITM_GENERIC_PORTNUM
+#define ITM_GENERIC_PORTNUM 0
+#endif
 
-#define ITM0                   ConvertCOM_ComHandle( ITM_VIRTUAL_COMPORTNUM ) 
+#define ITM0                   ConvertCOM_GenericHandle( ITM_GENERIC_PORTNUM ) 
 #define COM1                   ConvertCOM_ComHandle(1)
 #define COM2                   ConvertCOM_ComHandle(2)
 #define COM3                   ConvertCOM_ComHandle(3)

DeviceCode/include/COM_decl.h

@@ -5,7 +5,70 @@
 #ifndef _DRIVERS_COM_DIRECTOR_DECL_H_
 #define _DRIVERS_COM_DIRECTOR_DECL_H_ 1
 
-//--//
+// The functionality of Generic ports is triggered by
+// defining TOTAL_GENERIC_PORTS to a value > 0 in the
+// solution's platform_selector.h header file
+// Otherwise, the implementation of these functions is
+// just a stub that returns values indicating failure
+// as they should never be called.
+
+BOOL GenericPort_Initialize( int portNum );
+BOOL GenericPort_Uninitialize( int portNum );
+int GenericPort_Write( int portNum, const char* Data, size_t size );
+int GenericPort_Read( int portNum, char* Data, size_t size );
+BOOL GenericPort_Flush( int portNum );
+void GenericPort_ProtectPins( int portNum, BOOL On ); 
+BOOL GenericPort_IsSslSupported( int portNum );
+BOOL GenericPort_UpgradeToSsl( int portNum, const UINT8* pCACert, UINT32 caCertLen, const UINT8* pDeviceCert, UINT32 deviceCertLen, LPCSTR szTargetHost );
+BOOL GenericPort_IsUsingSsl( int portNum );
+
+// interface table for a generic port 
+// any NULL entries in the table indicates default handling is desired
+struct IGenericPort 
+{
+    // default returns TRUE
+    BOOL (*Initialize)( void* pInstance );
+    
+    // default returns TRUE
+    BOOL (*Uninitialize)( void* pInstance );
+    
+    // default return 0
+    int (*Write)( void* pInstance, const char* Data, size_t size );
+    
+    // defualt return 0
+    int (*Read)( void* pInstance, char* Data, size_t size );
+    
+    // default return TRUE
+    BOOL (*Flush)( void* pInstance );
+    
+    // default do nothing
+    void (*ProtectPins)( void* pInstance, BOOL On ); 
+    
+    // default return FALSE
+    BOOL (*IsSslSupported)( void* pInstance );
+    
+    // default return FALSE
+    BOOL (*UpgradeToSsl)( void* pInstance, const UINT8* pCACert, UINT32 caCertLen, const UINT8* pDeviceCert, UINT32 deviceCertLen, LPCSTR szTargetHost );
+    
+    // default return FALSE
+    BOOL (*IsUsingSsl)( void* pInstance );
+};
+
+struct GenericPortTableEntry
+{
+    IGenericPort const& Port;
+    void* pInstance;
+};
+
+#if TOTAL_GENERIC_PORTS > 0
+// ConvertCOM_GenericPort( ComPortHandle ) produces an index into this table
+// This table is provided by the solution to allow customization and extensibility
+// at the solution level. Individual port "drivers" can provide a common
+// GenericPortTableEntry structure implementation yet still remain independent of 
+// the actual solution since the solution owns the table, and ordering and thus the
+// handle definitions as well. 
+extern GenericPortTableEntry const* const g_GenericPorts[ TOTAL_GENERIC_PORTS ];
+#endif
 
 extern INT32 g_DebuggerPort_SslCtx_Handle;
 

DeviceCode/include/tinyhal.h

@@ -183,11 +183,11 @@ struct GPIO_FLAG
 #define STANDARD_USART_MIN_BAUDRATE  75
 #define STANDARD_USART_MAX_BAUDRATE  2304000
 
-// Defines a type representing both a port type or "transport" and a port number
+// COM_HANDLE Defines a type representing both a port type or "transport" and a port number
 // The COM_HANDLE is a multi bit field value with the following bit fields usage
 //    |--------+--------+--------+--------|
 //    |33222222|22221111|111111  |        |
-//    |10987654|32109876|54321098|76543210|
+//    |10987654|32109876|54321098|76543210| bit position
 //    |--------+--------+--------+--------|
 //    |00000000|00000000|TTTTTTTT|pppppppp| ( transport != USB_TRANSPORT )
 //    |--------+--------+--------+--------|
@@ -203,12 +203,20 @@ struct GPIO_FLAG
 //                LCD_TRANSPORT => 5
 //        FLASH_WRITE_TRANSPORT => 6
 //          MESSAGING_TRANSPORT => 7
+//            GENERIC_TRANSPORT => 8
 //    p => port instance number 
-//        Port instances in the handle are 1 based. (e.g. p == 0 is invalid )
+//        Port instances in the handle are 1 based. (e.g. p == 0 is invalid except when T == 0 )
 //    c -> Controller instance number ( USB_TRANSPORT only )
 //
-//    NULL_PORT => T==0 && p == 0 
-// 
+//    NULL_PORT => T==0 && p == 0
+//
+// GENERIC_TRANSPORT is any custom port that isn't one of the above, they 
+// are implemneted for the DebugPort_xxxx apis and the port number is 
+// and index into a const global table of port interfaces (structure of
+// function pointers) These allow custom extensions to the normal transports
+// without needing to continue defining additional transport types and modifiying
+// switch on transport code. To keep compatibility high and code churn low, the
+// previous legacy transports remain. 
 typedef INT32 COM_HANDLE;
 
 #define TRANSPORT_SHIFT             8
@@ -222,6 +230,7 @@ typedef INT32 COM_HANDLE;
 #define ExtractEventFromTransport(x) (ExtractTransport(x) == USART_TRANSPORT     ? SYSTEM_EVENT_FLAG_COM_IN: \
                                       ExtractTransport(x) == USB_TRANSPORT       ? SYSTEM_EVENT_FLAG_USB_IN: \
                                       ExtractTransport(x) == SOCKET_TRANSPORT    ? SYSTEM_EVENT_FLAG_SOCKET: \
+                                      ExtractTransport(x) == GENERIC_TRANSPORT   ? SYSTEM_EVENT_FLAG_GENERIC_PORT: \
                                       ExtractTransport(x) == DEBUG_TRANSPORT     ? SYSTEM_EVENT_FLAG_DEBUGGER_ACTIVITY: \
                                       ExtractTransport(x) == MESSAGING_TRANSPORT ? SYSTEM_EVENT_FLAG_MESSAGING_ACTIVITY: \
                                       0) \
@@ -248,11 +257,14 @@ typedef INT32 COM_HANDLE;
 
 #define MESSAGING_TRANSPORT         (7 << TRANSPORT_SHIFT)
 
+#define GENERIC_TRANSPORT           (8 << TRANSPORT_SHIFT)
+
 #define COM_IsSerial(x)             (((x) & TRANSPORT_MASK) == USART_TRANSPORT)
 #define COM_IsUsb(x)                (((x) & TRANSPORT_MASK) == USB_TRANSPORT)
 #define COM_IsSock(x)               (((x) & TRANSPORT_MASK) == SOCKET_TRANSPORT)
 #define COM_IsDebug(x)              (((x) & TRANSPORT_MASK) == DEBUG_TRANSPORT)
 #define COM_IsMessaging(x)          (((x) & TRANSPORT_MASK) == MESSAGING_TRANSPORT)
+#define COM_IsGeneric(x)            (((x) & TRANSPORT_MASK) == GENERIC_TRANSPORT)
 
 // Extracts a USART port number from a USART COM_HANDLE
 #define ConvertCOM_ComPort(x)       (((x) & PORT_NUMBER_MASK) - 1)
@@ -272,9 +284,12 @@ typedef INT32 COM_HANDLE;
 // Extracts a Debug transport port id from a DEBUG_TRANSPORT COM_HANDLE
 #define ConvertCOM_DebugPort(x)     (((x) & PORT_NUMBER_MASK) - 1)
 
-// Extracts a messaging transport port id from a MESSAGING_TRASNPORT COM_HANDLE
+// Extracts a messaging transport port id from a MESSAGING_TRANSPORT COM_HANDLE
 #define ConvertCOM_MessagingPort(x) (((x) & PORT_NUMBER_MASK) - 1)
 
+// Extracts a generic transport port id from a GENERIC_TRANSPORT COM_HANDLE
+#define ConvertCOM_GenericPort(x) (((x) & PORT_NUMBER_MASK) - 1)
+
 // Creates a COM_HANDLE value for a platform specific USART port number
 #define ConvertCOM_ComHandle(x)      ((COM_HANDLE)((x) + USART_TRANSPORT     + 1))
 
@@ -289,10 +304,11 @@ typedef INT32 COM_HANDLE;
 // Creates a COM_HANDLE value for a platform specific port number
 #define ConvertCOM_DebugHandle(x)    ((COM_HANDLE)((x) + DEBUG_TRANSPORT     + 1))
 
-// Creates a COM_HANDLE value for a platform specific MESsAGING port number
+// Creates a COM_HANDLE value for a platform specific MESSAGING port number
 #define ConvertCOM_MessagingHandle(x)((COM_HANDLE)((x) + MESSAGING_TRANSPORT + 1))
 
-//--//
+// Creates a COM_HANDLE value for a platform specific GENERIC port number
+#define ConvertCOM_GenericHandle(x)((COM_HANDLE)((x) + GENERIC_TRANSPORT + 1))
 
 typedef UINT32 FLASH_WORD;
 
@@ -638,7 +654,7 @@ void ApplicationEntryPoint();
 #define SYSTEM_EVENT_FLAG_TIMER1                    0x00000020
 #define SYSTEM_EVENT_FLAG_TIMER2                    0x00000040
 #define SYSTEM_EVENT_FLAG_BUTTON                    0x00000080
-#define SYSTEM_EVENT_FLAG_UNUSED_0x00000100         0x00000100
+#define SYSTEM_EVENT_FLAG_GENERIC_PORT              0x00000100
 #define SYSTEM_EVENT_FLAG_UNUSED_0x00000200         0x00000200
 #define SYSTEM_EVENT_FLAG_UNUSED_0x00000400         0x00000400
 #define SYSTEM_EVENT_FLAG_NETWORK                   0x00000800