717 lines
16 KiB
C++
717 lines
16 KiB
C++
|
/*----------------------------------------------------------------------------
|
||
|
|
* U S B - K e r n e l
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Name: MSCUSER.C
|
||
|
|
* Purpose: Mass Storage Class Custom User Module
|
||
|
|
* Version: V1.10
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* This software is supplied "AS IS" without any warranties, express,
|
||
|
|
* implied or statutory, including but not limited to the implied
|
||
|
|
* warranties of fitness for purpose, satisfactory quality and
|
||
|
|
* noninfringement. Keil extends you a royalty-free right to reproduce
|
||
|
|
* and distribute executable files created using this software for use
|
||
|
|
* on NXP Semiconductors LPC family microcontroller devices only. Nothing
|
||
|
|
* else gives you the right to use this software.
|
||
|
|
*
|
||
|
|
* Copyright (c) 2005-2009 Keil Software.
|
||
|
|
*---------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
extern "C" {
|
||
|
|
#include "LPC17xx.h"
|
||
|
|
#include "lpc_types.h"
|
||
|
|
}
|
||
|
|
#include "usb.h"
|
||
|
|
#include "msc.h"
|
||
|
|
#include "usbcfg.h"
|
||
|
|
#include "usbhw.h"
|
||
|
|
#include "usbcore.h"
|
||
|
|
#include "mscuser.h"
|
||
|
|
|
||
|
|
#include "../chanfs/diskio.h"
|
||
|
|
#include <debug_frmwrk.h>
|
||
|
|
|
||
|
|
DWORD MSC_BlockCount = 0;
|
||
|
|
|
||
|
|
uint32_t MemOK; /* Memory OK */
|
||
|
|
|
||
|
|
DWORD lba; /* start block */
|
||
|
|
DWORD transfer_count; /* blocks to transfer */
|
||
|
|
DWORD length;
|
||
|
|
uint32_t block_offset; /* current block offset*/
|
||
|
|
|
||
|
|
uint8_t BulkStage; /* Bulk Stage */
|
||
|
|
|
||
|
|
uint8_t BulkBuf[MSC_MAX_PACKET]; /* Bulk In/Out Buffer */
|
||
|
|
uint8_t block_cache[MSC_BLOCK_SIZE];
|
||
|
|
uint8_t BulkLen; /* Bulk In/Out Length */
|
||
|
|
|
||
|
|
MSC_CBW CBW; /* Command Block Wrapper */
|
||
|
|
MSC_CSW CSW; /* Command Status Wrapper */
|
||
|
|
uint8_t media_lock = 0;
|
||
|
|
|
||
|
|
uint32_t MSC_SD_Lock() {
|
||
|
|
media_lock = CBW.CB[4]; //0x1 - lock, 0x0 - unlock
|
||
|
|
// logical_unit = CBW.CB[1] & 0xE0;
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t MSC_SD_Release(uint8_t pdrv) {
|
||
|
|
MSC_BlockCount = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t MSC_SD_Init(uint8_t pdrv) {
|
||
|
|
DSTATUS ret = disk_initialize(pdrv);
|
||
|
|
if(ret) return ret;
|
||
|
|
if(disk_ioctl (pdrv, GET_SECTOR_COUNT, (void *)(&MSC_BlockCount))) return 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define STARTSTOP_STOPMOTOR 0x0
|
||
|
|
#define STARTSTOP_STARTMOTOR 0x1
|
||
|
|
#define STARTSTOP_EJECT 0x2
|
||
|
|
#define STARTSTOP_LOAD 0x3
|
||
|
|
|
||
|
|
void MSC_StartStopUnit() {
|
||
|
|
switch (CBW.CB[4] & 0x03) {
|
||
|
|
case STARTSTOP_EJECT:
|
||
|
|
MSC_SD_Release(0);
|
||
|
|
break;
|
||
|
|
case STARTSTOP_LOAD:
|
||
|
|
if(MSC_BlockCount == 0) {
|
||
|
|
if(MSC_SD_Init(0) != 0) {
|
||
|
|
CSW.bStatus = CSW_CMD_FAILED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
_DBG("MSC_StartStopUnit unknown startstopunit sub command\n");
|
||
|
|
}
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Mass Storage Reset Request Callback
|
||
|
|
* Called automatically on Mass Storage Reset Request
|
||
|
|
* Parameters: None (global SetupPacket and EP0Buf)
|
||
|
|
* Return Value: TRUE - Success, FALSE - Error
|
||
|
|
*/
|
||
|
|
|
||
|
|
uint32_t MSC_Reset (void) {
|
||
|
|
BulkStage = MSC_BS_CBW;
|
||
|
|
return (TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Get Max LUN Request Callback
|
||
|
|
* Called automatically on Get Max LUN Request
|
||
|
|
* Parameters: None (global SetupPacket and EP0Buf)
|
||
|
|
* Return Value: TRUE - Success, FALSE - Error
|
||
|
|
*/
|
||
|
|
|
||
|
|
uint32_t MSC_GetMaxLUN (void) {
|
||
|
|
|
||
|
|
EP0Buf[0] = 0; /* No LUN associated with this device */
|
||
|
|
return (TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Memory Read Callback
|
||
|
|
* Called automatically on Memory Read Event
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_MemoryRead (void) {
|
||
|
|
uint32_t n = (length > MSC_MAX_PACKET) ? MSC_MAX_PACKET : length;
|
||
|
|
|
||
|
|
if (lba > MSC_BlockCount) {
|
||
|
|
n = (MSC_BlockCount - lba) * MSC_BLOCK_SIZE + block_offset;
|
||
|
|
BulkStage = MSC_BS_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(block_offset == 0) {
|
||
|
|
disk_read (0, block_cache, lba, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
USB_WriteEP(MSC_EP_IN, &block_cache[block_offset], n);
|
||
|
|
|
||
|
|
block_offset += n;
|
||
|
|
length -= n;
|
||
|
|
CSW.dDataResidue -= n;
|
||
|
|
|
||
|
|
if(block_offset >= MSC_BLOCK_SIZE) {
|
||
|
|
block_offset = 0;
|
||
|
|
++lba;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (length == 0) {
|
||
|
|
BulkStage = MSC_BS_DATA_IN_LAST;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (BulkStage != MSC_BS_DATA_IN) {
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Memory Write Callback
|
||
|
|
* Called automatically on Memory Write Event
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_MemoryWrite (void) {
|
||
|
|
|
||
|
|
for (uint32_t n = 0; n < BulkLen; n++) {
|
||
|
|
block_cache[block_offset + n] = BulkBuf[n];
|
||
|
|
}
|
||
|
|
|
||
|
|
if(block_offset + BulkLen >= MSC_BLOCK_SIZE) {
|
||
|
|
if(!(disk_status(0) & STA_PROTECT)){
|
||
|
|
disk_write(0, block_cache, lba, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
block_offset += BulkLen;
|
||
|
|
length -= BulkLen;
|
||
|
|
CSW.dDataResidue -= BulkLen;
|
||
|
|
|
||
|
|
if(block_offset >= MSC_BLOCK_SIZE) {
|
||
|
|
block_offset = 0;
|
||
|
|
++lba;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((length == 0) || (BulkStage == MSC_BS_CSW)) {
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Memory Verify Callback
|
||
|
|
* Called automatically on Memory Verify Event
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_MemoryVerify (void) {
|
||
|
|
|
||
|
|
if(!block_offset) {
|
||
|
|
disk_read(0, block_cache, lba, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uint32_t n = 0; n < BulkLen; n++) {
|
||
|
|
if (block_cache[block_offset + n] != BulkBuf[n]) {
|
||
|
|
MemOK = FALSE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
block_offset += BulkLen;
|
||
|
|
length -= BulkLen;
|
||
|
|
CSW.dDataResidue -= BulkLen;
|
||
|
|
|
||
|
|
if ((length == 0) || (BulkStage == MSC_BS_CSW)) {
|
||
|
|
CSW.bStatus = (MemOK) ? CSW_CMD_PASSED : CSW_CMD_FAILED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Read/Write Setup Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: TRUE - Success, FALSE - Error
|
||
|
|
*/
|
||
|
|
|
||
|
|
uint32_t MSC_RWSetup (void) {
|
||
|
|
uint32_t n;
|
||
|
|
|
||
|
|
/* Logical Block Address of First Block */
|
||
|
|
lba = (CBW.CB[2] << 24) |
|
||
|
|
(CBW.CB[3] << 16) |
|
||
|
|
(CBW.CB[4] << 8) |
|
||
|
|
(CBW.CB[5] << 0);
|
||
|
|
|
||
|
|
/* Number of Blocks to transfer */
|
||
|
|
transfer_count = (CBW.CB[7] << 8) |
|
||
|
|
(CBW.CB[8] << 0);
|
||
|
|
|
||
|
|
block_offset = 0;
|
||
|
|
length = transfer_count * MSC_BLOCK_SIZE;
|
||
|
|
|
||
|
|
if (CBW.dDataLength != (transfer_count * MSC_BLOCK_SIZE)) {
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
return (FALSE);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Check Data IN Format
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: TRUE - Success, FALSE - Error
|
||
|
|
*/
|
||
|
|
|
||
|
|
uint32_t DataInFormat (void) {
|
||
|
|
|
||
|
|
if (CBW.dDataLength == 0) {
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
return (FALSE);
|
||
|
|
}
|
||
|
|
if ((CBW.bmFlags & 0x80) == 0) {
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
return (FALSE);
|
||
|
|
}
|
||
|
|
return (TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Perform Data IN Transfer
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: TRUE - Success, FALSE - Error
|
||
|
|
*/
|
||
|
|
|
||
|
|
void DataInTransfer (void) {
|
||
|
|
|
||
|
|
if (BulkLen > CBW.dDataLength) {
|
||
|
|
BulkLen = CBW.dDataLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
USB_WriteEP(MSC_EP_IN, BulkBuf, BulkLen);
|
||
|
|
BulkStage = MSC_BS_DATA_IN_LAST;
|
||
|
|
|
||
|
|
CSW.dDataResidue -= BulkLen;
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Test Unit Ready Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_TestUnitReady (void) {
|
||
|
|
|
||
|
|
if (CBW.dDataLength != 0) {
|
||
|
|
if ((CBW.bmFlags & 0x80) != 0) {
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
} else {
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(MSC_BlockCount > 0) {
|
||
|
|
CSW.bStatus = CSW_CMD_PASSED;
|
||
|
|
} else {
|
||
|
|
CSW.bStatus = CSW_CMD_FAILED;
|
||
|
|
}
|
||
|
|
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Request Sense Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_RequestSense (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
BulkBuf[ 0] = 0x70; /* Response Code */
|
||
|
|
BulkBuf[ 1] = 0x00;
|
||
|
|
BulkBuf[ 2] = static_cast<uint8_t>(Sense_KEY::ILLEGAL_REQUEST);
|
||
|
|
BulkBuf[ 3] = 0x00;
|
||
|
|
BulkBuf[ 4] = 0x00;
|
||
|
|
BulkBuf[ 5] = 0x00;
|
||
|
|
BulkBuf[ 6] = 0x00;
|
||
|
|
BulkBuf[ 7] = 0x0A; /* Additional Length */
|
||
|
|
|
||
|
|
BulkBuf[ 8] = 0x00;
|
||
|
|
BulkBuf[ 9] = 0x00;
|
||
|
|
BulkBuf[10] = 0x00;
|
||
|
|
BulkBuf[11] = 0x00;
|
||
|
|
BulkBuf[12] = static_cast<uint8_t>(Sense_ASC::CANNOT_READ_MEDIUM);
|
||
|
|
BulkBuf[13] = static_cast<uint8_t>(Sense_ASCQ::UNKNOWN_FORMAT);
|
||
|
|
BulkBuf[14] = 0x00;
|
||
|
|
BulkBuf[15] = 0x00;
|
||
|
|
BulkBuf[16] = 0x00;
|
||
|
|
BulkBuf[17] = 0x00;
|
||
|
|
|
||
|
|
if (MSC_BlockCount == 0) {
|
||
|
|
BulkBuf[ 2] = static_cast<uint8_t>(Sense_KEY::NOT_READY);
|
||
|
|
BulkBuf[12] = static_cast<uint8_t>(Sense_ASC::MEDIUM_NOT_PRESENT);
|
||
|
|
BulkBuf[13] = static_cast<uint8_t>(Sense_ASCQ::LOADABLE);
|
||
|
|
}
|
||
|
|
|
||
|
|
BulkLen = 18;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Inquiry Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_Inquiry (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
BulkBuf[ 0] = 0x00; /* Direct Access Device */
|
||
|
|
BulkBuf[ 1] = 0x80; /* RMB = 1: Removable Medium */
|
||
|
|
BulkBuf[ 2] = 0x00; /* Version: No conformance claim to standard */
|
||
|
|
BulkBuf[ 3] = 0x01;
|
||
|
|
|
||
|
|
BulkBuf[ 4] = 36-4; /* Additional Length */
|
||
|
|
BulkBuf[ 5] = 0x80; /* SCCS = 1: Storage Controller Component */
|
||
|
|
BulkBuf[ 6] = 0x00;
|
||
|
|
BulkBuf[ 7] = 0x00;
|
||
|
|
|
||
|
|
BulkBuf[ 8] = 'M'; /* Vendor Identification */
|
||
|
|
BulkBuf[ 9] = 'a';
|
||
|
|
BulkBuf[10] = 'r';
|
||
|
|
BulkBuf[11] = 'l';
|
||
|
|
BulkBuf[12] = 'i';
|
||
|
|
BulkBuf[13] = 'n';
|
||
|
|
BulkBuf[14] = ' ';
|
||
|
|
BulkBuf[15] = ' ';
|
||
|
|
|
||
|
|
BulkBuf[16] = 'R'; /* Product Identification */
|
||
|
|
BulkBuf[17] = 'e';
|
||
|
|
BulkBuf[18] = '-';
|
||
|
|
BulkBuf[19] = 'A';
|
||
|
|
BulkBuf[20] = 'R';
|
||
|
|
BulkBuf[21] = 'M';
|
||
|
|
BulkBuf[22] = ' ';
|
||
|
|
BulkBuf[23] = 'S';
|
||
|
|
BulkBuf[24] = 'D';
|
||
|
|
BulkBuf[25] = 'C';
|
||
|
|
BulkBuf[26] = 'a';
|
||
|
|
BulkBuf[27] = 'r';
|
||
|
|
BulkBuf[28] = 'd';
|
||
|
|
BulkBuf[29] = ' ';
|
||
|
|
BulkBuf[30] = '0';
|
||
|
|
BulkBuf[31] = '1';
|
||
|
|
|
||
|
|
BulkBuf[32] = '1'; /* Product Revision Level */
|
||
|
|
BulkBuf[33] = '.';
|
||
|
|
BulkBuf[34] = '0';
|
||
|
|
BulkBuf[35] = ' ';
|
||
|
|
|
||
|
|
if(MSC_BlockCount == 0) {
|
||
|
|
BulkBuf[0] = 0x20; // Direct Access Device usually available but not currently
|
||
|
|
}
|
||
|
|
|
||
|
|
BulkLen = 36;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Mode Sense (6-Byte) Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_ModeSense6 (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
BulkBuf[ 0] = 0x03;
|
||
|
|
BulkBuf[ 1] = 0x00;
|
||
|
|
BulkBuf[ 2] = 0x00;
|
||
|
|
BulkBuf[ 3] = 0x00;
|
||
|
|
|
||
|
|
BulkLen = 4;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Mode Sense (10-Byte) Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_ModeSense10 (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
BulkBuf[ 0] = 0x00;
|
||
|
|
BulkBuf[ 1] = 0x06;
|
||
|
|
BulkBuf[ 2] = 0x00;
|
||
|
|
BulkBuf[ 3] = 0x00;
|
||
|
|
BulkBuf[ 4] = 0x00;
|
||
|
|
BulkBuf[ 5] = 0x00;
|
||
|
|
BulkBuf[ 6] = 0x00;
|
||
|
|
BulkBuf[ 7] = 0x00;
|
||
|
|
|
||
|
|
BulkLen = 8;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Read Capacity Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_ReadCapacity (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
/* Last Logical Block */
|
||
|
|
BulkBuf[ 0] = ((MSC_BlockCount - 1) >> 24) & 0xFF;
|
||
|
|
BulkBuf[ 1] = ((MSC_BlockCount - 1) >> 16) & 0xFF;
|
||
|
|
BulkBuf[ 2] = ((MSC_BlockCount - 1) >> 8) & 0xFF;
|
||
|
|
BulkBuf[ 3] = ((MSC_BlockCount - 1) >> 0) & 0xFF;
|
||
|
|
|
||
|
|
/* Block Length */
|
||
|
|
BulkBuf[ 4] = (MSC_BLOCK_SIZE >> 24) & 0xFF;
|
||
|
|
BulkBuf[ 5] = (MSC_BLOCK_SIZE >> 16) & 0xFF;
|
||
|
|
BulkBuf[ 6] = (MSC_BLOCK_SIZE >> 8) & 0xFF;
|
||
|
|
BulkBuf[ 7] = (MSC_BLOCK_SIZE >> 0) & 0xFF;
|
||
|
|
|
||
|
|
BulkLen = 8;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC SCSI Read Format Capacity Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_ReadFormatCapacity (void) {
|
||
|
|
|
||
|
|
if (!DataInFormat()) return;
|
||
|
|
|
||
|
|
BulkBuf[ 0] = 0x00;
|
||
|
|
BulkBuf[ 1] = 0x00;
|
||
|
|
BulkBuf[ 2] = 0x00;
|
||
|
|
BulkBuf[ 3] = 0x08; /* Capacity List Length */
|
||
|
|
|
||
|
|
/* Block Count */
|
||
|
|
BulkBuf[ 4] = (MSC_BlockCount >> 24) & 0xFF;
|
||
|
|
BulkBuf[ 5] = (MSC_BlockCount >> 16) & 0xFF;
|
||
|
|
BulkBuf[ 6] = (MSC_BlockCount >> 8) & 0xFF;
|
||
|
|
BulkBuf[ 7] = (MSC_BlockCount >> 0) & 0xFF;
|
||
|
|
|
||
|
|
/* Block Length */
|
||
|
|
BulkBuf[ 8] = 0x02; /* Descriptor Code: Formatted Media */
|
||
|
|
BulkBuf[ 9] = (MSC_BLOCK_SIZE >> 16) & 0xFF;
|
||
|
|
BulkBuf[10] = (MSC_BLOCK_SIZE >> 8) & 0xFF;
|
||
|
|
BulkBuf[11] = (MSC_BLOCK_SIZE >> 0) & 0xFF;
|
||
|
|
|
||
|
|
BulkLen = 12;
|
||
|
|
DataInTransfer();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Get Command Block Wrapper Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_GetCBW (void) {
|
||
|
|
uint32_t n;
|
||
|
|
|
||
|
|
for (n = 0; n < BulkLen; n++) {
|
||
|
|
*((uint8_t *)&CBW + n) = BulkBuf[n];
|
||
|
|
}
|
||
|
|
if ((BulkLen == sizeof(CBW)) && (CBW.dSignature == MSC_CBW_Signature)) {
|
||
|
|
/* Valid CBW */
|
||
|
|
CSW.dTag = CBW.dTag;
|
||
|
|
CSW.dDataResidue = CBW.dDataLength;
|
||
|
|
if ((CBW.bLUN != 0) || (CBW.bCBLength < 1) || CBW.bCBLength > 16) {
|
||
|
|
fail: CSW.bStatus = CSW_CMD_FAILED;
|
||
|
|
MSC_SetCSW();
|
||
|
|
_DBG("Failed SCSI OP code ");
|
||
|
|
_DBH(CBW.CB[0]);
|
||
|
|
_DBG("\n");
|
||
|
|
} else {
|
||
|
|
switch (CBW.CB[0]) {
|
||
|
|
case SCSI_TEST_UNIT_READY:
|
||
|
|
MSC_TestUnitReady();
|
||
|
|
break;
|
||
|
|
case SCSI_REQUEST_SENSE:
|
||
|
|
MSC_RequestSense();
|
||
|
|
break;
|
||
|
|
case SCSI_FORMAT_UNIT:
|
||
|
|
goto fail;
|
||
|
|
case SCSI_INQUIRY:
|
||
|
|
MSC_Inquiry();
|
||
|
|
break;
|
||
|
|
case SCSI_START_STOP_UNIT:
|
||
|
|
MSC_StartStopUnit();
|
||
|
|
break;
|
||
|
|
case SCSI_MEDIA_REMOVAL:
|
||
|
|
MSC_SD_Lock();
|
||
|
|
break;
|
||
|
|
case SCSI_MODE_SELECT6:
|
||
|
|
goto fail;
|
||
|
|
case SCSI_MODE_SENSE6:
|
||
|
|
MSC_ModeSense6();
|
||
|
|
break;
|
||
|
|
case SCSI_MODE_SELECT10:
|
||
|
|
goto fail;
|
||
|
|
case SCSI_MODE_SENSE10:
|
||
|
|
MSC_ModeSense10();
|
||
|
|
break;
|
||
|
|
case SCSI_READ_FORMAT_CAPACITIES:
|
||
|
|
MSC_ReadFormatCapacity();
|
||
|
|
break;
|
||
|
|
case SCSI_READ_CAPACITY:
|
||
|
|
MSC_ReadCapacity();
|
||
|
|
break;
|
||
|
|
case SCSI_READ10:
|
||
|
|
if (MSC_RWSetup()) {
|
||
|
|
if ((CBW.bmFlags & 0x80) != 0) {
|
||
|
|
BulkStage = MSC_BS_DATA_IN;
|
||
|
|
MSC_MemoryRead();
|
||
|
|
} else {
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SCSI_WRITE10:
|
||
|
|
if (MSC_RWSetup()) {
|
||
|
|
if ((CBW.bmFlags & 0x80) == 0) {
|
||
|
|
BulkStage = MSC_BS_DATA_OUT;
|
||
|
|
} else {
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SCSI_VERIFY10:
|
||
|
|
if (MSC_RWSetup()) {
|
||
|
|
if ((CBW.bmFlags & 0x80) == 0) {
|
||
|
|
BulkStage = MSC_BS_DATA_OUT;
|
||
|
|
MemOK = TRUE;
|
||
|
|
} else {
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
goto fail;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
/* Invalid CBW */
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
BulkStage = MSC_BS_ERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Set Command Status Wrapper Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_SetCSW (void) {
|
||
|
|
|
||
|
|
CSW.dSignature = MSC_CSW_Signature;
|
||
|
|
USB_WriteEP(MSC_EP_IN, (uint8_t *)&CSW, sizeof(CSW));
|
||
|
|
BulkStage = MSC_BS_CSW;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Bulk In Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_BulkIn (void) {
|
||
|
|
|
||
|
|
switch (BulkStage) {
|
||
|
|
case MSC_BS_DATA_IN:
|
||
|
|
switch (CBW.CB[0]) {
|
||
|
|
case SCSI_READ10:
|
||
|
|
MSC_MemoryRead();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case MSC_BS_DATA_IN_LAST:
|
||
|
|
MSC_SetCSW();
|
||
|
|
break;
|
||
|
|
case MSC_BS_DATA_IN_LAST_STALL:
|
||
|
|
USB_SetStallEP(MSC_EP_IN);
|
||
|
|
MSC_SetCSW();
|
||
|
|
break;
|
||
|
|
case MSC_BS_CSW:
|
||
|
|
BulkStage = MSC_BS_CBW;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* MSC Bulk Out Callback
|
||
|
|
* Parameters: None (global variables)
|
||
|
|
* Return Value: None
|
||
|
|
*/
|
||
|
|
|
||
|
|
void MSC_BulkOut (void) {
|
||
|
|
|
||
|
|
BulkLen = (uint8_t)USB_ReadEP(MSC_EP_OUT, BulkBuf);
|
||
|
|
switch (BulkStage) {
|
||
|
|
case MSC_BS_CBW:
|
||
|
|
MSC_GetCBW();
|
||
|
|
break;
|
||
|
|
case MSC_BS_DATA_OUT:
|
||
|
|
switch (CBW.CB[0]) {
|
||
|
|
case SCSI_WRITE10:
|
||
|
|
MSC_MemoryWrite();
|
||
|
|
break;
|
||
|
|
case SCSI_VERIFY10:
|
||
|
|
MSC_MemoryVerify();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
USB_SetStallEP(MSC_EP_OUT);
|
||
|
|
CSW.bStatus = CSW_PHASE_ERROR;
|
||
|
|
MSC_SetCSW();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|