AVR Freaks

uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
{
	uint8_t ErrorCode;
	uint8_t address;

	USB_ControlRequest = (USB_Request_Header_t)
		{
			.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
			.bRequest      = MS_REQ_MassStorageReset,
			.wValue        = 0,
			.wIndex        = MSInterfaceInfo->State.InterfaceNumber,
			.wLength       = 0,
		};

	Pipe_SelectPipe(PIPE_CONTROLPIPE);

	if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
	  return ErrorCode;

	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
	
	address = Pipe_GetBoundEndpointAddress();
	if ((ErrorCode = USB_Host_ClearEndpointStall(address)) != HOST_SENDCONTROL_Successful)
	  return ErrorCode;

	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
	
	address = Pipe_GetBoundEndpointAddress();
	if ((ErrorCode = USB_Host_ClearEndpointStall(address)) != HOST_SENDCONTROL_Successful)
	  return ErrorCode;
	  
	

	return HOST_SENDCONTROL_Successful;
}

Can you post the exact command and data you are sending?

- Dean Twisted Evil

uint8_t MassStore_ReadCapacity(const uint8_t LUNIndex,
                               SCSI_Capacity_t* const CapacityPtr)
{
	uint8_t ErrorCode = PIPE_RWSTREAM_NoError;

	/* Create a CBW with a SCSI command to issue READ CAPACITY command */
	MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
		{
			.Signature          = MS_CBW_SIGNATURE,
			.DataTransferLength = sizeof(SCSI_Capacity_t),
			.Flags              = MS_COMMAND_DIR_DATA_IN,
			.LUN                = LUNIndex,
			.SCSICommandLength  = 10,
			.SCSICommandData    =
				{
					SCSI_CMD_READ_CAPACITY_10,
					0x00,                   // Reserved
					0x00,                   // MSB of Logical block address
					0x00,
					0x00,
					0x00,                   // LSB of Logical block address
					0x00,                   // Reserved
					0x00,                   // Reserved
					0x00,                   // Partial Medium Indicator
					0x00                    // Unused (control)
				}
		};

	/* Send the command and any data to the attached device */
	if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, CapacityPtr)) != PIPE_RWSTREAM_NoError)
	  return ErrorCode;

	/* Endian-correct the read data */
	CapacityPtr->Blocks    = SwapEndian_32(CapacityPtr->Blocks);
	CapacityPtr->BlockSize = SwapEndian_32(CapacityPtr->BlockSize);

	return ErrorCode;
}

uint8_t MassStore_ReadCapacity(const uint8_t LUNIndex,
                               SCSI_Capacity_t* const CapacityPtr)
{
	uint8_t ErrorCode = PIPE_RWSTREAM_NoError;

	/* Create a CBW with a SCSI command to issue READ CAPACITY command */
	MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
		{
			.Signature          = MS_CBW_SIGNATURE,
			.DataTransferLength = CPU_TO_LE32(sizeof(SCSI_Capacity_t)),
			.Flags              = MS_COMMAND_DIR_DATA_IN,
			.LUN                = LUNIndex,
			.SCSICommandLength  = 16,
			.SCSICommandData    =
				{
			   0x9E,                   // SCSI_CMD_READ_CAPACITY_16, 
               0x00,                   // Reserved 
               0x00,                   // MSB of Logical block address 
               0x00, 
               0x00, 
               0x00, 
               0x00, 
               0x00, 
               0x00, 
               0x00,                   // LSB of Logical block address 
               0x00,                   // MSB of Allocation Length 
               0x00, 
               0x00, 
               0x0F,                   // LSB of Allocation Length 
               0x00,                   // Partial Medium Indicator 
               0x00                    // Unused (control) 
	
				}
		};


	/* Send the command and any data to the attached device */
	if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, CapacityPtr)) != PIPE_RWSTREAM_NoError)
	  return ErrorCode;

	/* Endian-correct the read data */
	CapacityPtr->Blocks    = SwapEndian_64(CapacityPtr->Blocks);
	CapacityPtr->BlockSize = SwapEndian_32(CapacityPtr->BlockSize);

	return ErrorCode;
}

#define SWAPENDIAN_64(x)            (uint64_t)((((x) & 0xFF00000000000000UL) >> 56UL) | (((x) & 0x00FF000000000000UL) >> 40UL) | \
			                                               (((x) & 0x0000FF0000000000UL) >> 24UL)  | (((x)& 0x000000FF00000000UL) >> 8UL) | \
														   (((x) & 0x00000000FF000000UL) << 8UL) |  (((x) & 0x0000000000FF0000UL) >> 24UL) | \
			                                               (((x) & 0x000000000000FF00UL) >> 40UL)  |(((x) & 0x00000000000000FFUL) >> 56UL) )

static inline uint64_t SwapEndian_64(const uint64_t DDWord) ATTR_WARN_UNUSED_RESULT ATTR_CONST;
			static inline uint64_t SwapEndian_64(const uint64_t DDWord)
			{
				if (GCC_IS_COMPILE_CONST(DDWord))
				  return SWAPENDIAN_64(DDWord);

				uint8_t Temp;

				union
				{
					uint64_t DDWord;
					uint8_t  Bytes[8];
				} Data;

				Data.DDWord = DDWord;

				Temp = Data.Bytes[0];
				Data.Bytes[0] = Data.Bytes[7];
				Data.Bytes[7] = Temp;
				
				Temp = Data.Bytes[1];
				Data.Bytes[1] = Data.Bytes[6];
				Data.Bytes[6] = Temp;
				
				Temp = Data.Bytes[2];
				Data.Bytes[2] = Data.Bytes[5];
				Data.Bytes[5] = Temp;

				Temp = Data.Bytes[3];
				Data.Bytes[3] = Data.Bytes[4];
				Data.Bytes[4] = Temp;

				return Data.DDWord;
			}

typedef struct
			{
				uint32_t Blocks; /**< Number of blocks in the addressed LUN of the device. */
				uint32_t BlockSize; /**< Number of bytes in each block in the addressed LUN. */
			} SCSI_Capacity_t;

typedef struct
			{
				uint64_t Blocks; /**< Number of blocks in the addressed LUN of the device. */
				uint32_t BlockSize; /**< Number of bytes in each block in the addressed LUN. */
			} SCSI_Capacity_t;

I haven't got any equipment here to test at the moment myself, unfortunately.

	if (f_mount(&FatFs, "", 1) == FR_OK) {

			puts_P(PSTR("mount FR_OK.\r\n"));
				if (f_open(&Fil, "newfile.txt", FA_WRITE | FA_CREATE_ALWAYS) == FR_OK) {	/* Create a file */
				
					
					f_write(&Fil, "It works!\r\n", 11, &bw);	/* Write data to the file */
		
					f_close(&Fil);								/* Close the file */

					if (bw == 11) {		/* Lights green LED if data written well */
					
					}
				}
			}