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

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32test.h>

#include <testusbc.h>

#include "t_gml_tur_protocol.h"

#include "t_gml_tur_controller.h"

#include "cbulkonlytransport.h"

LOCAL_D RTest test(_L("t_gml_tur"));

_LIT(KDriverFileName,"TESTUSBC.LDD");

_LIT(KLddName,"usbc");

_LIT(KTransportThreadName,"TransportThread");

_LIT(KTransportSemName,"TransportThreadSem");

LOCAL_D const TInt KFiveDrives = 5;

LOCAL_D const TEndpointNumber KOutEp = EEndpoint1;

GLDEF_D CUsbMassStorageController* gController = NULL;

LOCAL_C void SetCBWHeader(TDes8& cbwData, TInt32 aDataTransferLength, TBool aDataIn, TUint8 aLun, TUint8 aCBLength)

	{

	//dCBWSignature

	cbwData[0] = 0x55;

	cbwData[1] = 0x53;

	cbwData[2] = 0x42;

	cbwData[3] = 0x43;

	//dCBWTag

	cbwData[4] = 0x01;

	cbwData[5] = 0x00;

	cbwData[6] = 0x00;

	cbwData[7] = 0x00;

	//dCBWDataTransferLength

	cbwData[8] = TUint8((aDataTransferLength & 0x000000FF));

	cbwData[9] = TUint8((aDataTransferLength & 0x0000FF00) >> 8);

	cbwData[10] = TUint8((aDataTransferLength & 0x00FF0000) >> 16);

	cbwData[11] = TUint8((aDataTransferLength & 0xFF000000) >> 24);

	//bmCBWFlags

	if (aDataIn)

		{

		cbwData[12] = 0x80;

		}

	else

		{

		cbwData[12] = 0x00;

		}

	//bCBWLUN

	cbwData[13] = aLun;

	//bCBWCBLength

	cbwData[14] = aCBLength;

	}

LOCAL_C TInt TransportThreadEntry(TAny* aPtr)

	{

	TInt err = KErrNone;

	TInt numDrives = KFiveDrives;

	//Create and install cleanup trap and active scheduler

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if (cleanup == NULL)

		{

		return KErrNoMemory;

		}

	CActiveScheduler* sched = new CActiveScheduler;

	if (sched == NULL)

		{

		return KErrNoMemory;

		}

	CActiveScheduler::Install(sched);

	//Start transport

	CScsiProtocol* protocol = NULL;

	TRAP(err, protocol = CScsiProtocol::NewL());

	if (err != KErrNone)

		{

		return err;

		}

	CUsbMassStorageController* controller = (CUsbMassStorageController*)aPtr;

	gController = controller;

	controller->CreateL(0);

	CBulkOnlyTransport* transport = NULL;

	TRAP(err, transport = CBulkOnlyTransport::NewL(numDrives, *controller));

	if (err != KErrNone)

		{

		return err;

		}

	controller->SetTransport(transport);

	TRAP(err, transport->InitialiseTransportL(1));

	transport->RegisterProtocol(*protocol);

	transport->Start();

	//Synchronize with test thread

	RSemaphore gSemThreadReady;

	gSemThreadReady.OpenGlobal(KTransportSemName);

	gSemThreadReady.Signal();

	gSemThreadReady.Close();

	CActiveScheduler::Start();

	delete transport;

	delete controller;

	delete protocol;

	delete sched;

	delete cleanup;

	return KErrNone;

	}

GLDEF_C TInt E32Main()

	{

	test.Title();

	TInt err;

	test.Start(_L("Loading ldd"));

	err = User::LoadLogicalDevice(KDriverFileName);

	test(err == KErrNone || err == KErrAlreadyExists);

	RDevTestUsbcClient ldd;

	err = ldd.Open(0);

	test(err == KErrNone);

	//ldd.ResetEndpoints();

	RSemaphore gSemThreadReady;

	err = gSemThreadReady.CreateGlobal(KTransportSemName, 0);

	CUsbMassStorageController* controller = new CUsbMassStorageController();

	test(controller != NULL);

	//Start transport thread.

	RThread transportThread;

	test.Next(_L("Creating transport thread, Max Lun = 4"));

	err = transportThread.Create(KTransportThreadName, TransportThreadEntry, KDefaultStackSize, NULL, (void*)controller);

	test(err == KErrNone);

	transportThread.Resume();

	//Synchronize with transport thread.

	gSemThreadReady.Wait();

	gSemThreadReady.Close();

	test(gController != NULL);

	TRequestStatus status;

	test.Next(_L("Writing GetMaxLun request to endpoint 0"));

	//Write GetMaxLun request to endpoint 0

	TBuf8<KRequestHdrSize> controlData;

	controlData.SetLength(KRequestHdrSize);

	controlData.FillZ();

	controlData[0] = 0xA1;

	controlData[1] = 0xFE;

	controlData[6] = 0x01;

	ldd.HostWrite(status, EEndpoint0, controlData, KRequestHdrSize);

	User::WaitForRequest(status);

	test.Printf(_L("status = %d"), status.Int());

	test(status.Int() == KErrNone);

	//Read request response

	controlData.SetLength(1);

	ldd.HostRead(status, EEndpoint0, controlData, 1);

	User::WaitForRequest(status);

	test(status.Int() == KErrNone);

	test.Printf(_L("Max LUN: %d\n"), controlData[0]);

	test(controlData[0] == KFiveDrives - 1);

	//Send TEST UNIT READY command

	TBuf8<KCbwLength> cbwData;

	cbwData.SetLength(KCbwLength);

	cbwData.FillZ();

	SetCBWHeader(cbwData, 6, ETrue, 0, 6);

	ldd.HostWrite(status, KOutEp, cbwData, KCbwLength);

	User::WaitForRequest(status);

	test(status.Int() == KErrNone);

	test.Next(_L("Writing Reset request to endpoint 0"));

	//Write Reset request to endpoint 0

	controlData.SetLength(KRequestHdrSize);

	controlData.FillZ();

	controlData[0] = 0x21;

	controlData[1] = 0xFF;

	ldd.HostWrite(status, EEndpoint0, controlData, KRequestHdrSize);

	User::WaitForRequest(status);

	test(status.Int() == KErrNone);

	User::After(3000000); //3 seconds

	test(gController->IsReset());

	test.Printf(_L("Controller got reset request\n"));

	TRequestStatus logonStatus;

	transportThread.Logon(logonStatus);

	TRequestStatus* statusPtr = &(controller->iStatus);

	transportThread.RequestComplete(statusPtr, KErrNone);

	//Wait for thread to die

	test.Printf(_L("Waiting for controller thread to die\n"));

	User::WaitForRequest(logonStatus);

	transportThread.Close();

	test.Printf(_L("The thread is dead, long live the thread\n"));

	ldd.Close();

	test.Printf(_L("Unloading ldd"));

	err = User::FreeLogicalDevice(KLddName);

	test(err == KErrNone);

    test.End();

	return 0;

	}