fix:lua层usb虚拟U盘读TF不启动，TF读写超时不准确

update:msc的操作都得队列化放在task里，否则会有冲突
add:usb msc可能会超时，加入重启USB操作

application/src/luat_lib_usbapp.c

@@ -134,7 +134,7 @@ USB U盘设备挂载SDHC，TF卡
 usbapp.udisk_attach_sdhc(0)
 */
 static int l_usb_udisk_attach_sdhc(lua_State* L) {
-    luat_usb_app_vhid_cancel_upload(USB_ID0);
+	luat_usb_udisk_attach_sdhc(USB_ID0);
     return 0;
 }
 
@@ -147,7 +147,7 @@ USB U盘设备去除挂载SDHC，TF卡
 usbapp.udisk_detach_sdhc(0)
 */
 static int l_usb_udisk_detach_sdhc(lua_State* L) {
-    luat_usb_app_vhid_cancel_upload(USB_ID0);
+	luat_usb_udisk_detach_sdhc(USB_ID0);
     return 0;
 }
 #include "rotable.h"

bsp/air105/test/test_usb_device.c

@@ -77,7 +77,7 @@ int32_t prvTest_HIDCB(void *pData, void *pParam)
 void Test_USBStart(void)
 {
 	Core_VUartInit(VIRTUAL_UART0, 0, 1, 0, 0, 0, prvTest_USBCB);
-	Core_VHIDInit(0, prvTest_HIDCB);
+//	Core_VHIDInit(0, prvTest_HIDCB);
 //	Core_VUartSetRxTimeout(VIRTUAL_UART0, 200);
 }
 
@@ -86,16 +86,16 @@ void prvUSB_Test(void *p)
 	SDHC_SPICtrlStruct SDHC;
 	memset(&SDHC, 0, sizeof(SDHC));
 	SDHC.SpiID = SPI_ID0;
-	SDHC.CSPin = GPIOC_13;
+	SDHC.CSPin = GPIOB_13;
 	SDHC.IsSpiDMAMode = 0;
 //	SDHC.NotifyTask = Task_GetCurrent();
 //	SDHC.TaskCB = prvEventCB;
-    SDHC.SDHCReadBlockTo = 5 * CORE_TICK_1MS;
-    SDHC.SDHCWriteBlockTo = 25 * CORE_TICK_1MS;
+    SDHC.SDHCReadBlockTo = 50 * CORE_TICK_1MS;
+    SDHC.SDHCWriteBlockTo = 250 * CORE_TICK_1MS;
     SDHC.IsPrintData = 0;
-    GPIO_Iomux(GPIOC_12,2);
-    GPIO_Iomux(GPIOC_14,2);
-    GPIO_Iomux(GPIOC_15,2);
+    GPIO_Iomux(GPIOB_12,0);
+    GPIO_Iomux(GPIOB_14,0);
+    GPIO_Iomux(GPIOB_15,0);
     GPIO_Config(SDHC.CSPin, 0, 1);
     SPI_MasterInit(SDHC.SpiID, 8, SPI_MODE_0, 400000, NULL, NULL);
 

bsp/common/src/core_usb_app.c

@@ -703,30 +703,6 @@ static int32_t prvCore_MSCCB(void *pData, void *pParam)
 {
 	USB_EndpointDataStruct *pEpData = (USB_EndpointDataStruct *)pData;
 	USB_EndpointDataStruct *pEpDataSave;
-	switch(prvUSBApp.tSCSI.BotState)
-	{
-	case USB_MSC_BOT_STATE_DATA_OUT_TO_DEVICE:
-	case USB_MSC_BOT_STATE_DATA_IN_TO_HOST:
-		goto MSC_RUN_IN_TASK;
-		break;
-	default:
-		if (pEpData->IsToDevice && pEpData->Data)
-		{
-			switch(pEpData->Data[15])
-			{
-			case SCSI_READ10:
-			case SCSI_READ12:
-			case SCSI_READ16:
-				goto MSC_RUN_IN_TASK;
-				break;
-			}
-
-		}
-		break;
-	}
-	USB_MSCHandle(pEpData, &prvUSBApp.tSCSI);
-	return ERROR_NONE;
-MSC_RUN_IN_TASK:
 	pEpDataSave = malloc(sizeof(USB_EndpointDataStruct));
 	memcpy(pEpDataSave, pEpData, sizeof(USB_EndpointDataStruct));
 	if (pEpData->Data && pEpData->Len)
@@ -740,7 +716,6 @@ MSC_RUN_IN_TASK:
 		pEpDataSave->Len = 0;
 	}
 	Task_SendEvent(prvUSBApp.hTaskHandle, USBD_MSC_CB, pEpDataSave, &prvUSBApp.tSCSI, pParam);
