usb-firewall-fork/Upstream/Src/upstream_interface_msc_mock.c

/*
 * upstream_interface_msc_mock.c
 *
 *  Created on: 17/07/2015
 *      Author: Robert Fisk
 *
 *      This file replaces upstream_interface_msc.c to allow operational
 *      testing of Upstream, without Upstream in place and communicating
 *      over SPI. It still attempts to write downstream packets out the SPI port.
 */


#include <upstream_interface_def.h>
#include <upstream_interface_msc.h>
#include <upstream_spi.h>
#include "stm32f4xx_hal.h"


//Stuff we need to save for our callbacks to use:
UpstreamInterfaceMSCCallbackTypeDef 			TestReadyCallback;
UpstreamInterfaceMSCCallbackUintPacketTypeDef	GetCapacityCallback;
UpstreamInterfaceMSCCallbackPacketTypeDef		GetStreamDataCallback;
uint32_t										ByteCount;
UpstreamPacketTypeDef*						ReadStreamPacket;
uint8_t											ReadStreamBusy;


static void UpstreamInterface_TestReadyReplyCallback(UpstreamPacketTypeDef* replyPacket);
static void UpstreamInterface_GetCapacityReplyCallback(UpstreamPacketTypeDef* replyPacket);
static void UpstreamInterface_GetStreamDataPacketCallback(UpstreamPacketTypeDef* replyPacket);
static void UpstreamInterface_BeginWriteReplyCallback(UpstreamPacketTypeDef* replyPacket);



HAL_StatusTypeDef UpstreamInterface_TestReady(UpstreamInterfaceMSCCallbackTypeDef callback)
{
	UpstreamPacketTypeDef* freePacket;
	HAL_StatusTypeDef tempResult;

	TestReadyCallback = callback;
	freePacket = Upstream_GetFreePacketImmediately();

	freePacket->Length = UPSTREAM_PACKET_HEADER_LEN;
	freePacket->CommandClass = COMMAND_CLASS_MASS_STORAGE;
	freePacket->Command = COMMAND_MSC_TEST_UNIT_READY;
	tempResult = Upstream_SendPacket(freePacket);
	if (tempResult != HAL_OK)
	{
		return tempResult;
	}
	//return Upstream_GetPacket(UpstreamInterface_TestReadyReplyCallback);
	return Upstream_GetFreePacket(UpstreamInterface_TestReadyReplyCallback);
}

void UpstreamInterface_TestReadyReplyCallback(UpstreamPacketTypeDef* replyPacket)
{
//	if ((replyPacket->Length != (UPSTREAM_PACKET_HEADER_LEN + 1)) ||
//		(replyPacket->CommandClass & COMMAND_CLASS_DATA_FLAG) ||
//		(replyPacket->Data[0] != HAL_OK))
//	{
//		Upstream_ReleasePacket(replyPacket);
//		TestReadyCallback(HAL_ERROR);
//		return;
//	}

		Upstream_ReleasePacket(replyPacket);
		TestReadyCallback(HAL_OK);
}



HAL_StatusTypeDef UpstreamInterface_GetCapacity(UpstreamInterfaceMSCCallbackUintPacketTypeDef callback)
{
	UpstreamPacketTypeDef* freePacket;
	HAL_StatusTypeDef tempResult;

	GetCapacityCallback = callback;
	freePacket = Upstream_GetFreePacketImmediately();

	freePacket->Length = UPSTREAM_PACKET_HEADER_LEN;
	freePacket->CommandClass = COMMAND_CLASS_MASS_STORAGE;
	freePacket->Command = COMMAND_MSC_GET_CAPACITY;
	tempResult = Upstream_SendPacket(freePacket);
	if (tempResult != HAL_OK)
	{
		return tempResult;
	}
	//return Upstream_GetPacket(UpstreamInterface_GetCapacityReplyCallback);
	return Upstream_GetFreePacket(UpstreamInterface_GetCapacityReplyCallback);
}

void UpstreamInterface_GetCapacityReplyCallback(UpstreamPacketTypeDef* replyPacket)
{
	uint32_t uint[2];

//	if ((replyPacket->Length != (UPSTREAM_PACKET_HEADER_LEN + 8) ||
//	    (replyPacket->CommandClass & COMMAND_CLASS_DATA_FLAG)))
//	{
//		GetCapacityCallback(HAL_ERROR, NULL, NULL);
//	}

	*(uint32_t*)&(replyPacket->Data[0]) = 262144;		//* 512B = 128MB
	*(uint32_t*)&(replyPacket->Data[4]) = 512;

	uint[0] = *(uint32_t*)&(replyPacket->Data[0]);
	uint[1] = *(uint32_t*)&(replyPacket->Data[4]);
	GetCapacityCallback(HAL_OK, uint, replyPacket);		//usb_msc_scsi will use this packet, so don't release now
}



