// 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:

// omap3530/omap3530_drivers/usbcc/pa_usbc.cpp

//

#include <usbc.h>

//#include <resourceman.h>

#include <assp/omap3530_assp/omap3530_assp_priv.h>

#include <assp/omap3530_assp/omap3530_irqmap.h>

#include <assp/omap3530_assp/omap3530_usbc.h>

//#include <assp/omap3530_assp/omap3530_prm.h>

#include <assp/omap3530_assp/omap3530_prcm.h>

// Debug support

#ifdef _DEBUG

static const char KUsbPanicCat[] = "USB PSL";

#endif

_LIT(KDfcName, "USB_DFC");

// Register definitions - move to a seperate header file at some point..

const TUint KCM_ICLKEN1_CORE = Omap3530HwBase::TVirtual<0x48004A10>::Value;

	const TUint KENHOSTOTGUSB_BIT = KBit4;

const TUint KCM_AUTOIDLE1_CORE = Omap3530HwBase::TVirtual<0x48004A30>::Value;

	const TUint KAUTO_HOSTOTGUSB_BIT = KBit4;

const TInt KSetupPacketSize = 8;

const TInt KMaxPayload = 0x400;

const TInt KUsbDfcPriority = 45;

const TUint KUSBBase = Omap3530HwBase::TVirtual<0x480AB000>::Value;

// USB registers - need the slave clock enabled to access most of these

const TUint KFADDR_REG = 0x0;

	const TUint KADDRESS_MSK = 0x7F;

const TUint KPOWER_REG  = 0x1;

	const TUint KSOFTCONNECT_BIT = KBit6;

	const TUint KSUSPENDM_BIT = KBit1;

	const TUint KRESUME_BIT = KBit2;

	const TUint KHSEN_BIT = KBit5;

//	const TUint KRESET_BIT = KBit3;

const TUint K_INTRTX_REG =0x2;

const TUint K_INTRRX_REG =0x4;

const TUint K_INTRTXE_REG =0x6;

const TUint K_INTRRXE_REG =0x8;

const TUint K_INTRUSB_REG = 0xA;

const TUint K_INTRUSBE_REG = 0xB;

	const TUint K_INT_RESET = KBit2;

	const TUint K_INT_RESUME = KBit1;

	const TUint K_INT_SUSPEND = KBit0;

//const TUint K_DEVCTRL_REG = 0x60;

const TUint K_FIFO0_REG = 0x20;

const TUint K_FIFO_OFFSET = 0x4;

const TUint K_COUNT0_REG = 0x18;

const TUint K_RXCOUNT_REG = 0x18;

const TUint K_CONFIGDATA_REG = 0x1F;

	const TUint K_MPRXE = KBit7;

	const TUint K_MPTXE = KBit6;

	const TUint K_DYNFIFO = KBit2;

	const TUint K_SOFTCONNECT = KBit1;

const TUint K_INDEX_REG = 0xE;

const TUint K_PERI_CSR0_REG = 0x12;

	const TUint K_EP0_FLUSHFIFO = KBit8;

	const TUint K_EP0_SERV_SETUPEND = KBit7;

	const TUint K_EP0_SERV_RXPKTRDY = KBit6;

	const TUint K_EP0_SETUPEND = KBit4;

	const TUint K_EP0_SENDSTALL = KBit5;

	const TUint K_EP0_DATAEND = KBit3;

	const TUint K_EP0_SENTSTALL = KBit2;

	const TUint K_EP0_TXPKTRDY = KBit1;

	const TUint K_EP0_RXPKTRDY = KBit0;

const TUint K_TXMAXP_REG = 0x10;

const TUint K_RXMAXP_REG = 0x14;