-
 	return ERROR_NONE;
 }
 
@@ -1234,6 +1209,18 @@ static void prvCore_USBAppTask(void *pParam)
 			pEpData = (USB_EndpointDataStruct *)Event.Param1;
 //			DBG("%d,%d,%d,%d", pEpData->USB_ID, pEpData->EpIndex, pEpData->IsToDevice, pEpData->Len);
 			USB_MSCHandle(pEpData, Event.Param2);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_IN, 0, 0);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_OUT, 1, 0);
+//			if (prvUSBApp.BlockCmd)
+//			{
+//				prvUSBApp.BlockCmd--;
+//			}
+//			else
+//			{
+//				DBG("!!!");
+//			}
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_IN, 0, 1);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_OUT, 1, 1);
 			free(pEpData->Data);
 			free(Event.Param1);
 			WDT_Feed();
@@ -1258,9 +1245,10 @@ void Core_UDiskAttachSDHC(uint8_t USB_ID, void *pCtrl)
 	memcpy(prvUSBApp.pSDHC, pCtrl, sizeof(SDHC_SPICtrlStruct));
 	prvUSBApp.tSCSI.pSCSIUserFunList = &prvSDHC_SCSIFun;
 	prvUSBApp.tSCSI.pUserData = prvUSBApp.pSDHC;
+	prvUSBApp.tSCSI.ReadTimeout = 500;
 	DBuffer_ReInit(&prvUSBApp.DataBuf, 8 * 1024);
+	prvUSBApp.pSDHC->USBDelayTime = 0;	//如果USB不稳定，可调加大USBDelayTime
 	prvUSBApp.pSDHC->SCSIDataBuf = &prvUSBApp.DataBuf;
-
 }
 
 void Core_UDiskDetachSDHC(uint8_t USB_ID)

bsp/device/include/dev_sdhc_spi.h

@@ -107,6 +107,8 @@ typedef struct
 	uint32_t Size;							//flash的大小KB
 	uint32_t OCR;
 	DBuffer_Struct *SCSIDataBuf;
+	uint32_t PreCurBlock;
+	uint32_t PreEndBlock;
 	uint32_t CurBlock;
 	uint32_t EndBlock;
 	uint16_t WriteWaitCnt;
@@ -122,11 +124,13 @@ typedef struct
 	uint8_t TempData[__SDHC_BLOCK_LEN__ + 8];
 	uint8_t IsPrintData;
 	uint8_t IsMMC;
+	uint8_t USBDelayTime;
 }SDHC_SPICtrlStruct;
 
 
 
 void SDHC_SpiInitCard(void *pSDHC);
+void SDHC_SpiReadCardConfig(void *pSDHC);
 void SDHC_SpiReadCardInfo(void *pSDHC);
 void SDHC_SpiWriteBlocks(void *pSDHC, const uint8_t *Buf, uint32_t StartLBA, uint32_t BlockNums);
 void SDHC_SpiReadBlocks(void *pSDHC, uint8_t *Buf, uint32_t StartLBA, uint32_t BlockNums);

bsp/device/src/dev_sdhc_spi.c