HAL_StatusTypeDef UpstreamInterface_BeginRead(UpstreamInterfaceMSCCallbackTypeDef callback,
												uint64_t readBlockStart,
												uint32_t readBlockCount,
												uint32_t readByteCount)
{
	UpstreamPacketTypeDef* freePacket;
	HAL_StatusTypeDef tempResult;

	ReadStreamPacket = NULL;			//Prepare for GetStreamDataPacket's use
	ReadStreamBusy = 0;

	TestReadyCallback = callback;
	ByteCount = readByteCount;
	freePacket = Upstream_GetFreePacketImmediately();

	freePacket->Length = UPSTREAM_PACKET_HEADER_LEN + (4 * 3);
	freePacket->CommandClass = COMMAND_CLASS_MASS_STORAGE;
	freePacket->Command = COMMAND_MSC_BEGIN_READ;
	*(uint64_t*)&(freePacket->Data[0]) = readBlockStart;
	*(uint32_t*)&(freePacket->Data[8]) = readBlockCount;

	tempResult = Upstream_SendPacket(freePacket);
	if (tempResult != HAL_OK)
	{
		TestReadyCallback(tempResult);
	}
	//return Upstream_GetPacket(UpstreamInterface_TestReadyReplyCallback);	//Re-use TestReadyReplyCallback because it does exactly what we want!
	return Upstream_GetFreePacket(UpstreamInterface_TestReadyReplyCallback);
}



HAL_StatusTypeDef UpstreamInterface_GetStreamDataPacket(UpstreamInterfaceMSCCallbackPacketTypeDef callback)
{
	GetStreamDataCallback = callback;

	if (ReadStreamBusy != 0)
	{
		return HAL_OK;
	}
	ReadStreamBusy = 1;

	if (ReadStreamPacket && GetStreamDataCallback)		//Do we have a stored packet and an address to send it?
	{
		UpstreamInterface_GetStreamDataPacketCallback(ReadStreamPacket);	//Send it now!
		ReadStreamPacket = NULL;
		return HAL_OK;				//Our callback will call us again, so we don't need to get a packet in this case.
	}
	//return Upstream_GetPacket(UpstreamInterface_GetStreamDataPacketCallback);
	return Upstream_GetFreePacket(UpstreamInterface_GetStreamDataPacketCallback);
}

void UpstreamInterface_GetStreamDataPacketCallback(UpstreamPacketTypeDef* replyPacket)
{
	uint16_t dataLength;

	ReadStreamBusy = 0;
	if (GetStreamDataCallback == NULL)
	{
		ReadStreamPacket = replyPacket;		//We used up our callback already, so save this one for later.
		return;
	}

//	if (((replyPacket->CommandClass & COMMAND_CLASS_DATA_FLAG) == 0) ||		//Any 'command' reply (as opposed to 'data' reply) is an automatic fail here
//		 (replyPacket->Length <= UPSTREAM_PACKET_HEADER_LEN) ||			//Should be at least one data byte in the reply.
//		 (replyPacket->Length > ByteCount))
//	{
//		GetStreamDataCallback(HAL_ERROR, NULL);
//		return;
//	}

	replyPacket->Length = MIN((ByteCount + UPSTREAM_PACKET_HEADER_LEN), (MSC_MEDIA_PACKET + UPSTREAM_PACKET_HEADER_LEN));

	dataLength = replyPacket->Length - UPSTREAM_PACKET_HEADER_LEN;
	ByteCount -= dataLength;
	GetStreamDataCallback(HAL_OK, replyPacket, dataLength);	//usb_msc_scsi will use this packet, so don't release now
	if (ByteCount > 0)
	{
		UpstreamInterface_GetStreamDataPacket(NULL);	//Try to get the next packet now, before USB asks for it
	}
}



HAL_StatusTypeDef UpstreamInterface_BeginWrite(UpstreamInterfaceMSCCallbackTypeDef callback,
												 uint64_t readBlockStart,
												 uint32_t readBlockCount)
{
	UpstreamPacketTypeDef* freePacket;
	HAL_StatusTypeDef tempResult;

	TestReadyCallback = callback;
	freePacket = Upstream_GetFreePacketImmediately();

	freePacket->Length = UPSTREAM_PACKET_HEADER_LEN + (4 * 3);
	freePacket->CommandClass = COMMAND_CLASS_MASS_STORAGE;
	freePacket->Command = COMMAND_MSC_BEGIN_WRITE;
	*(uint64_t*)&(freePacket->Data[0]) = readBlockStart;
	*(uint32_t*)&(freePacket->Data[8]) = readBlockCount;

	tempResult = Upstream_SendPacket(freePacket);
	if (tempResult != HAL_OK)
	{
		TestReadyCallback(tempResult);
	}
	//return Upstream_GetPacket(UpstreamInterface_BeginWriteReplyCallback);
	return Upstream_GetFreePacket(UpstreamInterface_BeginWriteReplyCallback);
}

void UpstreamInterface_BeginWriteReplyCallback(UpstreamPacketTypeDef* replyPacket)
{
//	if ((replyPacket->Length != (UPSTREAM_PACKET_HEADER_LEN + 1)) ||
//		(replyPacket->CommandClass & COMMAND_CLASS_DATA_FLAG) ||
//		((replyPacket->Data[0] != HAL_OK) && (replyPacket->Data[0] != HAL_BUSY)))
//	{
//		Upstream_ReleasePacket(replyPacket);
//		TestReadyCallback(HAL_ERROR);
//		return;
//	}

	Upstream_ReleasePacket(replyPacket);
	TestReadyCallback(replyPacket->Data[0]);
}



HAL_StatusTypeDef UpstreamInterface_PutStreamDataPacket(UpstreamPacketTypeDef* packetToSend,
														  uint32_t dataLength)
{
	packetToSend->Length = dataLength + UPSTREAM_PACKET_HEADER_LEN;
	packetToSend->CommandClass = COMMAND_CLASS_MASS_STORAGE | COMMAND_CLASS_DATA_FLAG;
	packetToSend->Command = COMMAND_MSC_BEGIN_WRITE;
	return Upstream_SendPacket(packetToSend);
}