Model A(+) support is working

FIXED: Handling for USB no-split interrupt transactions was incomplete
"class" DWHCIFrameSchedulerNoSplit added
Model check removed from DWHCIDeviceInitialize()

FIXED: URB status was not properly set on failure

USB reset recovery time increased to 20ms (an USB stick wasn't detected)

Author: maccasoft

uspi/Makefile

@@ -39,6 +39,7 @@ OBJS = \
 	lib/devicenameservice.o \
 	lib/dwhcidevice.o \
 	lib/dwhciframeschednper.o \
+	lib/dwhciframeschednsplit.o \
 	lib/dwhciframeschedper.o \
 	lib/dwhciregister.o \
 	lib/dwhcirootport.o \

uspi/README.md

@@ -6,7 +6,7 @@ USPi
 Overview
 --------
 
-USPi is a bare metal USB driver for the Raspberry Pi written in C. It was ported from the Circle USB library. Using C allows it to be used from bare metal C code for the Raspberry Pi. Like the Circle USB library it supports control (synchronous), bulk and interrupt (synchronous and asynchronous) transfers. Function drivers are available for USB keyboards, mass storage devices (e.g. USB flash devices) and the on-board Ethernet controller. USPi is only running on the Raspberry Pi model B and B+ at the moment.
+USPi is a bare metal USB driver for the Raspberry Pi written in C. It was ported from the Circle USB library. Using C allows it to be used from bare metal C code for the Raspberry Pi. Like the Circle USB library it supports control (synchronous), bulk and interrupt (synchronous and asynchronous) transfers. Function drivers are available for USB keyboards, mass storage devices (e.g. USB flash devices) and the on-board Ethernet controller. USPi should run on all existing Raspberry Pi models.
 
 USPi was "mechanically" ported from the Circle USB library which is written in C++. That's why the source code may look a little bit strange. But it was faster to do so.
 

uspi/include/uspi/dwhciframeschednsplit.h

@@ -0,0 +1,46 @@
+//
+// dwhciframeschednsplit.h
+//
+// USPi - An USB driver for Raspberry Pi written in C
+// Copyright (C) 2014  R. Stange <[email protected]>
+// 
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+#ifndef _uspi_dwhciframeschednsplit_h
+#define _uspi_dwhciframeschednsplit_h
+
+#include <uspi/dwhciframescheduler.h>
+#include <uspi/types.h>
+
+typedef struct TDWHCIFrameSchedulerNoSplit
+{
+	TDWHCIFrameScheduler m_DWHCIFrameScheduler;
+	
+	boolean m_bIsPeriodic;
+	unsigned m_nNextFrame;
+}
+TDWHCIFrameSchedulerNoSplit;
+
+void DWHCIFrameSchedulerNoSplit (TDWHCIFrameSchedulerNoSplit *pThis, boolean bIsPeriodic);
+void _DWHCIFrameSchedulerNoSplit (TDWHCIFrameScheduler *pBase);
+
+void DWHCIFrameSchedulerNoSplitStartSplit (TDWHCIFrameScheduler *pBase);
+boolean DWHCIFrameSchedulerNoSplitCompleteSplit (TDWHCIFrameScheduler *pBase);
+void DWHCIFrameSchedulerNoSplitTransactionComplete (TDWHCIFrameScheduler *pBase, u32 nStatus);
+
+void DWHCIFrameSchedulerNoSplitWaitForFrame (TDWHCIFrameScheduler *pBase);
+
+boolean DWHCIFrameSchedulerNoSplitIsOddFrame (TDWHCIFrameScheduler *pBase);
+
+#endif

uspi/lib/dwhcidevice.c

@@ -113,22 +113,6 @@ boolean DWHCIDeviceInitialize (TDWHCIDevice *pThis)
 {
 	assert (pThis != 0);
 
-	// Check model to prevent non-high-speed devices from over-clocking
-	int nRevision = GetBoardRevision ();
-	if (nRevision < 0)
-	{
-		LogWrite (FromDWHCI, LOG_ERROR, "Cannot get board revision");
-		return FALSE;
-	}
-
-	nRevision &= 0xFFFF;
-	if (   (7 <= nRevision && nRevision <= 9)
-	    || nRevision >= 0x11)
-	{
-		LogWrite (FromDWHCI, LOG_ERROR, "Model is not supported");
-		return FALSE;
-	}
-
 	DataMemBarrier ();
 
 	TDWHCIRegister VendorId;
@@ -552,7 +536,8 @@ boolean DWHCIDeviceEnableRootPort (TDWHCIDevice *pThis)
 	DWHCIRegisterAnd (&HostPort, ~DWHCI_HOST_PORT_RESET);
 	DWHCIRegisterWrite (&HostPort);
 
-	MsDelay (10);			// see USB 2.0 spec (tRSTRCY)
+	// normally 10ms, seems to be too short for some devices
+	MsDelay (20);			// see USB 2.0 spec (tRSTRCY)
 
 	_DWHCIRegister (&HostPort);
 
@@ -996,7 +981,7 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 
 		assert (   !DWHCITransferStageDataIsPeriodic (pStageData)
 			||    DWHCI_HOST_CHAN_XFER_SIZ_PID (DWHCIRegisterGet (&TransferSize))
-				!= DWHCI_HOST_CHAN_XFER_SIZ_PID_MDATA);
+			   != DWHCI_HOST_CHAN_XFER_SIZ_PID_MDATA);
 
 		DWHCITransferStageDataTransactionComplete (pStageData, DWHCIRegisterRead (&ChanInterrupt),
 			DWHCI_HOST_CHAN_XFER_SIZ_PACKETS (DWHCIRegisterGet (&TransferSize)),
@@ -1016,12 +1001,23 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 	switch (DWHCITransferStageDataGetState (pStageData))
 	{
 	case StageStateNoSplitTransfer:
-		DWHCIDeviceDisableChannelInterrupt (pThis, nChannel);
-	
 		nStatus = DWHCITransferStageDataGetTransactionStatus (pStageData);
 		if (nStatus & DWHCI_HOST_CHAN_INT_ERROR_MASK)
 		{
 			LogWrite (FromDWHCI, LOG_ERROR, "Transaction failed (status 0x%X)", nStatus);
+
+			USBRequestSetStatus (pURB, 0);
+		}
+		else if (   (nStatus & (DWHCI_HOST_CHAN_INT_NAK | DWHCI_HOST_CHAN_INT_NYET))
+			 && DWHCITransferStageDataIsPeriodic (pStageData))
+		{
+			DWHCITransferStageDataSetState (pStageData, StageStatePeriodicDelay);
+
+			unsigned nInterval = USBEndpointGetInterval (USBRequestGetEndpoint (pURB));
+
+			StartKernelTimer (MSEC2HZ (nInterval), DWHCIDeviceTimerHandler, pStageData, pThis);
+
+			break;
 		}
 		else
 		{
@@ -1033,6 +1029,8 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 			USBRequestSetStatus (pURB, 1);
 		}
 
+		DWHCIDeviceDisableChannelInterrupt (pThis, nChannel);
+	
 		_DWHCITransferStageData (pStageData);
 		free (pStageData);
 		pThis->m_pStageData[nChannel] = 0;
@@ -1050,6 +1048,8 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 		{
 			LogWrite (FromDWHCI, LOG_ERROR, "Transaction failed (status 0x%X)", nStatus);
 
+			USBRequestSetStatus (pURB, 0);
+
 			DWHCIDeviceDisableChannelInterrupt (pThis, nChannel);
 
 			_DWHCITransferStageData (pStageData);
@@ -1081,6 +1081,8 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 		{
 			LogWrite (FromDWHCI, LOG_ERROR, "Transaction failed (status 0x%X)", nStatus);
 
+			USBRequestSetStatus (pURB, 0);
+
 			DWHCIDeviceDisableChannelInterrupt (pThis, nChannel);
 
 			_DWHCITransferStageData (pStageData);
@@ -1106,6 +1108,8 @@ void DWHCIDeviceChannelInterruptHandler (TDWHCIDevice *pThis, unsigned nChannel)
 		{
 			if (!DWHCITransferStageDataBeginSplitCycle (pStageData))
 			{
+				USBRequestSetStatus (pURB, 0);
+
 				DWHCIDeviceDisableChannelInterrupt (pThis, nChannel);
 
 				_DWHCITransferStageData (pStageData);
@@ -1234,13 +1238,21 @@ void DWHCIDeviceTimerHandler (unsigned hTimer, void *pParam, void *pContext)
 
 	assert (pStageData != 0);
 	assert (DWHCITransferStageDataGetState (pStageData) == StageStatePeriodicDelay);
-	DWHCITransferStageDataSetState (pStageData, StageStateStartSplit);
-	
-	DWHCITransferStageDataSetSplitComplete (pStageData, FALSE);
-	TDWHCIFrameScheduler *pFrameScheduler =
-		DWHCITransferStageDataGetFrameScheduler (pStageData);
-	assert (pFrameScheduler != 0);
-	pFrameScheduler->StartSplit (pFrameScheduler);
+
+	if (DWHCITransferStageDataIsSplit (pStageData))
+	{
+		DWHCITransferStageDataSetState (pStageData, StageStateStartSplit);
+		
+		DWHCITransferStageDataSetSplitComplete (pStageData, FALSE);
+		TDWHCIFrameScheduler *pFrameScheduler =
+			DWHCITransferStageDataGetFrameScheduler (pStageData);
+		assert (pFrameScheduler != 0);
+		pFrameScheduler->StartSplit (pFrameScheduler);
+	}
+	else
+	{
+		DWHCITransferStageDataSetState (pStageData, StageStateNoSplitTransfer);
+	}
 
 	DWHCIDeviceStartTransaction (pThis, pStageData);
 
@@ -1302,9 +1314,9 @@ boolean DWHCIDeviceWaitForBit (TDWHCIDevice *pThis, TDWHCIRegister *pRegister, u
 
 		if (--nMsTimeout == 0)
 		{
-			LogWrite (FromDWHCI, LOG_WARNING, "Timeout");
+			//LogWrite (FromDWHCI, LOG_WARNING, "Timeout");
 #ifndef NDEBUG
-			DWHCIRegisterDump (pRegister);
+			//DWHCIRegisterDump (pRegister);
 #endif
 			return FALSE;
 		}

uspi/lib/dwhciframeschednsplit.c

@@ -0,0 +1,91 @@
+//
+// dwhciframeschednsplit.c
+//
+// USPi - An USB driver for Raspberry Pi written in C
+// Copyright (C) 2014  R. Stange <[email protected]>
+// 
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+#include <uspi/dwhciframeschednsplit.h>
+#include <uspi/dwhciregister.h>
+#include <uspi/assert.h>
+
+#define FRAME_UNSET	(DWHCI_MAX_FRAME_NUMBER+1)
+
+void DWHCIFrameSchedulerNoSplit (TDWHCIFrameSchedulerNoSplit *pThis, boolean bIsPeriodic)
+{
+	assert (pThis != 0);
+
+	TDWHCIFrameScheduler *pBase = (TDWHCIFrameScheduler *) pThis;
+
+	pBase->_DWHCIFrameScheduler = _DWHCIFrameSchedulerNoSplit;
+	pBase->StartSplit = DWHCIFrameSchedulerNoSplitStartSplit;
+	pBase->CompleteSplit = DWHCIFrameSchedulerNoSplitCompleteSplit;
+	pBase->TransactionComplete = DWHCIFrameSchedulerNoSplitTransactionComplete;
+	pBase->WaitForFrame = DWHCIFrameSchedulerNoSplitWaitForFrame;
+	pBase->IsOddFrame = DWHCIFrameSchedulerNoSplitIsOddFrame;
+
+	pThis->m_bIsPeriodic = bIsPeriodic;
+	pThis->m_nNextFrame = FRAME_UNSET;
+
+}
+
+void _DWHCIFrameSchedulerNoSplit (TDWHCIFrameScheduler *pBase)
+{
+}
+
+void DWHCIFrameSchedulerNoSplitStartSplit (TDWHCIFrameScheduler *pBase)
+{
+	assert (0);
+}
+
+boolean DWHCIFrameSchedulerNoSplitCompleteSplit (TDWHCIFrameScheduler *pBase)
+{
+	assert (0);
+	return FALSE;
+}
+
+void DWHCIFrameSchedulerNoSplitTransactionComplete (TDWHCIFrameScheduler *pBase, u32 nStatus)
+{
+	assert (0);
+}
+
+void DWHCIFrameSchedulerNoSplitWaitForFrame (TDWHCIFrameScheduler *pBase)
+{
+	TDWHCIFrameSchedulerNoSplit *pThis = (TDWHCIFrameSchedulerNoSplit *) pBase;
+	assert (pThis != 0);
+
+	TDWHCIRegister FrameNumber;
+	DWHCIRegister (&FrameNumber, DWHCI_HOST_FRM_NUM);
+
+	pThis->m_nNextFrame = (DWHCI_HOST_FRM_NUM_NUMBER (DWHCIRegisterRead (&FrameNumber))+1) & DWHCI_MAX_FRAME_NUMBER;
+
+	if (!pThis->m_bIsPeriodic)
+	{
+		while ((DWHCI_HOST_FRM_NUM_NUMBER (DWHCIRegisterRead (&FrameNumber)) & DWHCI_MAX_FRAME_NUMBER) != pThis->m_nNextFrame)
+		{
+			// do nothing
+		}
+	}
+
+	_DWHCIRegister (&FrameNumber);
+}
+
+boolean DWHCIFrameSchedulerNoSplitIsOddFrame (TDWHCIFrameScheduler *pBase)
+{
+	TDWHCIFrameSchedulerNoSplit *pThis = (TDWHCIFrameSchedulerNoSplit *) pBase;
+	assert (pThis != 0);
+
+	return pThis->m_nNextFrame & 1 ? TRUE : FALSE;
+}

uspi/lib/dwhcixferstagedata.c

@@ -20,6 +20,7 @@
 #include <uspi/dwhcixferstagedata.h>
 #include <uspi/dwhciframeschedper.h>
 #include <uspi/dwhciframeschednper.h>
+#include <uspi/dwhciframeschednsplit.h>
 #include <uspi/dwhci.h>
 #include <uspios.h>
 #include <uspi/assert.h>
@@ -121,6 +122,16 @@ void DWHCITransferStageData (TDWHCITransferStageData *pThis, unsigned nChannel,
 
 		assert (pThis->m_pFrameScheduler != 0);
 	}
+	else
+	{
+		if (   USBDeviceGetHubAddress (pThis->m_pDevice) == 0
+		    && pThis->m_Speed != USBSpeedHigh)
+		{
+			pThis->m_pFrameScheduler = (TDWHCIFrameScheduler *) malloc (sizeof (TDWHCIFrameSchedulerNoSplit));
+			DWHCIFrameSchedulerNoSplit ((TDWHCIFrameSchedulerNoSplit *) pThis->m_pFrameScheduler, DWHCITransferStageDataIsPeriodic (pThis));
+			assert (pThis->m_pFrameScheduler != 0);
+		}
+	}
 }
 
 void _DWHCITransferStageData (TDWHCITransferStageData *pThis)
@@ -406,7 +417,8 @@ u8 DWHCITransferStageDataGetHubPortAddress (TDWHCITransferStageData *pThis)
 u8 DWHCITransferStageDataGetSplitPosition (TDWHCITransferStageData *pThis)
 {
 	assert (pThis != 0);
-	return DWHCI_HOST_CHAN_SPLIT_CTRL_ALL;		// TODO: may not work in any case
+	assert (pThis->m_nTransferSize <= 188);		// TODO
+	return DWHCI_HOST_CHAN_SPLIT_CTRL_ALL;
 }
 
 u32 DWHCITransferStageDataGetStatusMask (TDWHCITransferStageData *pThis)
@@ -415,7 +427,8 @@ u32 DWHCITransferStageDataGetStatusMask (TDWHCITransferStageData *pThis)
 	u32 nMask =   DWHCI_HOST_CHAN_INT_XFER_COMPLETE
 		    | DWHCI_HOST_CHAN_INT_ERROR_MASK;
 
-	if (pThis->m_bSplitTransaction)
+	if (   pThis->m_bSplitTransaction
+	    || DWHCITransferStageDataIsPeriodic (pThis))
 	{
 		nMask |=   DWHCI_HOST_CHAN_INT_ACK
 			 | DWHCI_HOST_CHAN_INT_NAK