Max Penth 
Hello,
as there seem to be many requests on how to do this I will post how I did
it.
I needed a way to access GPIO from C#. As there doesn't seem to be to
access the registers directly you have to create a C++-DLL and call it with
P/Invoke.
I copied parts out of my code to make it more readable, so it is possible
that there are small errors.
This is the DLL-Code:
#include "stdafx.h"
#include "I2CDLL.h"
#include "Pkfuncs.h"
#include "s2440.h" //In some BSPs this file has a slightly different name
like s3c2440a.h, which then include some other .h files (copy those too)
#include <windows.h>
#include <time.h>
#include <ceddk.h>
void gpioInit();
void Virtual_Alloc();
bool memoryAlloced = false;
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
extern "C" _declspec(dllexport) bool WINAPI DLLreadPin (int port, int pin)
{
gpioInit();
switch (port) {
case 0:
if (s2440IOP->rGPADAT & (0x1 << pin))
return true;
else
return false;
break;
case 1:
if (s2440IOP->rGPBDAT & (0x1 << pin))
return true;
else
return false;
break;
case 2:
if (s2440IOP->rGPCDAT & (0x1 << pin))
return true;
else
return false;
break;
case 3:
if (s2440IOP->rGPDDAT & (0x1 << pin))
return true;
else
return false;
break;
case 4:
if (s2440IOP->rGPEDAT & (0x1 << pin))
return true;
else
return false;
break;
case 5:
if (s2440IOP->rGPFDAT & (0x1 << pin))
return true;
else
return false;
break;
caase 6:
if (s2440IOP->rGPGDAT & (0x1 << pin))
return true;
else
return false;
break;
}
return false;
}
extern "C" _declspec(dllexport) int WINAPI DLLmakeInputPin(int port, int
pin) {
gpioInit();
switch (port) {
case 0:
s2440IOP->rGPACON = (s2440IOP->rGPACON &~ ( 3 << pin*2)) ;
break;
case 1:
s2440IOP->rGPBCON = (s2440IOP->rGPBCON &~ ( 3 << pin*2)) ;
break;
case 2:
s2440IOP->rGPCCON = (s2440IOP->rGPCCON &~ ( 3 << pin*2)) ;
break;
case 3:
s2440IOP->rGPDCON = (s2440IOP->rGPDCON &~ ( 3 << pin*2)) ;
break;
case 4:
s2440IOP->rGPECON = (s2440IOP->rGPECON &~ ( 3 << pin*2)) ;
break;
case 5:
s2440IOP->rGPFCON = (s2440IOP->rGPFCON &~ ( 3 << pin*2)) ;
break;
case 6:
s2440IOP->rGPGCON = (s2440IOP->rGPGCON &~ ( 3 << pin*2)) ;
break;
}
return 0;
}
extern "C" _declspec(dllexport) int WINAPI DLLsetPin(int port, int pin,
bool on)
{
gpioInit();
switch (port) {
case 0:
s2440IOP->rGPACON = (s2440IOP->rGPACON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPADAT = (s2440IOP->rGPADAT &~ (0x1 << pin));
else
s2440IOP->rGPADAT = (s2440IOP->rGPADAT | (0x1 << pin));
break;
case 1:
s2440IOP->rGPBCON = (s2440IOP->rGPBCON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPBDAT = (s2440IOP->rGPBDAT &~ (0x1 << pin));
else
s2440IOP->rGPBDAT = (s2440IOP->rGPBDAT | (0x1 << pin));
break;
case 2:
s2440IOP->rGPCCON = (s2440IOP->rGPCCON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPCDAT = (s2440IOP->rGPCDAT &~ (0x1 << pin));
else
s2440IOP->rGPCDAT = (s2440IOP->rGPCDAT | (0x1 << pin));
break;
case 3:
s2440IOP->rGPDCON = (s2440IOP->rGPDCON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPDDAT = (s2440IOP->rGPDDAT &~ (0x1 << pin));
else
s2440IOP->rGPDDAT = (s2440IOP->rGPDDAT | (0x1 << pin));
break;
case 4:
s2440IOP->rGPECON = (s2440IOP->rGPECON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPEDAT = (s2440IOP->rGPEDAT &~ (0x1 << pin));
else
s2440IOP->rGPEDAT = (s2440IOP->rGPEDAT | (0x1 << pin));
break;
case 5:
s2440IOP->rGPFCON = (s2440IOP->rGPFCON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPFDAT = (s2440IOP->rGPFDAT &~ (0x1 << pin));
else
s2440IOP->rGPFDAT = (s2440IOP->rGPFDAT | (0x1 << pin));
break;
case 6:
s2440IOP->rGPGCON = (s2440IOP->rGPGCON &~ ( 3 << pin*2)) | ( 1<< pin*2);
if (!on)
s2440IOP->rGPGDAT = (s2440IOP->rGPGDAT &~ (0x1 << pin));
else
s2440IOP->rGPGDAT = (s2440IOP->rGPGDAT | (0x1 << pin));
break;
}
return 0;
}
void Virtual_Alloc()
{
// GPIO Virtual alloc
s2440IOP = (volatile IOPreg *) VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE,
PAGE_NOACCESS);
if(s2440IOP == NULL) {
RETAILMSG(1,(TEXT("For s2440IOP: VirtualAlloc faiLED!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440IOP,(PVOID)(IOP_BASE),sizeof(IOPreg),PAGE_READWRITE
| PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440IOP: VirtualCopy faiLED!\r\n")));
}
}
}
void gpioInit() {
if (!memoryAlloced) {
Virtual_Alloc();
memoryAlloced = true;
}
}
The included header files can be found in the WinCE SDK and the BSP for the
Board. The .h file for the DLL looks like this (my DLL is named I2Cdll):
#ifdef I2CDLL_EXPORTS
#define I2CDLL_API __declspec(dllexport)
#else
#define I2CDLL_API __declspec(dllimport)
#endif
// This class is exported from the I2CDLL.dll
class I2CDLL_API CI2CDLL {
public:
CI2CDLL(void);
// TODO: add your methods here.
};
extern I2CDLL_API int nI2CDLL;
I2CDLL_API int fnI2CDLL(void);
Compile this DLL with eVC++, then place the .dll in your application folder
(deploy along with application), the it can be accessed with C# like this:
Declare Imports in beginning of class:
[DllImport("I2CDLL.dll")]
extern private static int DLLsetPin(int port, int pin, bool state);
[DllImport("I2CDLL.dll")]
extern private static bool DLLreadPin(int port, int pin);
[DllImport(("I2CDLL.dll"))]
private static extern int DLLmakeInputPin(int port, int pin);
From your code just call the function, e.g. for setting GPBC3 to true :
DLLsetPin(2, 4, true); //2 is port, beggining with 0, 4 is pin,
beginning with 0
Using PWM/SPI/Watchdog works basically the same, just initialise the proper
registers like done above with IOPreg.
I am aware that the code could be improved in terms of elegance (basically
make 1 line out of all that switch-clutter), but I really didn't bother.
Btw.: This is _a lot_ faster than implementing this stuff into a stream
interface driver (which has to be included in the OS-Image). Calling a
stream interface driver from C# is painfully slow.