const TUint K_PERI_TXCSR_REG =  0x12;

	const TUint K_TX_ISO = KBit14;

	const TUint K_TX_DMAEN = KBit12;

	const TUint K_TX_DMAMODE = KBit10;

	const TUint K_TX_CLRDATATOG = KBit6;

	const TUint K_TX_SENTSTALL = KBit5;

	const TUint K_TX_SENDSTALL = KBit4;

	const TUint K_TX_FLUSHFIFO = KBit3;

	const TUint K_TX_UNDERRUN = KBit2;

//	const TUint K_TX_FIFONOTEMPTY = KBit1;

	const TUint K_TX_TXPKTRDY = KBit0;

const TUint K_PERI_RXCSR_REG =  0x16;

	const TUint K_RX_ISO = KBit14;

	const TUint K_RX_DMAEN = KBit13;

	const TUint K_RX_DISNYET = KBit12;

	const TUint K_RX_CLRDATATOG = KBit7;

	const TUint K_RX_SENTSTALL = KBit6;

	const TUint K_RX_SENDSTALL = KBit5;

	const TUint K_RX_FLUSHFIFO = KBit4;

	const TUint K_RX_OVERRUN = KBit2;

	const TUint K_RX_RXPKTRDY = KBit0;	

const TUint K_TXFIFOSZ_REG = 0x62;

const TUint K_RXFIFOSZ_REG = 0x63;

const TUint K_TXFIFOADDR_REG = 0x64;

const TUint K_RXFIFOADDR_REG = 0x66;

const TUint K_OTG_SYSCONFIG_REG = 0x404;

	const TUint K_ENABLEWAKEUP = KBit2;

//const TUint K_OTG_SYSSTATUS_REG = 0x408;

// End of Register definitions

// Define USB_SUPPORTS_PREMATURE_STATUS_IN to enable proper handling of a premature STATUS_IN stage, i.e. a

// situation where the host sends less data than first announced and instead of more data (OUT) will send an

// IN token to start the status stage. What we do in order to implement this here is to prime the TX fifo with

// a ZLP immediately when we find out that we're dealing with a DATA_OUT request. This way, as soon as the

// premature IN token is received, we complete the transaction by sending off the ZLP. If we don't prime the

// TX fifo then there is no way for us to recognise a premature status because the IN token itself doesn't

// raise an interrupt. We would simply wait forever for more data, or rather we would time out and the host

// would move on and send the next Setup packet.

// The reason why we would not want to implement the proper behaviour is this: After having primed the TX fifo

// with a ZLP, it is impossible for a user to reject such a (class/vendor specific) Setup request, basically

// because the successful status stage happens automatically. At the time the user has received and decoded

// the Setup request there's for her no way to stall Ep0 in order to show to the host that this Setup packet

// is invalid or inappropriate or whatever, because she cannot prevent the status stage from happening.

// (All this is strictly true only if the amount of data in the data stage is less than or equal to Ep0's max

//	packet size. However this is almost always the case.)

//#define USB_SUPPORTS_PREMATURE_STATUS_IN

static const TUsbcEndpointCaps DeviceEndpoints[KUsbTotalEndpoints] =

	{

	//                                                      Hardware #    iEndpoints index

	{KEp0MaxPktSzMask,	(KUsbEpTypeControl	   | KUsbEpDirOut)}, //	 0 -  0

	{KEp0MaxPktSzMask,	(KUsbEpTypeControl	   | KUsbEpDirIn )}, //	 0 -  1

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 1 -  2

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 2 -  3

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 3 -  4

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 4 -  5

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 5 -  6

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 6 -  7

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 7 -  8

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 8 -  9

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 9 -  10

	{KEp0MaxPktSzMask,	(KUsbEpTypeBulk	   	   | KUsbEpDirIn )}, //	 10 -  11

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 11 -  12

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 12 -  13

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 13 -  14

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 14 -  15

	// Disabled due to limited FIFO space

	/*{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 15 -  16

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 16 -  17

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 17 -  18

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 18 -  19

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 19 -  20

	{KEp0MaxPktSzMask,	(KUsbEpTypeBulk	   	   | KUsbEpDirIn )}, //	 20 -  21

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 21 -  22

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 22 -  23

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 23 -  24

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 24 -  25

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 25 -  26

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 26 -  27

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 27 -  28

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 28 -  29

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 29 -  30

	{KIntMaxPktSzMask,	(KUsbEpTypeInterrupt   | KUsbEpDirIn )}  //	 30-   31*/

	};

