// Copyright (c) 2005-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:

// UI menu file

// 

//

/**

 @file

*/

#include <e32const.h>

#include <e32const_private.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <e32cons.h>

#include <f32file.h>

#include <hal.h>

#include <u32hal.h>

#include "bootloader_variantconfig.h"

#include <nkern/nk_trace.h>

#include <e32twin.h>

#define FILE_ID	0x01

#include "bootldr.h"

#include <d32comm.h>

// Console screen

RConsole TheConsole;

RThread TheKeyThread;

////////////////////////////////////////////////////////

void menu_displayfn();

LOCAL_C void menu_processkey(TConsoleKey&);

void autoload_displayfn();

LOCAL_C void autoload_processkey(TConsoleKey &aKey);

struct display_process

	{

	void (*iDisplayFn)();

	void (*iProcessKey)(TConsoleKey&);

	};

display_process screens[] =

	{

	{autoload_displayfn, autoload_processkey},

	{menu_displayfn, menu_processkey}

	};

#define SCREEN_AUTOLOAD 0

#define SCREEN_MENU 1

display_process* gCurrentScreen = &screens[SCREEN_AUTOLOAD];

TBool gScreenUpdate;	// Controls whether to redraw the screen

void mainmenu_usbboot(TUint32, TUint32)

	{

	// Turn off raw mode so app receives key events

	TheConsole.Control(_L("-Raw"));

	if(StartUSBMS() == EFalse)

		{

		// Didn't manage to start

		TheConsole.Control(_L("+Raw"));

		TheConsole.SetCursorPosAbs(TPoint(0,15));

		TheConsole.Write(_L("Insert MMC card first!!"));

		TheConsole.SetCursorPosAbs(TPoint(0,16));

		TheConsole.Write(_L("Card required for USB boot"));

		TheConsole.SetCursorPosAbs(TPoint(0,17));

		TheConsole.Write(_L("mode"));

		}

	return;

	}

void mainmenu_serial(TUint32 aPort, TUint32 aBaud)

	{

	TBps baudRate;

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TBuf<64> outBuf;

	switch (aBaud)

		{

		case 115200:	baudRate = EBps115200; break;

		case 230400:    baudRate = EBps230400; break;

		default:

			outBuf.AppendFormat(_L("Invalid Baud Rate (COM%d,%d)"), aPort, aBaud);

			TheConsole.Write(outBuf);

			return;

		}

	outBuf.AppendFormat(_L("Setting COM%d baud %d"), aPort, aBaud);

	TheConsole.Write(outBuf);

	SerialDownloadPort = aPort;

	SerialBaud         = baudRate;

	WriteConfig();

	Restart(KtRestartReasonHardRestart);

	}

#ifdef __SUPPORT_FLASH_REPRO__

void mainmenu_bootnor(TUint32, TUint32)

	{

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TheConsole.Write(_L("Attempting to boot from"));

	TheConsole.SetCursorPosAbs(TPoint(0,16));

	TheConsole.Write(_L("onboard NOR flash..."));

	// This will restart the board very quickly - pause a second to let the LCD

	// controler display the message

	User::After(10000);

	Restart(KtRestartReasonBootRestart | KtRestartReasonNORImage);

	}

#endif

#ifdef __SUPPORT_MEMORY_TEST__

void mainmenu_memtest(TUint32, TUint32)

	{

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TheConsole.Write(_L("Starting Memory Test"));

	TheConsole.SetCursorPosAbs(TPoint(0,16));

	TheConsole.Write(_L("screen will decay..."));

	// This will restart the board very quickly - pause a second to let the LCD

	// controler display the message

	User::After(10000);

	Restart(KtRestartCustomRestartMemCheck);

	}

#endif

#ifdef __SUPPORT_FLASH_NAND__

void mainmenu_bootnand(TUint32, TUint32)

	{

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TheConsole.Write(_L("Attempting to boot from"));

	TheConsole.SetCursorPosAbs(TPoint(0,16));

	TheConsole.Write(_L("onboard NAND flash..."));

	// This will restart the board very quickly - pause a moment to let the LCD

	// controler display the message

	User::After(10000);

	Restart(KtRestartReasonBootRestart | KtRestartReasonNANDImage);

	}

#endif

#ifdef __SUPPORT_FLASH_ONENAND__

