--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/serialmouse/serialmouse.cpp	Thu Oct 15 12:59:54 2009 +0100
@@ -0,0 +1,434 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// omap3530/beagle_drivers/serialmouse/serialmouse.cpp
+// Serial mouse driver
+//
+
+
+
+/**
+ @file
+ @internalTechnology
+*/
+
+#include <e32keys.h>
+#include <arm.h>
+#include <comm.h>
+#include <assp.h>
+
+#include <assp/omap3530_assp/omap3530_uart.h>
+//#include <assp/omap3530_assp/omap3530_prm.h>
+#include <assp/omap3530_assp/omap3530_prcm.h>
+//#include <resourceman.h>
+
+#include "serialmouse.h"
+
+_LIT( KName, "SERMOUSE" );
+
+#ifdef _FRAME_BUFFER_CURSOR_
+#	define CURSOR_SIZE 5
+#endif
+
+
+LOCAL_C TInt halFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)
+	{
+	TSerialMouse* pH=(TSerialMouse*)aPtr;
+	return pH->HalFunction(aFunction,a1,a2);
+	}
+
+TSerialMouse::TSerialMouse()
+				: iKeyDfc( KeyDfcFn, this, Kern::DfcQue0(), 1 ), iState(ENormal),
+				iUart( Omap3530Uart::EUart2 )
+	{
+	Kern::Printf("+TSerialMouse::TSerialMouse");
+
+#	ifdef _FRAME_BUFFER_CURSOR_
+	iCursorBuffer = new TUint16[CURSOR_SIZE*CURSOR_SIZE];
+#	endif
+	
+	}
+
+TSerialMouse::~TSerialMouse()
+	{
+#	ifdef _FRAME_BUFFER_CURSOR_
+	delete[] iCursorBuffer;
+#	endif
+	}
+ 
+TInt TSerialMouse::Create()
+	{
+	
+	GetScreenInfo();
+	
+	TInt r=Kern::AddHalEntry(EHalGroupMouse, halFunction, this);
+	if (r!=KErrNone)
+		return r;
+	
+	
+	__KTRACE_OPT(KBOOT,Kern::Printf("+TSerialMouse::Init")) ;
+
+	iDebugPort = Kern::SuperPage().iDebugPort; // Get the debug port number
+	if( Arm::EDebugPortJTAG == iDebugPort )
+		{
+		__KTRACE_OPT(KBOOT,Kern::Printf("-TSerialMouse::Init: JTAG not supported"));
+		// We don't want to return an error here, just don't bother to initialize
+		return KErrNone;
+		}
+	else if( 2 != iDebugPort )
+		{
+		__KTRACE_OPT(KBOOT,Kern::Printf("-TSerialMouse::Init: Only UART3 supported"));
+		// We don't want to return an error here, just don't bother to initialize
+		return KErrNone;
+		}
+
+
+	// Register with the power resource manager
+	//r = PowerResourceManager::RegisterClient( iPrmClientId, KName );
+	//if( r != KErrNone )
+	//	{
+	//	return r;
+	//	}
+
+	//__KTRACE_OPT(KBOOT,Kern::Printf("+TSerialMouse::Init:PRM client ID=%x", iPrmClientId )) ;
+
+ 	r =Interrupt::Bind( iUart.InterruptId(),Isr,this);
+	if ( r < 0 )
+ 		{
+		Kern::Printf("TSerialMouse::Create Cant Bind to Interrupt %d ret %d",iUart.InterruptId(), r );
+		return r;
+ 		}
+
+	// Ask power resource manager to turn on clocks to the UART
+	// (this could take some time but we're not in any hurry)
+	//r = PowerResourceManager::ChangeResourceState( iPrmClientId, iUart.PrmFunctionClk(), Prcm::EClkAuto );
+	//if( KErrNone != r )
+	//	{
+	//	return r;
+	//	}
+		
+	//r = PowerResourceManager::ChangeResourceState( iPrmClientId, iUart.PrmInterfaceClk(), Prcm::EClkAuto );
+	//if( KErrNone != r )
+	//	{
+	//	return r;
+	//	}
+
+	iUart.Init();
+	iUart.DefineMode( Omap3530Uart::TUart::EUart );
+	iUart.SetBaud( Omap3530Uart::TUart::E1200 );
+	iUart.SetDataFormat( Omap3530Uart::TUart::E7Data, Omap3530Uart::TUart::E1Stop, Omap3530Uart::TUart::ENone );
+	iUart.EnableFifo( Omap3530Uart::TUart::EEnabled, Omap3530Uart::TUart::ETriggerUnchanged, Omap3530Uart::TUart::ETrigger8 );
+	iUart.EnableInterrupt( Omap3530Uart::TUart::EIntRhr );
+	iUart.Enable();
+
+	Interrupt::Enable(iUart.InterruptId());
+    
+	return KErrNone;
+	}
+
+
+void TSerialMouse::Isr( TAny* aPtr )
+	//
+	// Interrupt service routine. Called when we receive an interrupt
+	// on the IRQ line it is bound to. If it's a receive, queues DFC
+	// to post the event into the event queue.
+	//
+	{
+	TSerialMouse* self = (TSerialMouse*)aPtr;
+	
+	const TUint iir = Omap3530Uart::IIR::iMem.Read( self->iUart );
+
+	if ( 0 == (iir bitand Omap3530Uart::IIR::IT_PENDING::KMask) )
+		{
+		const TUint pending = iir bitand Omap3530Uart::IIR::IT_TYPE::KFieldMask;
+
+		// Although the TI datasheet descrivwed IT_TYPE as being an enumerated priority-decoded interrupt
+		// it appears to actually be a bitmask of active interrupt sources
+		if ( (pending bitand Omap3530Uart::IIR::IT_TYPE::ERHR) || (pending bitand Omap3530Uart::IIR::IT_TYPE::ERxLineStatus) )
+			{
+			TUint byte = self->iUart.Read();
+			
+			self->iKey = byte;
+			self->iKeyDfc.Add();
+			Interrupt::Disable( self->iUart.InterruptId() );
+			}
+		}
+	}
+	
+void TSerialMouse::KeyDfcFn( TAny* aPtr )
+	//
+	// DFC function. Just calls inline function KeyDfc()
+	//
+	{
+	((TSerialMouse*)aPtr)->KeyDfc();
+	}
+	
+inline void TSerialMouse::KeyDfc()
+	//
+	// Processes received characters
+	//
+	{	
+	
+	const TUint8 b = iKey;
+	
+	if ( b & 1<<6 )
+		{
+		// Beginning of a new frame
+		iByteIndex = 0;
+		iB0 = b;
+		}
+	else if ( iByteIndex == 0 )
+		{
+		iByteIndex = 1;
+		iB1 = b;
+		}
+	else if ( iByteIndex == 1 )
+		{
+		iByteIndex = -1;
+		iB2 = b;
+		
+		const TInt8 x_increment = (iB0 & 0x3)<<6 | (iB1 & 0x3f);
+		const TInt8 y_increment = (iB0 & 0xC)<<4 | (iB2 & 0x3f);
+		const TBool isLeftButtonDown	= iB0& 1<<5;
+		const TBool isRightButtonDown	= iB0& 1<<4;
+		
+#		ifdef _FRAME_BUFFER_CURSOR_
+		iLastX = iX;
+		iLastY = iY;
+#		endif
+		
+		iX += x_increment; //Scale ( x_increment );
+		iY += y_increment; //Scale ( y_increment );
+		
+		Clip( iX, iY );
+		
+		//DBG_PRINT4(_L("\nx:%d y:%d (%d,%d)"), x_increment, y_increment, iX, iY );
+		
+		TBool rightButtonEvent = (isRightButtonDown != iLastRightButtonDown);
+		TBool leftButtonEvent = (isLeftButtonDown != iLastLeftButtonDown);
+		iLastLeftButtonDown	= isLeftButtonDown;
+		iLastRightButtonDown	= isRightButtonDown;
+		
+		TRawEvent e;
+		
+		if ( rightButtonEvent )
+			{
+			e.Set( isRightButtonDown ? TRawEvent::EButton2Down : TRawEvent::EButton2Up, iX, iY );
+			Kern::AddEvent(e);	
+			//DBG_PRINT1(_L(" right:%S"), isRightButtonDown?&_L("down"):&_L("up") );
+			}
+		
+		if ( leftButtonEvent )
+			{
+			e.Set( isLeftButtonDown ? TRawEvent::EButton1Down : TRawEvent::EButton1Up, iX, iY );
+			Kern::AddEvent(e);
+			//DBG_PRINT1(_L(" left:%S"), isLeftButtonDown?&_L("down"):&_L("up") );
+			}
+		
+		if ( !rightButtonEvent && !leftButtonEvent )
+			{
+#			ifdef _TRACK_COORDINATES_
+			// Reoprt the exact coordinate to the windowserver
+			e.Set(TRawEvent::EPointerMove,iX,iY);
+#			else
+			// Report the change in coordinates to the windowserver
+			e.Set(TRawEvent::EPointerMove,x_increment,y_increment);
+#			endif
+			Kern::AddEvent(e);
+			}
+		
+#		ifdef _FRAME_BUFFER_CURSOR_
+		DrawCursor(iX,iY);
+#		endif
+		
+		}
+	
+	Interrupt::Enable(iUart.InterruptId()); // Can handle new chars now
+	} /* end of function - KeyDfc - */
+
+
+/*
+Perform 2:1 scaling on a mosue movement.
+*/
+TInt TSerialMouse::Scale(const TInt& aVal)
+	{
+	switch (aVal)
+		{
+		case 0: return 0;
+		case 1:
+		case 2: return 1;
+		case 3: return 3;
+		case 4: return 6;
+		case 5: return 9;
+		case -1:
+		case -2: return -1;
+		case -3: return -3;
+		case -4: return -6;
+		case -5: return -9;
+		default: return 2*aVal;
+		}
+	}
+
+/*
+Clip the mouse coordinates into the dimensions of the screen
+*/
+void TSerialMouse::Clip(TInt& aX, TInt& aY)
+	{
+	if ( aX < 0 )	aX = 0;
+	if ( aX >= iScreenWidth )	aX = iScreenWidth - 1;
+	if ( aY < 0 )	aY = 0;
+	if ( aY >= iScreenHeight )	aY = iScreenHeight - 1;
+	}
+
+void TSerialMouse::GetScreenInfo()
+	{
+	TScreenInfoV01 screenInfo;
+	TPckg<TScreenInfoV01> sI(screenInfo);
+	Kern::HalFunction(EHalGroupDisplay,EDisplayHalScreenInfo,(TAny*)&sI,NULL);
+	iScreenWidth = screenInfo.iScreenSize.iWidth;
+	iScreenHeight = screenInfo.iScreenSize.iHeight;
+#	ifdef _FRAME_BUFFER_CURSOR_
+	iVideoAddress = (TUint8*)screenInfo.iScreenAddress;
+#	endif
+	}
+
+#ifdef _FRAME_BUFFER_CURSOR_
+void TSerialMouse::Blit(TInt x, TInt y, TUint16 aColour)
+	{
+	
+	TUint16* fb = (TUint16*)iVideoAddress;
+	fb += (iLastY * iScreenWidth) + iLastX;
+	for (TInt i = 0; i<CURSOR_SIZE; ++i) //row
+		{
+		
+		if ( (iLastY + i) >= iScreenHeight) break;
+		
+		for (TInt j = 0; j<CURSOR_SIZE; ++j) //column
+			{
+			
+			if ((iLastX+j) < iScreenWidth)
+				{
+				*fb = iCursorBuffer[i*CURSOR_SIZE + j];
+				}
+				
+			++fb;
+			}
+		fb += iScreenWidth - CURSOR_SIZE;
+		}
+	
+	
+	fb = (TUint16*)iVideoAddress;
+	fb += (y * iScreenWidth) + x;
+	for (TInt i = 0; i<CURSOR_SIZE; ++i) //row
+		{
+		
+		if ( (y + i) >= iScreenHeight) break;
+		
+		for (TInt j = 0; j<CURSOR_SIZE; ++j) //column
+			{
+			
+			if ((x+j) < iScreenWidth)
+				{
+				iCursorBuffer[i*CURSOR_SIZE + j] = *fb;
+				*fb = aColour;
+				}
+				
+			++fb;
+			}
+		fb += iScreenWidth - CURSOR_SIZE;
+		}
+	
+	/*TUint8* fb = iVideoAddress;
+	fb += ( (y * iScreenWidth) + x ) * 2;	
+	
+	TBuf8<256> cur;
+	cur.FillZ();
+	TUint8* cursor = &cur[0];
+	
+	for (TInt i = 0; i<cursorSize; ++i)
+		{
+		
+		if ( (y + i) >= iScreenHeight) break;
+		
+		TInt bytes_to_copy = Min( cursorSize, iScreenWidth*2 - x*2 );
+		
+		Mem::Copy(fb, cursor, bytes_to_copy );
+		
+		cursor += cursorSize;
+		
+		}*/
+	
+	}
+
+void TSerialMouse::DrawCursor(TInt x, TInt y)
+	{	
+	TUint16 cursorColour = iLastLeftButtonDown ? 0x1F : 0x00;
+	Blit(x, y, cursorColour);
+	}
+#endif
+
+ 
+TInt TSerialMouse::HalFunction(TInt aFunction, TAny* a1, TAny* /*a2*/)
+	{
+	TInt r=KErrNone;
+	switch(aFunction)
+		{
+		case EMouseHalMouseInfo:
+			{
+			TPckgBuf<TMouseInfoV01> vPckg;
+			TMouseInfoV01& xyinfo=vPckg();
+			xyinfo.iMouseButtons=2;
+			xyinfo.iMouseAreaSize.iWidth=iScreenWidth;
+			xyinfo.iMouseAreaSize.iHeight=iScreenHeight;
+			xyinfo.iOffsetToDisplay.iX=0;
+			xyinfo.iOffsetToDisplay.iY=0;
+			Kern::InfoCopy(*(TDes8*)a1,vPckg);
+			break;
+			}
+		default:
+			r=KErrNotSupported;
+			break;
+		}
+	return r;
+	}
+
+void DoCreate( TAny* aParam )
+	{
+	TInt r = reinterpret_cast< TSerialMouse* >( aParam )->Create();
+	__ASSERT_ALWAYS( r == KErrNone, Kern::Fault( "SERKEY-Cr", r ) );	
+	}
+
+
+//
+// Kernel Extension entry point
+//
+DECLARE_STANDARD_EXTENSION()
+	{
+	__KTRACE_OPT(KBOOT,Kern::Printf("Starting mouse driver"));
+	
+	// create mouse driver
+	TInt r=KErrNoMemory;
+	TSerialMouse* mouse = new TSerialMouse;
+	if ( mouse )
+		{
+		// Because the Power Resource Manager doesn't finish initializing until after it
+		// has run a DFC on SvMsgQue, we need to defer our initialization until after that
+		// so we know that the PRM is ready for us to use it
+		static TDfc createDfc( &DoCreate, NULL );
+		new( &createDfc ) TDfc( &DoCreate, mouse, Kern::SvMsgQue(), KMaxDfcPriority-2 );
+		createDfc.Enque();
+		r = KErrNone;
+		}
+	__KTRACE_OPT(KEXTENSION,Kern::Printf("Returns %d",r));
+	return r;
+	}