// --- TEndpoint --------------------------------------------------------------

TEndpoint::TEndpoint()

//

// Constructor

//

	: iRxBuf(NULL), iReceived(0), iLength(0), iZlpReqd(EFalse), iNoBuffer(EFalse), iDisabled(EFalse),

	  iPackets(0), iLastError(KErrNone), iRequest(NULL), iRxTimer(RxTimerCallback, this),

	  iRxTimerSet(EFalse), iRxMoreDataRcvd(EFalse), iPacketIndex(NULL), iPacketSize(NULL)

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TEndpoint::TEndpoint"));

	}

void TEndpoint::RxTimerCallback(TAny* aPtr)

//

// (This function is static.)

//

	{

	TEndpoint* const ep = static_cast<TEndpoint*>(aPtr);

	if (!ep)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: !ep"));

		}

	else if (!ep->iRxTimerSet)

		{

		// Timer 'stop' substitute (instead of stopping it,

		// we just let it expire after clearing iRxTimerSet)

		__KTRACE_OPT(KUSB, Kern::Printf("!ep->iRxTimerSet - returning"));

		}

	else if (!ep->iRxBuf)

		{

		// Request already completed

		__KTRACE_OPT(KUSB, Kern::Printf("!ep->iRxBuf - returning"));

		}

	else if (ep->iRxMoreDataRcvd)

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > rx timer cb: not yet completing..."));

		ep->iRxMoreDataRcvd = EFalse;

		ep->iRxTimer.Again(KRxTimerTimeout);

		}

	else

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > rx timer cb: completing now..."));

		*ep->iPacketSize = ep->iReceived;

		ep->iController->RxComplete(ep);

		}

	}

// --- DOmap3530Usbcc public ---------------------------------------------------

DOmap3530Usbcc::DOmap3530Usbcc()

//

// Constructor.

//

	: iCableConnected(ETrue), iBusIsPowered(EFalse),

	  iInitialized(EFalse), iUsbClientConnectorCallback(UsbClientConnectorCallback),

	  iAssp( static_cast<Omap3530Assp*>( Arch::TheAsic() ) ),

	  iEp0Configured(EFalse), iSuspendDfc(SuspendDfcFn, this, 7),

	  iResumeDfc(ResumeDfcFn, this, 7), iResetDfc(ResetDfcFn, this, 7)

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::DOmap3530Usbcc"));

	TInt r = Kern::DfcQCreate(iDfcQueue, KUsbDfcPriority, &KDfcName);

	iSuspendDfc.SetDfcQ(iDfcQueue);	

	iResetDfc.SetDfcQ(iDfcQueue);

	iResumeDfc.SetDfcQ(iDfcQueue);

	iSoftwareConnectable = iAssp->UsbSoftwareConnectable();

	iCableDetectable = iAssp->UsbClientConnectorDetectable();

	if (iCableDetectable)

		{

		// Register our callback for detecting USB cable insertion/removal.

		// We ignore the error code: if the registration fails, we just won't get any events.

		// (Which of course is bad enough...)

		(void) iAssp->RegisterUsbClientConnectorCallback(iUsbClientConnectorCallback, this);

		// Call the callback straight away so we get the proper PIL state from the beginning.

		(void) UsbClientConnectorCallback(this);

		}

	for (TInt i = 0; i < KUsbTotalEndpoints; i++)

		{

		iEndpoints[i].iController = this;

		}

	__KTRACE_OPT(KUSB, Kern::Printf("-DOmap3530Usbcc::DOmap3530Usbcc"));

	}