LOCAL_C void mainmenu_bootonenand(TUint32, TUint32)

	{

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TheConsole.Write(_L("Attempting to boot from"));

	TheConsole.SetCursorPosAbs(TPoint(0,16));

	TheConsole.Write(_L("onboard OneNAND flash..."));

	// This will restart the board very quickly - pause a moment to let the LCD

	// controller display the message

	User::After(10000);

	Restart(KtRestartReasonBootRestart | KtRestartReasonONENANDImage);

	}

#endif

#ifdef __USE_EMBEDDED_MMC_SD__

LOCAL_C void mainmenu_bootmmc(TUint32, TUint32)

	{

	TheConsole.SetCursorPosAbs(TPoint(0,15));

	TheConsole.Write(_L("Attempting to boot from"));

	TheConsole.SetCursorPosAbs(TPoint(0,16));

	TheConsole.Write(_L("Embedded MMC..."));

	// This will restart the board very quickly - pause a moment to let the LCD

	// controller display the message

	User::After(10000);

	Restart(KtRestartReasonBootRestart | KtRestartReasonMMCSDImage);

	}

#endif

// Example of switching screens

//

// void mainmenu_gotoautoload()

//	{

//	// Change screen

//	gCurrentScreen = &screens[SCREEN_AUTOLOAD];

//	gScreenUpdate=ETrue;

//	}

struct menu_item

	{

	TPtrC iTitle;

	void (*iFn)(TUint32, TUint32);

	TUint32 iParam1;

	TUint32 iParam2;

	};

menu_item mainmenu[] =

	{

//	{_L("Autoload mode"), mainmenu_gotoautoload},

#ifdef __USE_USBMS__

	{_L("USB Mass Storage mode"), mainmenu_usbboot, 0, 0},

#endif

#ifdef __SUPPORT_COM0_115200__

	{_L("COM0 @ 115200"), mainmenu_serial, 0, 115200},

#endif

#ifdef __SUPPORT_COM0_230400__

	{_L("COM0 @ 230400"), mainmenu_serial, 0, 230400},

#endif

#ifdef __SUPPORT_COM1_115200__

	{_L("COM1 @ 115200"), mainmenu_serial, 1, 115200},

#endif

#ifdef __SUPPORT_COM1_230400__

	{_L("COM1 @ 230400"), mainmenu_serial, 1, 230400},

#endif

#ifdef __SUPPORT_COM2_115200__

	{_L("COM2 @ 115200"), mainmenu_serial, 2, 115200},

#endif

#ifdef __SUPPORT_COM2_230400__

	{_L("COM2 @ 230400"), mainmenu_serial, 2, 230400},

#endif

#ifdef __SUPPORT_COM3_115200__

	{_L("COM3 @ 115200"), mainmenu_serial, 3, 115200},

#endif

#ifdef __SUPPORT_COM3_230400__

	{_L("COM3 @ 230400"), mainmenu_serial, 3, 230400},

#endif

#ifdef __SUPPORT_COM7_115200__

	{_L("COM7 @ 115200"), mainmenu_serial, 7, 115200},

#endif

#ifdef __SUPPORT_FLASH_REPRO__

	{_L("Try boot NOR flash"), mainmenu_bootnor, 0, 0},

#endif

#ifdef __SUPPORT_FLASH_NAND__

	{_L("Try boot NAND flash"), mainmenu_bootnand, 0, 0},

#endif

#ifdef __SUPPORT_FLASH_ONENAND__

	{_L("Try boot OneNAND flash"), mainmenu_bootonenand, 0, 0},

#endif

#ifdef __USE_EMBEDDED_MMC_SD__

	{_L("Try boot Embedded MMC"), mainmenu_bootmmc, 0, 0},

#endif	

#ifdef __SUPPORT_MEMORY_TEST__

	{_L("Run Memory Test"), mainmenu_memtest, 0, 0},

#endif

	{_L("The End"), NULL},		// DO NOT REMOVE - array terminator

	};

TInt mainmenu_items=0;	// The number of items in the menu is set up when the menu is drawn

TInt mainmenu_idx=0;

// autoload screen functions

void autoload_displayfn()

	{

	TheConsole.ClearScreen();

	TheConsole.SetCursorPosAbs(TPoint(0,0));

	TheConsole.SetTitle(_L("AUTOLOAD"));

	TheConsole.Write(_L("AUTOLOADING on Serial....."));

	}

void autoload_processkey(TConsoleKey &aKey)