@@ -99,6 +99,10 @@ static int32_t prvSDHC_SCSIInit(uint8_t LUN, void *pUserData)
 static int32_t prvSDHC_SCSIGetCapacity(uint8_t LUN, uint32_t *BlockNum, uint32_t *BlockSize, void *pUserData)
 {
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
+	if (!pSDHC->Info.LogBlockSize || !pSDHC->Info.LogBlockNbr)
+	{
+		SDHC_SpiReadCardConfig(pSDHC);
+	}
 	*BlockSize = pSDHC->Info.LogBlockSize;
 	*BlockNum = pSDHC->Info.LogBlockNbr;
 	return 0;
@@ -121,11 +125,17 @@ static int32_t prvSDHC_SCSIPreRead(uint8_t LUN, uint32_t BlockAddress, uint32_t
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
 	if ((BlockAddress + BlockNums) > pSDHC->Info.LogBlockNbr)
 	{
+		DBG("%u,%u,%u", BlockAddress, BlockNums, pSDHC->Info.LogBlockNbr);
 		return -1;
 	}
 	pSDHC->CurBlock = BlockAddress;
 	pSDHC->EndBlock = BlockAddress + BlockNums;
-
+	if ((pSDHC->PreCurBlock == pSDHC->CurBlock) && pSDHC->PreEndBlock)
+	{
+//		DBG("%u,%u,%u", pSDHC->PreCurBlock, pSDHC->CurBlock, pSDHC->PreEndBlock);
+		pSDHC->CurBlock = pSDHC->PreEndBlock;
+		return 0;
+	}
 	prvSDHC_SCSIReadNext(LUN, pUserData);
 	return 0;
 }
@@ -142,7 +152,10 @@ static int32_t prvSDHC_SCSIRead(uint8_t LUN, uint32_t Len, uint8_t **pOutData, u
 	}
 	DBuffer_SetDataLen(pSDHC->SCSIDataBuf, 0, 1);
 	DBuffer_SwapCache(pSDHC->SCSIDataBuf);
-//	Task_DelayMS(1);
+	if (pSDHC->USBDelayTime)	//不得不降速
+	{
+		Task_DelayMS(pSDHC->USBDelayTime);
+	}
 #else
 	uint32_t ReadBlocks;
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
@@ -168,7 +181,15 @@ static int32_t prvSDHC_SCSIReadNext(uint8_t LUN, void *pUserData)
 #if 1
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
 	uint32_t ReadBlocks;
-	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
+	if (pSDHC->EndBlock <= pSDHC->CurBlock)
+	{
+		ReadBlocks = pSDHC->SCSIDataBuf->MaxLen >> 9;
+		pSDHC->PreCurBlock = pSDHC->EndBlock;
+		SDHC_SpiReadBlocks(pSDHC, DBuffer_GetCache(pSDHC->SCSIDataBuf, 1), pSDHC->PreCurBlock, ReadBlocks);
+		pSDHC->PreEndBlock = pSDHC->PreCurBlock + ReadBlocks;
+		DBuffer_SetDataLen(pSDHC->SCSIDataBuf, pSDHC->SCSIDataBuf->MaxLen, 1);
+		return ERROR_NONE;
+	}
 
 	if ( ((pSDHC->EndBlock - pSDHC->CurBlock) << 9) > pSDHC->SCSIDataBuf->MaxLen)
 	{
@@ -203,7 +224,6 @@ static int32_t prvSDHC_SCSIPreWrite(uint8_t LUN, uint32_t BlockAddress, uint32_t
 static int32_t prvSDHC_SCSIWrite(uint8_t LUN, uint8_t *Data, uint32_t Len, void *pUserData)
 {
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
-	uint32_t WriteBlocks = Len >> 9;
 	if (!SDHC_IsReady(pSDHC)) return -1;
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
 	memcpy(DBuffer_GetCache(pSDHC->SCSIDataBuf, 1) + DBuffer_GetDataLen(pSDHC->SCSIDataBuf, 1), Data, Len);
@@ -218,6 +238,7 @@ static int32_t prvSDHC_SCSIDoWrite(uint8_t LUN, void *pUserData)
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
 	if (WriteBlocks)
 	{
+
 		if (WriteBlocks > (pSDHC->EndBlock - pSDHC->CurBlock))
 		{
 			WriteBlocks = pSDHC->EndBlock - pSDHC->CurBlock;
@@ -448,7 +469,7 @@ static int32_t SDHC_SpiWriteBlockData(SDHC_SPICtrlStruct *Ctrl)
 	uint8_t *pBuf;
 	Ctrl->SPIError = 0;
 	Ctrl->SDHCError = 0;
-	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS;
+	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo;
 	while( (Ctrl->DataBuf.Pos < Ctrl->DataBuf.MaxLen) && (GetSysTick() < OpEndTick) )
 	{
 		Ctrl->TempData[0] = 0xff;
@@ -499,14 +520,14 @@ static int32_t SDHC_SpiWriteBlockData(SDHC_SPICtrlStruct *Ctrl)
 			goto SDHC_SPIWRITEBLOCKDATA_DONE;
 		}
 		Ctrl->DataBuf.Pos++;
-		OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS;
+		OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo;
 	}
 	Result = ERROR_NONE;
 SDHC_SPIWRITEBLOCKDATA_DONE:
 	Ctrl->TempData[0] = 0xfd;
 	SPI_BlockTransfer(Ctrl->SpiID, Ctrl->TempData, Ctrl->TempData, 1);
 
-	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS * Ctrl->DataBuf.MaxLen;
+	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * Ctrl->DataBuf.MaxLen;
 	DoneFlag = 0;
 	while( (GetSysTick() < OpEndTick) && !DoneFlag )
 	{
@@ -522,7 +543,6 @@ SDHC_SPIWRITEBLOCKDATA_DONE:
 			}
 		}
 	}
-
 	SDHC_SpiCS(Ctrl, 0);
 
 	return Result;
@@ -537,8 +557,7 @@ static int32_t SDHC_SpiReadBlockData(SDHC_SPICtrlStruct *Ctrl)
 	uint8_t *pBuf;
 	Ctrl->SPIError = 0;
 	Ctrl->SDHCError = 0;
-
-	OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo * CORE_TICK_1MS;
+	OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo;
 	while( (Ctrl->DataBuf.Pos < Ctrl->DataBuf.MaxLen) && (GetSysTick() < OpEndTick) )
 	{
 
@@ -577,7 +596,7 @@ READ_REST_DATA:
 			goto SDHC_SPIREADBLOCKDATA_DONE;
 		}
 		Ctrl->DataBuf.Pos++;
-		OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo * CORE_TICK_1MS;
+		OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo;
 	}
 	Result = ERROR_NONE;
 
@@ -653,7 +672,6 @@ void SDHC_SpiReadCardConfig(void *pSDHC)
 	SD_CardInfo *pCardInfo = &Ctrl->Info;
 	uint64_t Temp;
 	uint8_t flag_SDHC = (Ctrl->OCR & 0x40000000) >> 30;
-
 	if (Ctrl->Info.CardCapacity) return;
 
 	if (SDHC_SpiCmd(Ctrl, CMD9, 0, 0))
@@ -882,6 +900,7 @@ SDHC_SPIREADBLOCKS_START:
 	if (Ctrl->DataBuf.Pos != Ctrl->DataBuf.MaxLen)
 	{
 		Retry++;
+		DBG("%d", Retry);
 		if (Retry > 3)
 		{
 			Ctrl->SDHCError = 1;
@@ -891,6 +910,7 @@ SDHC_SPIREADBLOCKS_START:
 	}
 	return;
 SDHC_SPIREADBLOCKS_ERROR:
+	DBG("!");
 	Ctrl->IsInitDone = 0;
 	Ctrl->SDHCError = 1;
 	return;
@@ -901,8 +921,8 @@ void *SDHC_SpiCreate(uint8_t SpiID, uint8_t CSPin)
 	SDHC_SPICtrlStruct *Ctrl = zalloc(sizeof(SDHC_SPICtrlStruct));
 	Ctrl->CSPin = CSPin;
 	Ctrl->SpiID = SpiID;
-	Ctrl->SDHCReadBlockTo = 5 * CORE_TICK_1MS;
-	Ctrl->SDHCWriteBlockTo = 25 * CORE_TICK_1MS;
+	Ctrl->SDHCReadBlockTo = 50 * CORE_TICK_1MS;
+	Ctrl->SDHCWriteBlockTo = 250 * CORE_TICK_1MS;
 //	Ctrl->IsPrintData = 1;
 	return Ctrl;
 }
@@ -922,6 +942,7 @@ uint8_t SDHC_IsReady(void *pSDHC)
 	}
 	else
 	{
+		DBG("!");
 		return 0;
 	}
 }

