rt_int32_t MS_BulkSend ( rt_uint32_t block_number,
volatile rt_uint8_t *user_buffer,
rt_uint16_t num_blocks)
{
rt_int32_t rc;


Fill_MSCommand(block_number, MS_BlkSize, num_blocks, MS_DATA_DIR_OUT, SCSI_CMD_WRITE_10, 10);

rc = Host_ProcessTD(EDBulkOut, TD_OUT, TDBuffer, CBW_SIZE);
if (rc == OK) {
Host_DelayMS(20);
rc = Host_ProcessTD(EDBulkOut, TD_OUT, user_buffer, MS_BlkSize * num_blocks);
if (rc == OK) {
rc = Host_ProcessTD(EDBulkIn, TD_IN, TDBuffer, CSW_SIZE);
if (rc == OK) {
if (TDBuffer[12] != 0) {
rc = ERR_MS_CMD_FAILED;
}
}
}
}
return (rc);
}


rt_int32_t Host_ProcessTD (volatile HCED *ed,
volatile rt_uint32_t token,
volatile rt_uint8_t *buffer,
rt_uint32_t buffer_len)
{
volatile rt_uint32_t td_toggle;


if (ed == EDCtrl) {
if (token == TD_SETUP) {
td_toggle = TD_TOGGLE_0;
} else {
td_toggle = TD_TOGGLE_1;
}
} else {
td_toggle = 0;
}
TDHead->Control = (TD_ROUNDING |
token |
TD_DELAY_INT(0) |
td_toggle |
TD_CC);
TDTail->Control = 0;
TDHead->CurrBufPtr = (rt_uint32_t) buffer;
TDTail->CurrBufPtr = 0;
TDHead->Next = (rt_uint32_t) TDTail;
TDTail->Next = 0;
TDHead->BufEnd = (rt_uint32_t)(buffer + (buffer_len - 1));
TDTail->BufEnd = 0;

ed->HeadTd = (rt_uint32_t)TDHead | ((ed->HeadTd) & 0x00000002);
ed->TailTd = (rt_uint32_t)TDTail;
ed->Next = 0;

if (ed == EDCtrl) {
LPC_USB->HcControlHeadED = (rt_uint32_t)ed;
LPC_USB->HcCommandStatus = LPC_USB->HcCommandStatus | OR_CMD_STATUS_CLF;
LPC_USB->HcControl = LPC_USB->HcControl | OR_CONTROL_CLE;
} else {
LPC_USB->HcBulkHeadED = (rt_uint32_t)ed;
LPC_USB->HcCommandStatus = LPC_USB->HcCommandStatus | OR_CMD_STATUS_BLF;
LPC_USB->HcControl = LPC_USB->HcControl | OR_CONTROL_BLE;
}

if (DebugValue) LPC_GPIO0->FIOSET = 1<<11;
else LPC_GPIO0->FIOCLR = 1<<11;
DebugValue = !DebugValue;
Host_WDHWait();

// if (!(TDHead->Control & 0xF0000000)) {
if (!HOST_TDControlStatus) {
return (OK);
} else {
return (ERR_TD_FAIL);
}
}

        rc = Host_ProcessTD(EDBulkOut, TD_OUT, user_buffer, MS_BlkSize * num_blocks);

DRESULT disk_write(BYTE drv, /* Physical drive number (0..) */
    const BYTE *buff, /* Data to be written */
    DWORD sector, /* Sector address (LBA) */
    BYTE count /* Number of sectors to write (1..255) */
)
{
    DRESULT res;
    int result;

    (void) result;

        if (usb_status & STA_NOINIT) {
            return RES_NOTRDY;
        } else {
            if ( MS_BulkSend( sector, count, (volatile USB_INT08U*) buff ) == OK ) {
                res = RES_OK;
            } else {
                res = RES_ERROR;
                }
            }
        return res;
}

int main(void)
{
BYTE file_deviceID[1];
UINT cnt;

if ((disk_initialize(0)) == FR_OK)  //
    {
    if ((f_mount(0, &fatfs[0])) == FR_OK)
        {
        if ((f_open(&file1, "DEVICE1.TXT", FA_CREATE_ALWAYS | FA_WRITE)) == FR_OK)
            {
            cnt = 1;
            file_deviceID[0] = 'Y';
            f_write(&file1,&file_deviceID,cnt,&cnt);
            f_close(&file1); //                                                        <---------------------- ТУТ ЗАВИСАНИЕ на Host_WDHWait()
            }
        f_mount(0, NULL);
        }
    }

return 0;
}

1) f_write(&file1,&file_deviceID,cnt,&cnt);
2) fp->sclust = clst = create_chain(fp->fs, 0);    /* Create a new cluster chain */
3) cs = get_fat(fs, ncl);     /* Get the cluster status */
4) case FS_FAT16 : if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)))) break; ...
5) if (disk_write(fs->drv, fs->win, wsect, 1) != RES_OK) /* Write back dirty window if needed */
6) if ( MS_BulkSend( sector, count, (volatile USB_INT08U*) buff ) == OK )....

DRESULT disk_write(BYTE drv, /* Physical drive number (0..) */
    const BYTE *buff, /* Data to be written */
    DWORD sector, /* Sector address (LBA) */
    BYTE count /* Number of sectors to write (1..255) */
)
{
    if (usb_status & STA_NOINIT) return RES_NOTRDY;
    
    memcpy((void*)UserBuffer, buff, MS_BlkSize * count);

    if ( MS_BulkSend( sector, count, UserBuffer) == OK )
        return RES_OK;
    else
        return RES_ERROR;

}