{

	TUint code = aKey.Code();

	if (aKey.Type() == 0x3) // key down

		{

		if ((code == 0x3)||(code == 0x4)) // Direction key enter, or Esc

			{

			// Change to menu mode

			gCurrentScreen = &screens[SCREEN_MENU];

			gScreenUpdate=ETrue;

			}

		}

	}

// main menu screen functions

void menu_displayfn()

	{

	TheConsole.ClearScreen();

	TheConsole.SetTitle(_L("Bootloader menu"));

	mainmenu_items=0;

	for (TInt i=0; mainmenu[i].iFn!=NULL ; i++)

		{

		TheConsole.SetCursorPosAbs(TPoint(0,i+1));

		if (mainmenu_idx==i)

			TheConsole.Write(_L("==> "));

		else

			TheConsole.Write(_L("    "));

		TBuf<0x2> buf;

		buf.AppendNum(i);

		TheConsole.Write(buf);

		TheConsole.Write(_L("."));

		TheConsole.Write(mainmenu[i].iTitle);

		mainmenu_items++;

		}

	TheConsole.SetCursorPosAbs(TPoint(0,14));

	TheConsole.Write(_L("============================"));

	}

void menu_processkey(TConsoleKey &aKey)

	{

	TUint code=aKey.Code();

	TUint type=aKey.Type();

	if (type == 0x3) // key down

		{

		if (code == 0x3) // Direction key enter

			{

			mainmenu[mainmenu_idx].iFn(mainmenu[mainmenu_idx].iParam1, mainmenu[mainmenu_idx].iParam2);

			}

		else if (code == 0x11) // Direction key down (portrait)

			{

			if (++mainmenu_idx == mainmenu_items)

				mainmenu_idx=0;

			gScreenUpdate=ETrue;

			}

		else if (code == 0x10) // Direction key up (portrait)

			{

			if (--mainmenu_idx<0)

				mainmenu_idx=mainmenu_items-1;

			gScreenUpdate=ETrue;

			}

		else if ((code >= 0x30) && (code <= 0x39))

			{

			// If a number is entered, select the relevant menu option

			TUint num=code-0x30;

			if (num < TUint(mainmenu_items))

				{

				// coverity[overrun-local]

				// Coverity doesn't consider the comparison against mainmenu_items

				mainmenu[num].iFn(mainmenu[num].iParam1, mainmenu[num].iParam2);

				}

			}

		}

	}

// Generic key press processor

void keystate_processor(TConsoleKey &aKey)

	{

	gScreenUpdate=EFalse;

	gCurrentScreen->iProcessKey(aKey);

	if (gScreenUpdate)

		gCurrentScreen->iDisplayFn();

	}

TInt KeyThreadFn(TAny*)

	{

	// Create a console window

	TheConsole.Init(_L(""),TSize(KConsFullScreen,KConsFullScreen));

	// Suppress cursor, stop any resizing, ensure that we get RAW events from

	// the console which means people can't dick with the screen

	TheConsole.Control(_L("-Cursor -Aresize +Raw"));

	while(1)

		{

		TConsoleKey key;

		TheConsole.Read(key);

		//RDebug::Print(_L("code 0x%x\n"), key.Code());

		//RDebug::Print(_L("type 0x%x\n"), key.Type());

		//RDebug::Print(_L("mods 0x%x\n"), key.Modifiers());

		keystate_processor(key);

		}

	}

//////////////////////////////////////////////////////////////////////////////

//

// Application entry point

//

//////////////////////////////////////////////////////////////////////////////

GLDEF_C void StartMenu()

	{

    TInt r = KErrUnknown;

	// Create thread for console and key events

	r = TheKeyThread.Create(_L("keythread"),KeyThreadFn,KDefaultStackSize,0x200,0x200,(TAny*)NULL,EOwnerProcess);

	if (r != KErrNone)

		{

		RDebug::Print(_L("FAULT: thread create %d\r\n"),r);

		BOOT_FAULT();

		}

	TheKeyThread.Resume();

	// Pause slightly to let the console draw before continuing

	User::After(100000);

	}

GLDEF_C void EnableMenu()

	{

	// RDebug::Print(_L("Enable\r\n"));

	// Touching TheConsole is not allowed from this context

	// TheConsole.Control(_L("+Raw"));

	}

GLDEF_C void DisableMenu()

	{

	// RDebug::Print(_L("Disable\r\n"));

	// Touching TheConsole is not allowed from this context

	// TheConsole.Control(_L("-Raw"));

	}