bsp/usb/include/usb_msc.h

@@ -107,9 +107,11 @@ typedef struct
 	MSC_BOT_CSWTypeDef  CSW;
 	Buffer_Struct BotDataBuffer;
 	SCSI_SenseTypeDef Sense;
+	uint64_t TestTime;
 	HANDLE pSCSIUserFunList;
 	Timer_t *ReadTimer;
 	void *pUserData;
+	uint32_t ReadTimeout;
 	uint32_t XferDoneLen;
 	uint32_t LastXferLen;
 	uint32_t XferTotalLen;//实际上需要发送的总数据量，有可能和CBW要求的不一样

bsp/usb/src/core_usb_class_msc_scsi.c

@@ -93,11 +93,9 @@ static void prvUSB_SendCSW(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *
 static int32_t prvUSB_MSCTimeout(void *pData, void *pParam)
 {
 	MSC_SCSICtrlStruct *pMSC = (void *)pParam;
-	DBG("!");
-	pMSC->CSWStatus = USB_MSC_CSW_CMD_FAILED;
-	USB_StackStopDeviceTx(pMSC->USB_ID, pMSC->ToHostEpIndex, 0);
-	USB_StackSetEpStatus(pMSC->USB_ID, pMSC->ToHostEpIndex, 1, USB_EP_STATE_STALL);
-	prvUSB_SendCSW(NULL, pMSC);
+	DBG("bot timeout!, reboot usb");
+	Core_USBDefaultDeviceStart(pMSC->USB_ID);
+
 }
 
 static void prvUSB_SendBotData(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *pMSC)
@@ -169,6 +167,7 @@ void USB_MSCHandle(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *pMSC)
 					goto ERROR_OUT;
 				}
 				pMSC->XferDoneLen = 0;