TInt DOmap3530Usbcc::Construct()

//

// Construct.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::Construct"));

	iPhy = MOmap3530UsbPhy::New();

	if( !iPhy )

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Failed to get pointer to USB PHY"));

		return KErrNoMemory;

		}

	//TInt r = PowerResourceManager::RegisterClient( iPrmClientId, KDfcName );

	//if( r != KErrNone )

	//	{

	//	__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Failed to connect to PRM"));

	//	return r;

	//	}

	TUsbcDeviceDescriptor* DeviceDesc = TUsbcDeviceDescriptor::New(

		0x00,												// aDeviceClass

		0x00,												// aDeviceSubClass

		0x00,												// aDeviceProtocol

		KEp0MaxPktSz,										// aMaxPacketSize0

		KUsbVendorId,										// aVendorId

		KUsbProductId,										// aProductId

		KUsbDevRelease,										// aDeviceRelease

		1);													// aNumConfigurations

	if (!DeviceDesc)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev desc failed."));

		return KErrGeneral;

		}

	TUsbcConfigDescriptor* ConfigDesc = TUsbcConfigDescriptor::New(

		1,													// aConfigurationValue

		ETrue,												// aSelfPowered (see 12.4.2 "Bus-Powered Devices")

		ETrue,												// aRemoteWakeup

		0);													// aMaxPower (mA)

	if (!ConfigDesc)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config desc failed."));

		return KErrGeneral;

		}

	TUsbcLangIdDescriptor* StringDescLang = TUsbcLangIdDescriptor::New(KUsbLangId);

	if (!StringDescLang)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for lang id $ desc failed."));

		return KErrGeneral;

		}

	// ('sizeof(x) - 2' because 'wchar_t KStringXyz' created a wide string that ends in '\0\0'.)

	TUsbcStringDescriptor* StringDescManu =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringManufacturer)),

									   sizeof(KStringManufacturer) - 2, sizeof(KStringManufacturer) - 2));

	if (!StringDescManu)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for manufacturer $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescProd =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringProduct)),

									   sizeof(KStringProduct) - 2, sizeof(KStringProduct) - 2));

	if (!StringDescProd)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for product $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescSer =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringSerialNo)),

									   sizeof(KStringSerialNo) - 2, sizeof(KStringSerialNo) - 2));

	if (!StringDescSer)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for serial no $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescConf =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringConfig)),

									   sizeof(KStringConfig) - 2, sizeof(KStringConfig) - 2));

	if (!StringDescConf)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config $ desc failed."));

		return KErrGeneral;

		}

	const TBool b =	InitialiseBaseClass(DeviceDesc,

										ConfigDesc,

										StringDescLang,

										StringDescManu,

										StringDescProd,

										StringDescSer,

										StringDescConf);

	if (!b)

		{ 

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: UsbClientController::InitialiseBaseClass failed."));

		return KErrGeneral;

		}

	return KErrNone;

	}

DOmap3530Usbcc::~DOmap3530Usbcc()

//

// Destructor.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::~DOmap3530Usbcc"));

	// Unregister our callback for detecting USB cable insertion/removal

	if (iCableDetectable)

		{

		iAssp->UnregisterUsbClientConnectorCallback();

		}

	if (iInitialized)

		{

		// (The explicit scope operator is used against Lint warning #1506.)

		DOmap3530Usbcc::StopUdc();

		}

	}

TBool DOmap3530Usbcc::DeviceStateChangeCaps() const

//

// Returns capability of hardware to accurately track the device state (Chapter 9 state).

//

	{

	return EFalse;

	}

TInt DOmap3530Usbcc::SignalRemoteWakeup()

//

// Forces the UDC into a non-idle state to perform a remote wakeup operation.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::SignalRemoteWakeup"));

	Kern::Printf("DOmap3530Usbcc::SignalRemoteWakeup");

	// Resume signal

	TInt sysconfig = AsspRegister::Read32(KUSBBase+K_OTG_SYSCONFIG_REG );

	if(sysconfig&K_ENABLEWAKEUP && iRmWakeupStatus_Enabled)

		{

		AsspRegister::Modify8(KUSBBase+KPOWER_REG, KClearNone , KRESUME_BIT);

		Kern::NanoWait(10000000); // Wait 10ms - Use a callback instead!

		AsspRegister::Modify8(KUSBBase+KPOWER_REG, KRESUME_BIT, KSetNone);

		}

	return KErrNone;

	}

void DOmap3530Usbcc::DumpRegisters()

//

// Dumps the contents of a number of UDC registers to the screen (using Kern::Printf()).

// Rarely used, but might prove helpful when needed.

//

	{

	Kern::Printf("DOmap3530Usbcc::DumpRegisters:");

	}

TDfcQue* DOmap3530Usbcc::DfcQ(TInt /* aUnit */)

//

// Returns a pointer to the kernel DFC queue to be used buy the USB LDD.

//

	{

	return iDfcQueue;

	}

// --- DOmap3530Usbcc private virtual ------------------------------------------

TInt DOmap3530Usbcc::SetDeviceAddress(TInt aAddress)

//

// Sets the PIL-provided device address manually (if possible - otherwise do nothing).

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::SetDeviceAddress: %d", aAddress));

	AsspRegister::Write8(KUSBBase+KFADDR_REG, aAddress & KADDRESS_MSK);

	if (aAddress || GetDeviceStatus()==EUsbcDeviceStateAddress)

		{

		// Address can be zero.

		MoveToAddressState();

		}

	return KErrNone;

	}

TInt DOmap3530Usbcc::ConfigureEndpoint(TInt aRealEndpoint, const TUsbcEndpointInfo& aEndpointInfo)

//

// Prepares (enables) an endpoint (incl. Ep0) for data transmission or reception.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::ConfigureEndpoint(%d)", aRealEndpoint));

	const TInt n = ArrayIdx2TemplateEp(aRealEndpoint);

	if (n < 0)

		return KErrArgument;

	TEndpoint* const ep = &iEndpoints[aRealEndpoint];

	if (ep->iDisabled == EFalse)

		{

		EnableEndpointInterrupt(aRealEndpoint);

		if(n!=0)

			{

			AsspRegister::Write8(KUSBBase+K_INDEX_REG, (TInt)(aRealEndpoint/2));

			if(aRealEndpoint%2==0)

				{

				AsspRegister::Write16(KUSBBase+K_PERI_RXCSR_REG, K_RX_CLRDATATOG | K_RX_DISNYET);

				}

			else

				{			

				AsspRegister::Write16(KUSBBase+K_PERI_TXCSR_REG, K_TX_CLRDATATOG);

				}

			}

		else

			{

			AsspRegister::Write8(KUSBBase+K_INDEX_REG, 0x0);

			AsspRegister::Write16(KUSBBase+K_PERI_CSR0_REG, K_EP0_FLUSHFIFO); // FlushFifo;

			}

		}

	ep->iNoBuffer = EFalse;

	if (n == 0)

		iEp0Configured = ETrue;

	return KErrNone;

	}

TInt DOmap3530Usbcc::DeConfigureEndpoint(TInt aRealEndpoint)

//

// Disables an endpoint (incl. Ep0).

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DOmap3530Usbcc::DeConfigureEndpoint(%d)", aRealEndpoint));

	const TInt n = ArrayIdx2TemplateEp(aRealEndpoint);

	if (n < 0)

		return KErrArgument;

	DisableEndpointInterrupt(aRealEndpoint);

	if (n == 0)

		{

		iEp0Configured = EFalse;

		AsspRegister::Write8(KUSBBase+K_INDEX_REG, 0);

		AsspRegister::Modify16(KUSBBase+K_PERI_CSR0_REG, KClearNone, K_EP0_FLUSHFIFO);