+//				pMSC->TestTime = GetSysTickUS();
 				prvUSB_SCSIHandleCmd(pEpData, pMSC);
 				if (!pMSC->CBW.dDataLength)
 				{
@@ -311,6 +310,7 @@ static void prvUSB_SCSIHandleToHostData(USB_EndpointDataStruct *pEpData, MSC_SCS
 	pMSC->XferDoneLen += pMSC->LastXferLen;
 	if (pMSC->XferDoneLen >= pMSC->XferTotalLen)
 	{
+//		DBG("%llu", GetSysTickUS() - pMSC->TestTime);
 		prvUSB_SendCSW(pEpData, pMSC);
 		return;
 	}
@@ -650,7 +650,6 @@ static int32_t prvSCSI_Read(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct
 		BlockNums = BytesGetBe32(&pMSC->CBW.CB[10]);
 		break;
 	}
-
     /* case 10 : Ho <> Di */
     if ((pMSC->CBW.bmFlags & 0x80U) != 0x80U)
     {
@@ -692,12 +691,11 @@ static int32_t prvSCSI_Read(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct
 		DBG("!");
 		return -1;
 	}
-
 	pMSC->LastXferLen = TxLen;
 	USB_StackTxEpData(pEpData->USB_ID, pMSC->ToHostEpIndex, TxData, TxLen, TxLen, 0);
 	pMSC->BotState = USB_MSC_BOT_STATE_DATA_IN_TO_HOST;
 	pUserFun->ReadNext(pMSC->CBW.bLUN, pMSC->pUserData);
-	Timer_StartMS(pMSC->ReadTimer, 1000, 0);
+	Timer_StartMS(pMSC->ReadTimer, pMSC->ReadTimeout, 0);
     return 0;
 }