; generated by ARM C/C++ Compiler, 5.03 [Build 24]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\obj\massstorage.o --asm_dir=.\lst\ --list_dir=.\lst\ --depend=.\obj\massstorage.d --cpu=Cortex-M0 --apcs=interwork -I.\ -I..\..\..\..\Library\CMSIS\Include -I..\..\..\..\Library\Device\Nuvoton\NUC200Series\Include -I..\..\..\..\Library\StdDriver\inc -IC:\Keil\ARM\RV31\INC -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\?ST\STM32F10x -D__MICROLIB --omf_browse=.\obj\massstorage.crf ..\MassStorage.c]
                          THUMB

                          AREA ||i.EP2_Handler||, CODE, READONLY, ALIGN=2

                  EP2_Handler PROC
;;;195    
;;;196    void EP2_Handler(void)
000000  b510              PUSH     {r4,lr}
;;;197    {
;;;198        g_u8EP2Ready = 1;
000002  4903              LDR      r1,|L1.16|
000004  2001              MOVS     r0,#1
000006  7008              STRB     r0,[r1,#0]
;;;199        MSC_AckCmd();
000008  f7fffffe          BL       MSC_AckCmd
;;;200    }
00000c  bd10              POP      {r4,pc}
;;;201    
                          ENDP

00000e  0000              DCW      0x0000
                  |L1.16|
                          DCD      ||.data||

                          AREA ||i.EP3_Handler||, CODE, READONLY, ALIGN=2

                  EP3_Handler PROC
;;;202    
;;;203    void EP3_Handler(void)
000000  4901              LDR      r1,|L2.8|
;;;204    {
;;;205        /* Bulk OUT */
;;;206        g_u8EP3Ready = 1;
000002  2001              MOVS     r0,#1
000004  7048              STRB     r0,[r1,#1]
;;;207    }
000006  4770              BX       lr
;;;208    
                          ENDP

                  |L2.8|
                          DCD      ||.data||

                          AREA ||i.MSC_AckCmd||, CODE, READONLY, ALIGN=2

                  MSC_AckCmd PROC
;;;817    
;;;818    void MSC_AckCmd(void)
000000  b570              PUSH     {r4-r6,lr}
;;;819    {
;;;820        /* Bulk IN */
;;;821        int32_t volatile idx;
;;;822    
;;;823        if (g_u8BulkState == BULK_CSW) {
000002  4d2c              LDR      r5,|L3.180|
000004  2300              MOVS     r3,#0
000006  78e8              LDRB     r0,[r5,#3]  ; g_u8BulkState
;;;824            /* Prepare to receive the CBW */
;;;825            g_u8BulkState = BULK_CBW;
;;;826    
;;;827            USBD_SET_EP_BUF_ADDR(EP3, g_u32BulkBuf0);
000008  4c2b              LDR      r4,|L3.184|
00000a  2804              CMP      r0,#4                 ;823
00000c  d014              BEQ      |L3.56|
;;;828            USBD_SET_PAYLOAD_LEN(EP3, 31);
;;;829        } else if (g_u8BulkState == BULK_IN) {
00000e  2801              CMP      r0,#1
000010  d117              BNE      |L3.66|
000012  4629              MOV      r1,r5                 ;823
;;;830            switch (g_sCBW.u8OPCode) {
000014  4829              LDR      r0,|L3.188|
000016  698a              LDR      r2,[r1,#0x18]
;;;831            case UFI_READ_FORMAT_CAPACITY:
;;;832            case UFI_READ_CAPACITY:
;;;833            case UFI_MODE_SENSE_10: {
;;;834                if (g_u32Length > 0) {
;;;835                    MSC_Read();
;;;836                    return;
;;;837                }
;;;838            }
;;;839            case UFI_READ_10: {
;;;840                if (g_u32Length > 0) {
;;;841                    MSC_ReadTrig();
;;;842                    return;
;;;843                }
;;;844            }
;;;845    
;;;846            case UFI_REQUEST_SENSE:
;;;847            case UFI_INQUIRY: {
;;;848                g_sCSW.dCSWDataResidue = 0;
000018  4e28              LDR      r6,|L3.188|
00001a  4928              LDR      r1,|L3.188|
00001c  7bc0              LDRB     r0,[r0,#0xf]          ;830  ; g_sCBW
00001e  3620              ADDS     r6,r6,#0x20
;;;849                g_sCSW.bCSWStatus = 0;
;;;850                break;
;;;851            }
;;;852    
;;;853            case UFI_PREVENT_ALLOW_MEDIUM_REMOVAL:
;;;854            case UFI_VERIFY_10:
;;;855            case UFI_START_STOP:
;;;856            case UFI_WRITE_10: {
;;;857                int32_t tmp;
;;;858    
;;;859                tmp = g_sCBW.dCBWDataTransferLength - STORAGE_BUFFER_SIZE;
000020  6889              LDR      r1,[r1,#8]
000022  2823              CMP      r0,#0x23              ;830
000024  d031              BEQ      |L3.138|
000026  dc12              BGT      |L3.78|
000028  2812              CMP      r0,#0x12              ;830
00002a  d040              BEQ      |L3.174|
00002c  dc0a              BGT      |L3.68|
00002e  2800              CMP      r0,#0                 ;830
000030  d03d              BEQ      |L3.174|
000032  2803              CMP      r0,#3                 ;830
000034  d117              BNE      |L3.102|
000036  e03a              B        |L3.174|
                  |L3.56|
000038  70eb              STRB     r3,[r5,#3]            ;825
00003a  6a68              LDR      r0,[r5,#0x24]         ;827  ; g_u32BulkBuf0
00003c  6120              STR      r0,[r4,#0x10]         ;827
00003e  201f              MOVS     r0,#0x1f              ;828
000040  6160              STR      r0,[r4,#0x14]         ;828
                  |L3.66|
;;;860                if (tmp < 0)
;;;861                    tmp = 0;
;;;862    
;;;863                g_sCSW.dCSWDataResidue = tmp;
;;;864                g_sCSW.bCSWStatus = 0;
;;;865                break;
;;;866            }
;;;867            case UFI_TEST_UNIT_READY: {
;;;868                g_sCSW.dCSWDataResidue = 0;
;;;869                g_sCSW.bCSWStatus = 0;
;;;870                break;
;;;871            }
;;;872            default: {
;;;873                /* Unsupported commmand. Return command fail status */
;;;874                g_sCSW.dCSWDataResidue = g_sCBW.dCBWDataTransferLength;
;;;875                g_sCSW.bCSWStatus = 0x01;
;;;876                break;
;;;877            }
;;;878            }
;;;879    
;;;880            /* Return the CSW */
;;;881            USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf1);
;;;882    
;;;883            /* Bulk IN buffer */
;;;884            USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)&g_sCSW.dCSWSignature, 16);
;;;885    
;;;886            g_u8BulkState = BULK_CSW;
;;;887            USBD_SET_PAYLOAD_LEN(EP2, 13);
;;;888        }
;;;889    }
000042  bd70              POP      {r4-r6,pc}
                  |L3.68|
000044  281b              CMP      r0,#0x1b              ;830
000046  d02a              BEQ      |L3.158|
000048  281e              CMP      r0,#0x1e              ;830
00004a  d10c              BNE      |L3.102|
00004c  e027              B        |L3.158|
                  |L3.78|
00004e  282a              CMP      r0,#0x2a              ;830
000050  d025              BEQ      |L3.158|
000052  dc04              BGT      |L3.94|
000054  2825              CMP      r0,#0x25              ;830
000056  d018              BEQ      |L3.138|
000058  2828              CMP      r0,#0x28              ;830
00005a  d104              BNE      |L3.102|
00005c  e01a              B        |L3.148|
                  |L3.94|
00005e  282f              CMP      r0,#0x2f              ;830
000060  d01d              BEQ      |L3.158|
000062  285a              CMP      r0,#0x5a              ;830
000064  d011              BEQ      |L3.138|
                  |L3.102|
000066  2001              MOVS     r0,#1                 ;875
000068  60b1              STR      r1,[r6,#8]            ;875  ; g_sCSW
00006a  7330              STRB     r0,[r6,#0xc]          ;875
                  |L3.108|
00006c  6aa8              LDR      r0,[r5,#0x28]         ;881  ; g_u32BulkBuf1
00006e  6020              STR      r0,[r4,#0]            ;881
000070  4b11              LDR      r3,|L3.184|
000072  4912              LDR      r1,|L3.188|
000074  33c0              ADDS     r3,r3,#0xc0           ;884
000076  2210              MOVS     r2,#0x10              ;884
000078  3120              ADDS     r1,r1,#0x20           ;884
00007a  18c0              ADDS     r0,r0,r3              ;884
00007c  f7fffffe          BL       USBD_MemCopy
000080  2004              MOVS     r0,#4                 ;886
000082  70e8              STRB     r0,[r5,#3]            ;886
000084  200d              MOVS     r0,#0xd               ;887
000086  6060              STR      r0,[r4,#4]            ;887
000088  bd70              POP      {r4-r6,pc}
                  |L3.138|
00008a  2a00              CMP      r2,#0                 ;834
00008c  d00f              BEQ      |L3.174|
00008e  f7fffffe          BL       MSC_Read
000092  bd70              POP      {r4-r6,pc}
                  |L3.148|
000094  2a00              CMP      r2,#0                 ;840
000096  d00a              BEQ      |L3.174|
000098  f7fffffe          BL       MSC_ReadTrig
00009c  bd70              POP      {r4-r6,pc}
                  |L3.158|
00009e  39ff              SUBS     r1,r1,#0xff           ;859
0000a0  39ff              SUBS     r1,r1,#0xff           ;859
0000a2  3902              SUBS     r1,#2                 ;859
0000a4  d500              BPL      |L3.168|
0000a6  2100              MOVS     r1,#0                 ;861
                  |L3.168|
0000a8  60b1              STR      r1,[r6,#8]            ;863  ; g_sCSW
                  |L3.170|
0000aa  7333              STRB     r3,[r6,#0xc]          ;849
0000ac  e7de              B        |L3.108|
                  |L3.174|
0000ae  60b3              STR      r3,[r6,#8]            ;870  ; g_sCSW
0000b0  e7fb              B        |L3.170|
;;;890    
                          ENDP

0000b2  0000              DCW      0x0000
                  |L3.180|
                          DCD      ||.data||
                  |L3.184|
                          DCD      0x40060040
                  |L3.188|
                          DCD      ||.bss||

                          AREA ||i.MSC_ClassRequest||, CODE, READONLY, ALIGN=2

                  MSC_ClassRequest PROC
;;;248    
;;;249    void MSC_ClassRequest(void)
000000  b51c              PUSH     {r2-r4,lr}
;;;250    {
;;;251        uint8_t buf[8];
;;;252    
;;;253        USBD_GetSetupPacket(buf);
000002  4668              MOV      r0,sp
000004  f7fffffe          BL       USBD_GetSetupPacket
;;;254    
;;;255        if (buf[0] & 0x80) { /* request data transfer direction */
000008  4668              MOV      r0,sp
00000a  7800              LDRB     r0,[r0,#0]
00000c  2100              MOVS     r1,#0
00000e  0603              LSLS     r3,r0,#24
;;;256            // Device to host
;;;257            switch (buf[1]) {
;;;258            case GET_MAX_LUN: {
;;;259                M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = 0;
;;;260                /* Data stage */
;;;261                USBD_SET_DATA1(EP0);
000010  2280              MOVS     r2,#0x80
000012  2b00              CMP      r3,#0                 ;255
;;;262                USBD_SET_PAYLOAD_LEN(EP0, 1);
;;;263                /* Status stage */
;;;264                USBD_PrepareCtrlOut(0,0);
;;;265                break;
;;;266            }
;;;267            default: {
;;;268                /* Setup error, stall the device */
;;;269                USBD_SetStall(0);
;;;270                break;
;;;271            }
;;;272            }
;;;273        } else {
;;;274            // Host to device
;;;275            switch (buf[1]) {
000014  466b              MOV      r3,sp
000016  480f              LDR      r0,|L4.84|
000018  785b              LDRB     r3,[r3,#1]
00001a  da13              BGE      |L4.68|
00001c  2bfe              CMP      r3,#0xfe              ;257
00001e  d10d              BNE      |L4.60|
000020  6a03              LDR      r3,[r0,#0x20]         ;259
000022  4c0d              LDR      r4,|L4.88|
000024  191b              ADDS     r3,r3,r4              ;259
000026  7019              STRB     r1,[r3,#0]            ;259
000028  6a81              LDR      r1,[r0,#0x28]         ;261
00002a  4311              ORRS     r1,r1,r2              ;261
00002c  6281              STR      r1,[r0,#0x28]         ;261
00002e  2101              MOVS     r1,#1                 ;262
000030  6241              STR      r1,[r0,#0x24]         ;262
000032  2100              MOVS     r1,#0                 ;264
000034  4608              MOV      r0,r1                 ;264
000036  f7fffffe          BL       USBD_PrepareCtrlOut
;;;276            case BULK_ONLY_MASS_STORAGE_RESET: {
;;;277                /* Status stage */
;;;278                USBD_SET_DATA1(EP0);
;;;279                USBD_SET_PAYLOAD_LEN(EP0, 0);
;;;280    
;;;281                /* TODO: reset channel ? or trigger CBW? */
;;;282    
;;;283                break;
;;;284            }
;;;285            default: {
;;;286                // Stall
;;;287                /* Setup error, stall the device */
;;;288                USBD_SetStall(0);
;;;289                break;
;;;290            }
;;;291            }
;;;292        }
;;;293    }
00003a  bd1c              POP      {r2-r4,pc}
                  |L4.60|
00003c  2000              MOVS     r0,#0                 ;269
00003e  f7fffffe          BL       USBD_SetStall
000042  bd1c              POP      {r2-r4,pc}
                  |L4.68|
000044  2bff              CMP      r3,#0xff              ;275
000046  d1f9              BNE      |L4.60|
000048  6a83              LDR      r3,[r0,#0x28]         ;278
00004a  4313              ORRS     r3,r3,r2              ;278
00004c  6283              STR      r3,[r0,#0x28]         ;278
00004e  6241              STR      r1,[r0,#0x24]         ;279
000050  bd1c              POP      {r2-r4,pc}
;;;294    
                          ENDP

000052  0000              DCW      0x0000
                  |L4.84|
                          DCD      0x40060000
                  |L4.88|
                          DCD      0x40060100

                          AREA ||i.MSC_Init||, CODE, READONLY, ALIGN=2

                  MSC_Init PROC
;;;209    
;;;210    void MSC_Init(void)
000000  4810              LDR      r0,|L5.68|
;;;211    {
;;;212        /* Init setup packet buffer */
;;;213        /* Buffer range for setup packet -> [0 ~ 0x7] */
;;;214        USBD->STBUFSEG = SETUP_BUF_BASE;
000002  2100              MOVS     r1,#0
000004  6181              STR      r1,[r0,#0x18]
;;;215    
;;;216        /*****************************************************/
;;;217        /* EP0 ==> control IN endpoint, address 0 */
;;;218        USBD_CONFIG_EP(EP0, USBD_CFG_CSTALL | USBD_CFG_EPMODE_IN | 0);
000006  2109              MOVS     r1,#9
000008  0189              LSLS     r1,r1,#6
00000a  6281              STR      r1,[r0,#0x28]
;;;219        /* Buffer range for EP0 */
;;;220        USBD_SET_EP_BUF_ADDR(EP0, EP0_BUF_BASE);
00000c  2108              MOVS     r1,#8
00000e  6201              STR      r1,[r0,#0x20]
;;;221    
;;;222        /* EP1 ==> control OUT endpoint, address 0 */
;;;223        USBD_CONFIG_EP(EP1, USBD_CFG_CSTALL | USBD_CFG_EPMODE_OUT | 0);
000010  2211              MOVS     r2,#0x11
000012  0152              LSLS     r2,r2,#5
000014  6382              STR      r2,[r0,#0x38]
;;;224        /* Buffer range for EP1 */
;;;225        USBD_SET_EP_BUF_ADDR(EP1, EP1_BUF_BASE);
000016  6301              STR      r1,[r0,#0x30]
;;;226    
;;;227        /*****************************************************/
;;;228        /* EP2 ==> Bulk IN endpoint, address 2 */
;;;229        USBD_CONFIG_EP(EP2, USBD_CFG_EPMODE_IN | BULK_IN_EP_NUM);
000018  480a              LDR      r0,|L5.68|
00001a  2142              MOVS     r1,#0x42
00001c  3040              ADDS     r0,r0,#0x40
00001e  6081              STR      r1,[r0,#8]
;;;230        /* Buffer range for EP2 */
;;;231        USBD_SET_EP_BUF_ADDR(EP2, EP2_BUF_BASE);
000020  2148              MOVS     r1,#0x48
000022  6001              STR      r1,[r0,#0]
;;;232    
;;;233        /* EP3 ==> Bulk Out endpoint, address 3 */
;;;234        USBD_CONFIG_EP(EP3, USBD_CFG_EPMODE_OUT | BULK_OUT_EP_NUM);
000024  2223              MOVS     r2,#0x23
000026  6182              STR      r2,[r0,#0x18]
;;;235        /* Buffer range for EP3 */
;;;236        USBD_SET_EP_BUF_ADDR(EP3, EP3_BUF_BASE);
000028  2288              MOVS     r2,#0x88
00002a  6102              STR      r2,[r0,#0x10]
;;;237    
;;;238        /* trigger to receive OUT data */
;;;239        USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
00002c  2340              MOVS     r3,#0x40
00002e  6143              STR      r3,[r0,#0x14]
;;;240    
;;;241        /*****************************************************/
;;;242        g_u32BulkBuf0 = EP3_BUF_BASE;
000030  4805              LDR      r0,|L5.72|
;;;243        g_u32BulkBuf1 = EP2_BUF_BASE;
;;;244    
;;;245        g_sCSW.dCSWSignature = CSW_SIGNATURE;
000032  6242              STR      r2,[r0,#0x24]  ; g_u32BulkBuf0
000034  6281              STR      r1,[r0,#0x28]  ; g_u32BulkBuf1
000036  4a06              LDR      r2,|L5.80|
000038  4904              LDR      r1,|L5.76|
;;;246        g_TotalSectors = DATA_FLASH_STORAGE_SIZE / UDC_SECTOR_SIZE;
00003a  6011              STR      r1,[r2,#0]  ; g_sCSW
00003c  2180              MOVS     r1,#0x80
00003e  6081              STR      r1,[r0,#8]  ; g_TotalSectors
;;;247    }
000040  4770              BX       lr
;;;248    
                          ENDP

000042  0000              DCW      0x0000
                  |L5.68|
                          DCD      0x40060000
                  |L5.72|
                          DCD      ||.data||
                  |L5.76|
                          DCD      0x53425355
                  |L5.80|
                          DCD      ||.bss||+0x20

                          AREA ||i.MSC_ModeSense10||, CODE, READONLY, ALIGN=2

                  MSC_ModeSense10 PROC
;;;455    
;;;456    void MSC_ModeSense10(void)
000000  b5f0              PUSH     {r4-r7,lr}
;;;457    {
;;;458        uint8_t i,j;
;;;459        uint8_t NumHead,NumSector;
;;;460        uint16_t NumCyl=0;
;;;461    
;;;462        /* Clear the command buffer */
;;;463        *((uint32_t *)MassCMD_BUF  ) = 0;
000002  4a4b              LDR      r2,|L6.304|
000004  2300              MOVS     r3,#0
;;;464        *((uint32_t *)MassCMD_BUF + 1) = 0;
000006  6013              STR      r3,[r2,#0]  ; MassBlock
;;;465    
;;;466        switch (g_sCBW.au8Data[0]) {
;;;467        case 0x01:
;;;468            *((uint8_t *)MassCMD_BUF) = 19;
;;;469            i = 8;
;;;470            for (j = 0; j<12; j++, i++)
;;;471                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_01[j];
;;;472            break;
;;;473    
;;;474        case 0x05:
;;;475            *((uint8_t *)MassCMD_BUF) = 39;
;;;476            i = 8;
;;;477            for (j = 0; j<32; j++, i++)
;;;478                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_05[j];
;;;479    
;;;480            NumHead = 2;
;;;481            NumSector = 64;
;;;482            NumCyl = g_TotalSectors / 128;
000008  4c4a              LDR      r4,|L6.308|
00000a  6053              STR      r3,[r2,#4]            ;466  ; MassBlock
00000c  68a4              LDR      r4,[r4,#8]
00000e  4e49              LDR      r6,|L6.308|
000010  17e5              ASRS     r5,r4,#31
000012  0e6d              LSRS     r5,r5,#25
000014  192c              ADDS     r4,r5,r4
000016  4610              MOV      r0,r2                 ;466
000018  0264              LSLS     r4,r4,#9
00001a  3830              SUBS     r0,r0,#0x30           ;466
00001c  0c24              LSRS     r4,r4,#16
00001e  3658              ADDS     r6,r6,#0x58           ;471
000020  7c40              LDRB     r0,[r0,#0x11]         ;466  ; g_sCBW
;;;483    
;;;484            *((uint8_t *)(MassCMD_BUF+12)) = NumHead;
;;;485            *((uint8_t *)(MassCMD_BUF+13)) = NumSector;
;;;486            *((uint8_t *)(MassCMD_BUF+16)) = (uint8_t)(NumCyl >> 8);
000022  0a25              LSRS     r5,r4,#8
000024  4637              MOV      r7,r6                 ;478
000026  2113              MOVS     r1,#0x13              ;468
000028  370c              ADDS     r7,r7,#0xc            ;478
;;;487            *((uint8_t *)(MassCMD_BUF+17)) = (uint8_t)(NumCyl & 0x00ff);
00002a  b2e4              UXTB     r4,r4
00002c  281b              CMP      r0,#0x1b              ;466
00002e  d030              BEQ      |L6.146|
000030  dc04              BGT      |L6.60|
000032  2801              CMP      r0,#1                 ;466
000034  d00e              BEQ      |L6.84|
000036  2805              CMP      r0,#5                 ;466
000038  d104              BNE      |L6.68|
00003a  e017              B        |L6.108|
                  |L6.60|
00003c  281c              CMP      r0,#0x1c              ;466
00003e  d036              BEQ      |L6.174|
000040  283f              CMP      r0,#0x3f              ;466
000042  d043              BEQ      |L6.204|
                  |L6.68|
;;;488            break;
;;;489    
;;;490        case 0x1B:
;;;491            *((uint8_t *)MassCMD_BUF) = 19;
;;;492            i = 8;
;;;493            for (j = 0; j<12; j++, i++)
;;;494                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_1B[j];
;;;495            break;
;;;496    
;;;497        case 0x1C:
;;;498            *((uint8_t *)MassCMD_BUF) = 15;
;;;499            i = 8;
;;;500            for (j = 0; j<8; j++, i++)
;;;501                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_1C[j];
;;;502            break;
;;;503    
;;;504        case 0x3F:
;;;505            *((uint8_t *)MassCMD_BUF) = 0x47;
;;;506            i = 8;
;;;507            for (j = 0; j<12; j++, i++)
;;;508                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_01[j];
;;;509            for (j = 0; j<32; j++, i++)
;;;510                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_05[j];
;;;511            for (j = 0; j<12; j++, i++)
;;;512                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_1B[j];
;;;513            for (j = 0; j<8; j++, i++)
;;;514                *((uint8_t *)(MassCMD_BUF+i)) = g_au8ModePage_1C[j];
;;;515    
;;;516            NumHead = 2;
;;;517            NumSector = 64;
;;;518            NumCyl = g_TotalSectors / 128;
;;;519    
;;;520            *((uint8_t *)(MassCMD_BUF+24)) = NumHead;
;;;521            *((uint8_t *)(MassCMD_BUF+25)) = NumSector;
;;;522            *((uint8_t *)(MassCMD_BUF+28)) = (uint8_t)(NumCyl >> 8);
;;;523            *((uint8_t *)(MassCMD_BUF+29)) = (uint8_t)(NumCyl & 0x00ff);
;;;524            break;
;;;525    
;;;526        default:
;;;527            g_au8SenseKey[0] = 0x05;
000044  483b              LDR      r0,|L6.308|
000046  2105              MOVS     r1,#5
000048  300c              ADDS     r0,r0,#0xc
00004a  7001              STRB     r1,[r0,#0]
;;;528            g_au8SenseKey[1] = 0x24;
00004c  2124              MOVS     r1,#0x24
00004e  7041              STRB     r1,[r0,#1]
;;;529            g_au8SenseKey[2] = 0x00;
000050  7083              STRB     r3,[r0,#2]
;;;530        }
;;;531    }
000052  bdf0              POP      {r4-r7,pc}
                  |L6.84|
000054  7011              STRB     r1,[r2,#0]            ;468
000056  2108              MOVS     r1,#8                 ;469
000058  2000              MOVS     r0,#0                 ;470
                  |L6.90|
00005a  5c33              LDRB     r3,[r6,r0]            ;471
00005c  5453              STRB     r3,[r2,r1]            ;471
00005e  1c40              ADDS     r0,r0,#1              ;470
000060  1c49              ADDS     r1,r1,#1              ;470
000062  b2c0              UXTB     r0,r0                 ;470
000064  b2c9              UXTB     r1,r1                 ;470
000066  280c              CMP      r0,#0xc               ;470
000068  d3f7              BCC      |L6.90|
00006a  bdf0              POP      {r4-r7,pc}
                  |L6.108|
00006c  2027              MOVS     r0,#0x27              ;475
00006e  7010              STRB     r0,[r2,#0]            ;475
000070  2108              MOVS     r1,#8                 ;476
000072  2000              MOVS     r0,#0                 ;477
                  |L6.116|
000074  5c3b              LDRB     r3,[r7,r0]            ;478
000076  5453              STRB     r3,[r2,r1]            ;478
000078  1c40              ADDS     r0,r0,#1              ;477
00007a  1c49              ADDS     r1,r1,#1              ;477
00007c  b2c0              UXTB     r0,r0                 ;477
00007e  b2c9              UXTB     r1,r1                 ;477
000080  2820              CMP      r0,#0x20              ;477
000082  d3f7              BCC      |L6.116|
000084  2102              MOVS     r1,#2                 ;480
000086  2040              MOVS     r0,#0x40              ;481
000088  7311              STRB     r1,[r2,#0xc]          ;484
00008a  7350              STRB     r0,[r2,#0xd]          ;485
00008c  7415              STRB     r5,[r2,#0x10]         ;486
00008e  7454              STRB     r4,[r2,#0x11]         ;487
000090  bdf0              POP      {r4-r7,pc}
                  |L6.146|
000092  7011              STRB     r1,[r2,#0]            ;491
000094  4b27              LDR      r3,|L6.308|
000096  2108              MOVS     r1,#8                 ;492
000098  2000              MOVS     r0,#0                 ;493
00009a  3384              ADDS     r3,r3,#0x84           ;494
                  |L6.156|
00009c  5c1c              LDRB     r4,[r3,r0]            ;494
00009e  5454              STRB     r4,[r2,r1]            ;494
0000a0  1c40              ADDS     r0,r0,#1              ;493
0000a2  1c49              ADDS     r1,r1,#1              ;493
0000a4  b2c0              UXTB     r0,r0                 ;493
0000a6  b2c9              UXTB     r1,r1                 ;493
0000a8  280c              CMP      r0,#0xc               ;493
0000aa  d3f7              BCC      |L6.156|
0000ac  bdf0              POP      {r4-r7,pc}
                  |L6.174|
0000ae  200f              MOVS     r0,#0xf               ;498
0000b0  7010              STRB     r0,[r2,#0]            ;498
0000b2  4b20              LDR      r3,|L6.308|
0000b4  2108              MOVS     r1,#8                 ;499
0000b6  2000              MOVS     r0,#0                 ;500
0000b8  332c              ADDS     r3,r3,#0x2c           ;501
                  |L6.186|
0000ba  5c1c              LDRB     r4,[r3,r0]            ;501
0000bc  5454              STRB     r4,[r2,r1]            ;501
0000be  1c40              ADDS     r0,r0,#1              ;500
0000c0  1c49              ADDS     r1,r1,#1              ;500
0000c2  b2c0              UXTB     r0,r0                 ;500
0000c4  b2c9              UXTB     r1,r1                 ;500
0000c6  2808              CMP      r0,#8                 ;500
0000c8  d3f7              BCC      |L6.186|
0000ca  bdf0              POP      {r4-r7,pc}
                  |L6.204|
0000cc  2047              MOVS     r0,#0x47              ;505
0000ce  7010              STRB     r0,[r2,#0]            ;505
0000d0  2008              MOVS     r0,#8                 ;506
0000d2  2100              MOVS     r1,#0                 ;507
                  |L6.212|
0000d4  5c73              LDRB     r3,[r6,r1]            ;508
0000d6  5413              STRB     r3,[r2,r0]            ;508
0000d8  1c49              ADDS     r1,r1,#1              ;507
0000da  1c40              ADDS     r0,r0,#1              ;507
0000dc  b2c9              UXTB     r1,r1                 ;507
0000de  b2c0              UXTB     r0,r0                 ;507
0000e0  290c              CMP      r1,#0xc               ;507
0000e2  d3f7              BCC      |L6.212|
0000e4  2100              MOVS     r1,#0                 ;509
                  |L6.230|
0000e6  5c7b              LDRB     r3,[r7,r1]            ;510
0000e8  5413              STRB     r3,[r2,r0]            ;510
0000ea  1c49              ADDS     r1,r1,#1              ;509
0000ec  1c40              ADDS     r0,r0,#1              ;509
0000ee  b2c9              UXTB     r1,r1                 ;509
0000f0  b2c0              UXTB     r0,r0                 ;509
0000f2  2920              CMP      r1,#0x20              ;509
0000f4  d3f7              BCC      |L6.230|
0000f6  4b0f              LDR      r3,|L6.308|
0000f8  2100              MOVS     r1,#0                 ;511
0000fa  3384              ADDS     r3,r3,#0x84           ;494
                  |L6.252|
0000fc  5c5e              LDRB     r6,[r3,r1]            ;512
0000fe  5416              STRB     r6,[r2,r0]            ;512
000100  1c49              ADDS     r1,r1,#1              ;511
000102  1c40              ADDS     r0,r0,#1              ;511
000104  b2c9              UXTB     r1,r1                 ;511
000106  b2c0              UXTB     r0,r0                 ;511
000108  290c              CMP      r1,#0xc               ;511
00010a  d3f7              BCC      |L6.252|
00010c  4b09              LDR      r3,|L6.308|
00010e  2100              MOVS     r1,#0                 ;513
000110  332c              ADDS     r3,r3,#0x2c           ;501
                  |L6.274|
000112  5c5e              LDRB     r6,[r3,r1]            ;514
000114  5416              STRB     r6,[r2,r0]            ;514
000116  1c49              ADDS     r1,r1,#1              ;513
000118  1c40              ADDS     r0,r0,#1              ;513
00011a  b2c9              UXTB     r1,r1                 ;513
00011c  b2c0              UXTB     r0,r0                 ;513
00011e  2908              CMP      r1,#8                 ;513
000120  d3f7              BCC      |L6.274|
000122  2102              MOVS     r1,#2                 ;516
000124  2040              MOVS     r0,#0x40              ;517
000126  7611              STRB     r1,[r2,#0x18]         ;520
000128  7650              STRB     r0,[r2,#0x19]         ;521
00012a  7715              STRB     r5,[r2,#0x1c]         ;522
00012c  7754              STRB     r4,[r2,#0x1d]         ;523
00012e  bdf0              POP      {r4-r7,pc}
;;;532    
                          ENDP

                  |L6.304|
                          DCD      ||.bss||+0x30
                  |L6.308|
                          DCD      ||.data||

                          AREA ||i.MSC_ProcessCmd||, CODE, READONLY, ALIGN=2

                  MSC_ProcessCmd PROC
;;;580    
;;;581    void MSC_ProcessCmd(void)
000000  b5f8              PUSH     {r3-r7,lr}
;;;582    {
;;;583        uint8_t u8Len;
;;;584        int32_t i;
;;;585    
;;;586        if (g_u8EP3Ready) {
000002  4c86              LDR      r4,|L7.540|
000004  7860              LDRB     r0,[r4,#1]  ; g_u8EP3Ready
000006  2800              CMP      r0,#0
000008  d00e              BEQ      |L7.40|
;;;587            g_u8EP3Ready = 0;
00000a  2000              MOVS     r0,#0
00000c  7060              STRB     r0,[r4,#1]
;;;588            if (g_u8BulkState == BULK_CBW) {
00000e  78e0              LDRB     r0,[r4,#3]  ; g_u8BulkState
;;;589                u8Len = USBD_GET_PAYLOAD_LEN(EP3);
;;;590    
;;;591                /* Check Signature & length of CBW */
;;;592                /* Bulk Out buffer */
;;;593                if ((*(uint32_t *) ((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0) != CBW_SIGNATURE) || (u8Len != 31)) {
;;;594                    return;
;;;595                }
;;;596    
;;;597                /* Get the CBW */
;;;598                for (i = 0; i < u8Len; i++)
;;;599                    *((uint8_t *) (&g_sCBW.dCBWSignature) + i) = *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0 + i);
000010  4f83              LDR      r7,|L7.544|
000012  2800              CMP      r0,#0                 ;588
000014  d009              BEQ      |L7.42|
;;;600    
;;;601                /* Prepare to echo the tag from CBW to CSW */
;;;602                g_sCSW.dCSWTag = g_sCBW.dCBWTag;
;;;603    
;;;604                /* Parse Op-Code of CBW */
;;;605                switch (g_sCBW.u8OPCode) {
;;;606                case UFI_PREVENT_ALLOW_MEDIUM_REMOVAL: {
;;;607                    if (g_sCBW.au8Data[2] & 0x01) {
;;;608                        g_au8SenseKey[0] = 0x05;  //INVALID COMMAND
;;;609                        g_au8SenseKey[1] = 0x24;
;;;610                        g_au8SenseKey[2] = 0;
;;;611                        g_u8Prevent = 1;
;;;612                    } else
;;;613                        g_u8Prevent = 0;
;;;614                    g_u8BulkState = BULK_IN;
;;;615                    MSC_AckCmd();
;;;616                    return;
;;;617                }
;;;618                case UFI_VERIFY_10:
;;;619                case UFI_START_STOP:
;;;620                case UFI_TEST_UNIT_READY: {
;;;621                    g_u8BulkState = BULK_IN;
;;;622                    MSC_AckCmd();
;;;623                    return;
;;;624                }
;;;625                case UFI_REQUEST_SENSE: {
;;;626                    MSC_RequestSense();
;;;627                    g_u8BulkState = BULK_IN;
;;;628                    USBD_SET_PAYLOAD_LEN(EP2, 18);
;;;629                    return;
;;;630                }
;;;631                case UFI_READ_FORMAT_CAPACITY: {
;;;632                    if (g_u32Length == 0) {
;;;633                        g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;634                        g_u32Address = MassCMD_BUF;
;;;635                    }
;;;636                    MSC_ReadFormatCapacity();
;;;637                    g_u8BulkState = BULK_IN;
;;;638                    if (g_u32Length > 0) {
;;;639                        if (g_u32Length > EP2_MAX_PKT_SIZE)
;;;640                            g_u8Size = EP2_MAX_PKT_SIZE;
;;;641                        else
;;;642                            g_u8Size = g_u32Length;
;;;643    
;;;644                        /* Bulk IN buffer */
;;;645                        USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;646    
;;;647                        g_u32Address += g_u8Size;
;;;648                        USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0);
;;;649                        MSC_Read();
;;;650                    }
;;;651    //                     else
;;;652    //                         MSC_AckCmd();
;;;653                    return;
;;;654                }
;;;655                case UFI_READ_CAPACITY: {
;;;656                    if (g_u32Length == 0) {
;;;657                        g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;658                        g_u32Address = MassCMD_BUF;
;;;659                    }
;;;660    
;;;661                    MSC_ReadCapacity();
;;;662                    g_u8BulkState = BULK_IN;
;;;663                    if (g_u32Length > 0) {
;;;664                        if (g_u32Length > EP2_MAX_PKT_SIZE)
;;;665                            g_u8Size = EP2_MAX_PKT_SIZE;
;;;666                        else
;;;667                            g_u8Size = g_u32Length;
;;;668    
;;;669                        /* Bulk IN buffer */
;;;670                        USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;671    
;;;672                        g_u32Address += g_u8Size;
;;;673                        USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0);
;;;674                        MSC_Read();
;;;675                    }
;;;676    //                     else
;;;677    //                         MSC_AckCmd();
;;;678                    return;
;;;679                }
;;;680                case UFI_MODE_SELECT_10: {
;;;681                    g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;682                    g_u32Address = MassCMD_BUF;
;;;683    
;;;684                    if (g_u32Length > 0) {
;;;685                        USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
;;;686                        g_u8BulkState = BULK_OUT;
;;;687                    }
;;;688                    return;
;;;689                }
;;;690                case UFI_MODE_SENSE_10: {
;;;691                    if (g_u32Length == 0) {
;;;692                        g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;693                        g_u32Address = MassCMD_BUF;
;;;694                    }
;;;695    
;;;696                    MSC_ModeSense10();
;;;697                    g_u8BulkState = BULK_IN;
;;;698                    if (g_u32Length > 0) {
;;;699                        if (g_u32Length > EP2_MAX_PKT_SIZE)
;;;700                            g_u8Size = EP2_MAX_PKT_SIZE;
;;;701                        else
;;;702                            g_u8Size = g_u32Length;
;;;703                        /* Bulk IN buffer */
;;;704                        USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;705    
;;;706                        g_u32Address += g_u8Size;
;;;707    
;;;708                        USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0);
;;;709                        MSC_Read();
;;;710                    }
;;;711    //                     else
;;;712    //                         MSC_AckCmd();
;;;713                    return;
;;;714                }
;;;715                case UFI_INQUIRY: {
;;;716                    /* Bulk IN buffer */
;;;717                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_au8InquiryID, 36);
;;;718                    USBD_SET_PAYLOAD_LEN(EP2, 36);
;;;719                    g_u8BulkState = BULK_IN;
;;;720    
;;;721                    return;
;;;722                }
;;;723                case UFI_READ_10: {
;;;724                    /* Check if it is a new transfer */
;;;725                    if(g_u32Length == 0) {
;;;726                        /* Prepare the data for Bulk IN transfer */
;;;727    
;;;728                        /* Get LBA address */
;;;729                        g_u32Address = get_be32(&g_sCBW.au8Data[0]);
;;;730                        g_u32LbaAddress = g_u32Address * UDC_SECTOR_SIZE;
;;;731                        g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;732                        g_u32BytesInStorageBuf = g_u32Length;
;;;733    
;;;734                        i = g_u32Length;
;;;735                        if (i > STORAGE_BUFFER_SIZE)
;;;736                            i = STORAGE_BUFFER_SIZE;
;;;737    
;;;738                        MSC_ReadMedia(g_u32Address * UDC_SECTOR_SIZE, i, (uint8_t *)STORAGE_DATA_BUF);
;;;739                        g_u32BytesInStorageBuf = i;
;;;740                        g_u32LbaAddress += i;
;;;741                    }
;;;742                    g_u32Address = STORAGE_DATA_BUF;
;;;743    
;;;744                    /* Indicate the next packet should be Bulk IN Data packet */
;;;745                    g_u8BulkState = BULK_IN;
;;;746    
;;;747                    if (g_u32BytesInStorageBuf > 0) {
;;;748                        /* Set the packet size */
;;;749                        if (g_u32BytesInStorageBuf > EP2_MAX_PKT_SIZE)
;;;750                            g_u8Size = EP2_MAX_PKT_SIZE;
;;;751                        else
;;;752                            g_u8Size = g_u32BytesInStorageBuf;
;;;753    
;;;754                        /* Prepare the first data packet (DATA1) */
;;;755                        /* Bulk IN buffer */
;;;756                        USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;757                        g_u32Address += g_u8Size;
;;;758    
;;;759                        /* kick - start */
;;;760                        USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf1);
;;;761                        /* Trigger to send out the data packet */
;;;762                        USBD_SET_PAYLOAD_LEN(EP2, g_u8Size);
;;;763                        g_u32Length -= g_u8Size;
;;;764                        g_u32BytesInStorageBuf -= g_u8Size;
;;;765                    }
;;;766    //                     else
;;;767    //                         MSC_AckCmd();
;;;768    
;;;769                    return;
;;;770                }
;;;771                case UFI_WRITE_10: {
;;;772                    if (g_u32Length == 0) {
;;;773                        g_u32Length = g_sCBW.dCBWDataTransferLength;
;;;774                        g_u32Address = STORAGE_DATA_BUF;
;;;775                        g_u32DataFlashStartAddr = get_be32(&g_sCBW.au8Data[0]) * UDC_SECTOR_SIZE;
;;;776                    }
;;;777    
;;;778                    if ((g_u32Length > 0)) {
;;;779                        USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
;;;780                        g_u8BulkState = BULK_OUT;
;;;781                    }
;;;782                    return;
;;;783                }
;;;784                default: {
;;;785                    /* Unsupported command */
;;;786                    g_au8SenseKey[0] = 0x05;
;;;787                    g_au8SenseKey[1] = 0x20;
;;;788                    g_au8SenseKey[2] = 0x00;
;;;789    
;;;790                    /* If CBW request for data phase, just return zero packet to end data phase */
;;;791                    if (g_sCBW.dCBWDataTransferLength > 0) {
;;;792                        /* Data Phase, zero/short packet */
;;;793                        if ((g_sCBW.bmCBWFlags & 0x80) != 0) {
;;;794                            /* Data-In */
;;;795                            g_u8BulkState = BULK_IN;
;;;796                            USBD_SET_PAYLOAD_LEN(EP2, 0);
;;;797                        }
;;;798                    } else {
;;;799                        /* Status Phase */
;;;800                        g_u8BulkState = BULK_IN;
;;;801                        MSC_AckCmd();
;;;802                    }
;;;803                    return;
;;;804                }
;;;805                }
;;;806            } else if (g_u8BulkState == BULK_OUT) {
000016  2802              CMP      r0,#2
000018  d106              BNE      |L7.40|
;;;807                switch (g_sCBW.u8OPCode) {
00001a  7bf8              LDRB     r0,[r7,#0xf]  ; g_sCBW
00001c  282a              CMP      r0,#0x2a
00001e  d001              BEQ      |L7.36|
000020  2855              CMP      r0,#0x55
000022  d101              BNE      |L7.40|
                  |L7.36|
;;;808                case UFI_WRITE_10:
;;;809                case UFI_MODE_SELECT_10: {
;;;810                    MSC_Write();
000024  f7fffffe          BL       MSC_Write
                  |L7.40|
;;;811                    return;
;;;812                }
;;;813                }
;;;814            }
;;;815        }
;;;816    }
000028  bdf8              POP      {r3-r7,pc}
                  |L7.42|
00002a  4e7e              LDR      r6,|L7.548|
00002c  6970              LDR      r0,[r6,#0x14]         ;589
00002e  4b7d              LDR      r3,|L7.548|
000030  6a62              LDR      r2,[r4,#0x24]         ;593  ; g_u32BulkBuf0
000032  b2c1              UXTB     r1,r0                 ;589
000034  33c0              ADDS     r3,r3,#0xc0           ;593
000036  18d0              ADDS     r0,r2,r3              ;593
000038  6800              LDR      r0,[r0,#0]            ;593
00003a  4d7b              LDR      r5,|L7.552|
00003c  42a8              CMP      r0,r5                 ;593
00003e  d1f3              BNE      |L7.40|
000040  291f              CMP      r1,#0x1f              ;593
000042  d1f1              BNE      |L7.40|
000044  2000              MOVS     r0,#0                 ;598
                  |L7.70|
000046  4b77              LDR      r3,|L7.548|
000048  1815              ADDS     r5,r2,r0              ;599
00004a  33c0              ADDS     r3,r3,#0xc0           ;599
00004c  18eb              ADDS     r3,r5,r3              ;599
00004e  781b              LDRB     r3,[r3,#0]            ;599
000050  543b              STRB     r3,[r7,r0]            ;599
000052  1c40              ADDS     r0,r0,#1              ;598
000054  4288              CMP      r0,r1                 ;598
000056  dbf6              BLT      |L7.70|
000058  4971              LDR      r1,|L7.544|
00005a  6878              LDR      r0,[r7,#4]            ;602  ; g_sCBW
00005c  3120              ADDS     r1,r1,#0x20           ;602
00005e  6048              STR      r0,[r1,#4]            ;605  ; g_sCSW
000060  4608              MOV      r0,r1                 ;634
000062  4b6e              LDR      r3,|L7.540|
000064  496d              LDR      r1,|L7.540|
000066  7bfa              LDRB     r2,[r7,#0xf]          ;605  ; g_sCBW
000068  330c              ADDS     r3,r3,#0xc            ;608
00006a  3010              ADDS     r0,r0,#0x10           ;634
00006c  2501              MOVS     r5,#1                 ;611
00006e  6989              LDR      r1,[r1,#0x18]         ;632
000070  2a25              CMP      r2,#0x25              ;605
000072  d05c              BEQ      |L7.302|
000074  dc0e              BGT      |L7.148|
000076  2a1b              CMP      r2,#0x1b              ;605
000078  d035              BEQ      |L7.230|
00007a  dc06              BGT      |L7.138|
00007c  2a00              CMP      r2,#0                 ;605
00007e  d032              BEQ      |L7.230|
000080  2a03              CMP      r2,#3                 ;605
000082  d034              BEQ      |L7.238|
000084  2a12              CMP      r2,#0x12              ;605
000086  d112              BNE      |L7.174|
000088  e06e              B        |L7.360|
                  |L7.138|
00008a  2a1e              CMP      r2,#0x1e              ;605
00008c  d01e              BEQ      |L7.204|
00008e  2a23              CMP      r2,#0x23              ;605
000090  d10d              BNE      |L7.174|
000092  e032              B        |L7.250|
                  |L7.148|
000094  2a2f              CMP      r2,#0x2f              ;605
000096  d026              BEQ      |L7.230|
000098  dc05              BGT      |L7.166|
00009a  4864              LDR      r0,|L7.556|
00009c  2a28              CMP      r2,#0x28              ;605
00009e  d071              BEQ      |L7.388|
0000a0  2a2a              CMP      r2,#0x2a              ;605
0000a2  d104              BNE      |L7.174|
0000a4  e0a6              B        |L7.500|
                  |L7.166|
0000a6  2a55              CMP      r2,#0x55              ;605
0000a8  d050              BEQ      |L7.332|
0000aa  2a5a              CMP      r2,#0x5a              ;605
0000ac  d054              BEQ      |L7.344|
                  |L7.174|
0000ae  2105              MOVS     r1,#5                 ;786
0000b0  7019              STRB     r1,[r3,#0]            ;786
0000b2  2120              MOVS     r1,#0x20              ;787
0000b4  7059              STRB     r1,[r3,#1]            ;787
0000b6  2100              MOVS     r1,#0                 ;788
0000b8  7099              STRB     r1,[r3,#2]            ;788
0000ba  68b8              LDR      r0,[r7,#8]            ;791  ; g_sCBW
0000bc  2800              CMP      r0,#0                 ;791
0000be  d012              BEQ      |L7.230|
0000c0  7b38              LDRB     r0,[r7,#0xc]          ;793  ; g_sCBW
0000c2  0600              LSLS     r0,r0,#24             ;793
0000c4  d5b0              BPL      |L7.40|
0000c6  70e5              STRB     r5,[r4,#3]            ;795
0000c8  6071              STR      r1,[r6,#4]            ;796
0000ca  bdf8              POP      {r3-r7,pc}
                  |L7.204|
0000cc  7cf8              LDRB     r0,[r7,#0x13]         ;607  ; g_sCBW
0000ce  07c0              LSLS     r0,r0,#31             ;607
0000d0  d007              BEQ      |L7.226|
0000d2  2105              MOVS     r1,#5                 ;608
0000d4  7019              STRB     r1,[r3,#0]            ;608
0000d6  2124              MOVS     r1,#0x24              ;609
0000d8  7059              STRB     r1,[r3,#1]            ;609
0000da  2100              MOVS     r1,#0                 ;610
0000dc  7099              STRB     r1,[r3,#2]            ;610
0000de  70a5              STRB     r5,[r4,#2]            ;611
0000e0  e001              B        |L7.230|
                  |L7.226|
0000e2  2000              MOVS     r0,#0                 ;613
0000e4  70a0              STRB     r0,[r4,#2]            ;613
                  |L7.230|
0000e6  70e5              STRB     r5,[r4,#3]            ;800
0000e8  f7fffffe          BL       MSC_AckCmd
0000ec  bdf8              POP      {r3-r7,pc}
                  |L7.238|
0000ee  f7fffffe          BL       MSC_RequestSense
0000f2  70e5              STRB     r5,[r4,#3]            ;627
0000f4  2012              MOVS     r0,#0x12              ;628
0000f6  6070              STR      r0,[r6,#4]            ;628
0000f8  bdf8              POP      {r3-r7,pc}
                  |L7.250|
0000fa  2900              CMP      r1,#0                 ;632
0000fc  d102              BNE      |L7.260|
0000fe  68b9              LDR      r1,[r7,#8]            ;633  ; g_sCBW
000100  61a1              STR      r1,[r4,#0x18]         ;634  ; g_u32Length
000102  6160              STR      r0,[r4,#0x14]         ;634  ; g_u32Address
                  |L7.260|
000104  f7fffffe          BL       MSC_ReadFormatCapacity
000108  e018              B        |L7.316|
                  |L7.266|
00010a  7120              STRB     r0,[r4,#4]            ;642
00010c  b2c2              UXTB     r2,r0                 ;704
00010e  4845              LDR      r0,|L7.548|
000110  6aa3              LDR      r3,[r4,#0x28]         ;704  ; g_u32BulkBuf1
000112  30c0              ADDS     r0,r0,#0xc0           ;704
000114  1818              ADDS     r0,r3,r0              ;704
000116  6961              LDR      r1,[r4,#0x14]         ;704  ; g_u32Address
000118  f7fffffe          BL       USBD_MemCopy
00011c  7921              LDRB     r1,[r4,#4]            ;706  ; g_u8Size
00011e  6960              LDR      r0,[r4,#0x14]         ;706  ; g_u32Address
000120  1840              ADDS     r0,r0,r1              ;706
000122  6160              STR      r0,[r4,#0x14]         ;708  ; g_u32Address
000124  6a60              LDR      r0,[r4,#0x24]         ;708  ; g_u32BulkBuf0
000126  6030              STR      r0,[r6,#0]            ;708
000128  f7fffffe          BL       MSC_Read
                  |L7.300|
00012c  bdf8              POP      {r3-r7,pc}
                  |L7.302|
00012e  2900              CMP      r1,#0                 ;656
000130  d102              BNE      |L7.312|
000132  68b9              LDR      r1,[r7,#8]            ;657  ; g_sCBW
000134  61a1              STR      r1,[r4,#0x18]         ;658  ; g_u32Length
000136  6160              STR      r0,[r4,#0x14]         ;658  ; g_u32Address
                  |L7.312|
000138  f7fffffe          BL       MSC_ReadCapacity
                  |L7.316|
00013c  70e5              STRB     r5,[r4,#3]            ;637
00013e  69a0              LDR      r0,[r4,#0x18]         ;638  ; g_u32Length
000140  2800              CMP      r0,#0                 ;638
000142  d0f3              BEQ      |L7.300|
000144  2840              CMP      r0,#0x40              ;699
000146  d9e0              BLS      |L7.266|
000148  2040              MOVS     r0,#0x40              ;700
00014a  e7de              B        |L7.266|
                  |L7.332|
00014c  68b9              LDR      r1,[r7,#8]            ;681  ; g_sCBW
00014e  61a1              STR      r1,[r4,#0x18]         ;684  ; g_u32Length
000150  6160              STR      r0,[r4,#0x14]         ;684  ; g_u32Address
000152  2900              CMP      r1,#0                 ;684
000154  d15c              BNE      |L7.528|
000156  bdf8              POP      {r3-r7,pc}
                  |L7.344|
000158  2900              CMP      r1,#0                 ;691
00015a  d102              BNE      |L7.354|
00015c  68b9              LDR      r1,[r7,#8]            ;692  ; g_sCBW
00015e  61a1              STR      r1,[r4,#0x18]         ;693  ; g_u32Length
000160  6160              STR      r0,[r4,#0x14]         ;693  ; g_u32Address
                  |L7.354|
000162  f7fffffe          BL       MSC_ModeSense10
000166  e7e9              B        |L7.316|
                  |L7.360|
000168  482e              LDR      r0,|L7.548|
00016a  492c              LDR      r1,|L7.540|
00016c  6aa3              LDR      r3,[r4,#0x28]         ;717  ; g_u32BulkBuf1
00016e  30c0              ADDS     r0,r0,#0xc0           ;717
000170  2224              MOVS     r2,#0x24              ;717
000172  3134              ADDS     r1,r1,#0x34           ;717
000174  1818              ADDS     r0,r3,r0              ;717
000176  f7fffffe          BL       USBD_MemCopy
00017a  2024              MOVS     r0,#0x24              ;718
00017c  6070              STR      r0,[r6,#4]            ;718
00017e  70e5              STRB     r5,[r4,#3]            ;719
                  |L7.384|
000180  bdf8              POP      {r3-r7,pc}
000182  e7ff              B        |L7.388|
                  |L7.388|
000184  2900              CMP      r1,#0                 ;725
000186  d115              BNE      |L7.436|
000188  f7fffffe          BL       get_be32
00018c  6160              STR      r0,[r4,#0x14]         ;730  ; g_u32Address
00018e  0240              LSLS     r0,r0,#9              ;730
000190  61e0              STR      r0,[r4,#0x1c]         ;731  ; g_u32LbaAddress
000192  68bf              LDR      r7,[r7,#8]            ;731  ; g_sCBW
000194  2101              MOVS     r1,#1                 ;735
000196  61a7              STR      r7,[r4,#0x18]         ;732  ; g_u32Length
000198  0249              LSLS     r1,r1,#9              ;735
00019a  6227              STR      r7,[r4,#0x20]         ;735  ; g_u32BytesInStorageBuf
00019c  428f              CMP      r7,r1                 ;735
00019e  dd00              BLE      |L7.418|
0001a0  460f              MOV      r7,r1                 ;736
                  |L7.418|
0001a2  4a22              LDR      r2,|L7.556|
0001a4  4639              MOV      r1,r7                 ;738
0001a6  324f              ADDS     r2,r2,#0x4f           ;738
0001a8  f7fffffe          BL       MSC_ReadMedia
0001ac  6227              STR      r7,[r4,#0x20]         ;740  ; g_u32BytesInStorageBuf
0001ae  69e0              LDR      r0,[r4,#0x1c]         ;740  ; g_u32LbaAddress
0001b0  19c0              ADDS     r0,r0,r7              ;740
0001b2  61e0              STR      r0,[r4,#0x1c]         ;740  ; g_u32LbaAddress
                  |L7.436|
0001b4  491d              LDR      r1,|L7.556|
0001b6  314f              ADDS     r1,r1,#0x4f           ;742
0001b8  6161              STR      r1,[r4,#0x14]         ;745  ; g_u32Address
0001ba  70e5              STRB     r5,[r4,#3]            ;745
0001bc  6a20              LDR      r0,[r4,#0x20]         ;747  ; g_u32BytesInStorageBuf
0001be  2800              CMP      r0,#0                 ;747
0001c0  d0de              BEQ      |L7.384|
0001c2  2840              CMP      r0,#0x40              ;749
0001c4  d900              BLS      |L7.456|
0001c6  2040              MOVS     r0,#0x40              ;750
                  |L7.456|
0001c8  7120              STRB     r0,[r4,#4]            ;752
0001ca  b2c2              UXTB     r2,r0                 ;756
0001cc  4815              LDR      r0,|L7.548|
0001ce  6aa3              LDR      r3,[r4,#0x28]         ;756  ; g_u32BulkBuf1
0001d0  30c0              ADDS     r0,r0,#0xc0           ;756
0001d2  1818              ADDS     r0,r3,r0              ;756
0001d4  f7fffffe          BL       USBD_MemCopy
0001d8  7920              LDRB     r0,[r4,#4]            ;757  ; g_u8Size
0001da  6961              LDR      r1,[r4,#0x14]         ;757  ; g_u32Address
0001dc  1809              ADDS     r1,r1,r0              ;757
0001de  6161              STR      r1,[r4,#0x14]         ;760  ; g_u32Address
0001e0  6aa1              LDR      r1,[r4,#0x28]         ;760  ; g_u32BulkBuf1
0001e2  6031              STR      r1,[r6,#0]            ;760
0001e4  6070              STR      r0,[r6,#4]            ;762
0001e6  69a1              LDR      r1,[r4,#0x18]         ;763  ; g_u32Length
0001e8  1a09              SUBS     r1,r1,r0              ;763
0001ea  61a1              STR      r1,[r4,#0x18]         ;764  ; g_u32Length
0001ec  6a21              LDR      r1,[r4,#0x20]         ;764  ; g_u32BytesInStorageBuf
0001ee  1a08              SUBS     r0,r1,r0              ;764
0001f0  6220              STR      r0,[r4,#0x20]         ;764  ; g_u32BytesInStorageBuf
0001f2  e7c5              B        |L7.384|
                  |L7.500|
0001f4  2900              CMP      r1,#0                 ;772
0001f6  d10b              BNE      |L7.528|
0001f8  68b9              LDR      r1,[r7,#8]            ;773  ; g_sCBW
0001fa  61a1              STR      r1,[r4,#0x18]         ;774  ; g_u32Length
0001fc  490b              LDR      r1,|L7.556|
0001fe  314f              ADDS     r1,r1,#0x4f           ;774
000200  6161              STR      r1,[r4,#0x14]         ;775  ; g_u32Address
000202  f7fffffe          BL       get_be32
000206  0240              LSLS     r0,r0,#9              ;775
000208  6120              STR      r0,[r4,#0x10]         ;778  ; g_u32DataFlashStartAddr
00020a  69a0              LDR      r0,[r4,#0x18]         ;778  ; g_u32Length
00020c  2800              CMP      r0,#0                 ;778
00020e  d0b7              BEQ      |L7.384|
                  |L7.528|
000210  2040              MOVS     r0,#0x40              ;779
000212  6170              STR      r0,[r6,#0x14]         ;779
000214  2002              MOVS     r0,#2                 ;780
000216  70e0              STRB     r0,[r4,#3]            ;780
000218  e7b2              B        |L7.384|
;;;817    
                          ENDP

00021a  0000              DCW      0x0000
                  |L7.540|
                          DCD      ||.data||
                  |L7.544|
                          DCD      ||.bss||
                  |L7.548|
                          DCD      0x40060040
                  |L7.552|
                          DCD      0x43425355
                  |L7.556|
                          DCD      ||.bss||+0x11

                          AREA ||i.MSC_Read||, CODE, READONLY, ALIGN=2

                  MSC_Read PROC
;;;335    
;;;336    void MSC_Read(void)
000000  b5f8              PUSH     {r3-r7,lr}
;;;337    {
;;;338        uint32_t u32Len;
;;;339    
;;;340        if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
000002  4f26              LDR      r7,|L8.156|
000004  6839              LDR      r1,[r7,#0]
000006  4d26              LDR      r5,|L8.160|
000008  462a              MOV      r2,r5
;;;341            USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0);
00000a  6aa8              LDR      r0,[r5,#0x28]  ; g_u32BulkBuf1
00000c  6a53              LDR      r3,[r2,#0x24]         ;340
00000e  4281              CMP      r1,r0                 ;340
000010  d101              BNE      |L8.22|
000012  603b              STR      r3,[r7,#0]
000014  e000              B        |L8.24|
                  |L8.22|
;;;342        else
;;;343            USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf1);
000016  6038              STR      r0,[r7,#0]
                  |L8.24|
;;;344    
;;;345        /* Trigger to send out the data packet */
;;;346        USBD_SET_PAYLOAD_LEN(EP2, g_u8Size);
000018  7929              LDRB     r1,[r5,#4]  ; g_u8Size
00001a  6079              STR      r1,[r7,#4]
;;;347    
;;;348        g_u32Length -= g_u8Size;
00001c  69aa              LDR      r2,[r5,#0x18]  ; g_u32Length
00001e  1a54              SUBS     r4,r2,r1
;;;349        g_u32BytesInStorageBuf -= g_u8Size;
000020  61ac              STR      r4,[r5,#0x18]  ; g_u32Length
000022  6a2a              LDR      r2,[r5,#0x20]  ; g_u32BytesInStorageBuf
000024  1a51              SUBS     r1,r2,r1
;;;350    
;;;351        if (g_u32Length) {
000026  6229              STR      r1,[r5,#0x20]  ; g_u32BytesInStorageBuf
000028  2c00              CMP      r4,#0
00002a  d018              BEQ      |L8.94|
;;;352            if (g_u32BytesInStorageBuf) {
;;;353                /* Prepare next data packet */
;;;354                g_u8Size = EP2_MAX_PKT_SIZE;
;;;355                if (g_u8Size > g_u32Length)
;;;356                    g_u8Size = g_u32Length;
;;;357    
;;;358                if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
;;;359                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), (uint8_t *)g_u32Address, g_u8Size);
00002c  4e1b              LDR      r6,|L8.156|
00002e  36c0              ADDS     r6,r6,#0xc0
000030  2900              CMP      r1,#0                 ;352
000032  d015              BEQ      |L8.96|
000034  2140              MOVS     r1,#0x40              ;354
000036  7129              STRB     r1,[r5,#4]            ;354
000038  2c40              CMP      r4,#0x40              ;355
00003a  d200              BCS      |L8.62|
00003c  712c              STRB     r4,[r5,#4]            ;356
                  |L8.62|
00003e  683a              LDR      r2,[r7,#0]            ;358
000040  4917              LDR      r1,|L8.160|
000042  4282              CMP      r2,r0                 ;358
000044  6949              LDR      r1,[r1,#0x14]
000046  d102              BNE      |L8.78|
000048  792a              LDRB     r2,[r5,#4]  ; g_u8Size
00004a  1998              ADDS     r0,r3,r6
00004c  e001              B        |L8.82|
                  |L8.78|
;;;360                else
;;;361                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
00004e  792a              LDRB     r2,[r5,#4]  ; g_u8Size
000050  e022              B        |L8.152|
                  |L8.82|
000052  f7fffffe          BL       USBD_MemCopy
;;;362                g_u32Address += g_u8Size;
;;;363            } else {
;;;364                u32Len = g_u32Length;
;;;365                if (u32Len > STORAGE_BUFFER_SIZE)
;;;366                    u32Len = STORAGE_BUFFER_SIZE;
;;;367    
;;;368                MSC_ReadMedia(g_u32LbaAddress, u32Len, (uint8_t *)STORAGE_DATA_BUF);
;;;369                g_u32BytesInStorageBuf = u32Len;
;;;370                g_u32LbaAddress += u32Len;
;;;371                g_u32Address = STORAGE_DATA_BUF;
;;;372    
;;;373                /* Prepare next data packet */
;;;374                g_u8Size = EP2_MAX_PKT_SIZE;
;;;375                if (g_u8Size > g_u32Length)
;;;376                    g_u8Size = g_u32Length;
;;;377    
;;;378                if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
;;;379                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), (uint8_t *)g_u32Address, g_u8Size);
;;;380                else
;;;381                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;382                g_u32Address += g_u8Size;
000056  7929              LDRB     r1,[r5,#4]  ; g_u8Size
000058  6968              LDR      r0,[r5,#0x14]  ; g_u32Address
00005a  1840              ADDS     r0,r0,r1
00005c  6168              STR      r0,[r5,#0x14]  ; g_u32Address
                  |L8.94|
;;;383            }
;;;384        }
;;;385    }
00005e  bdf8              POP      {r3-r7,pc}
                  |L8.96|
000060  2001              MOVS     r0,#1                 ;365
000062  0240              LSLS     r0,r0,#9              ;365
000064  4284              CMP      r4,r0                 ;365
000066  d900              BLS      |L8.106|
000068  4604              MOV      r4,r0                 ;366
                  |L8.106|
00006a  4a0e              LDR      r2,|L8.164|
00006c  4621              MOV      r1,r4                 ;368
00006e  69e8              LDR      r0,[r5,#0x1c]         ;368  ; g_u32LbaAddress
000070  f7fffffe          BL       MSC_ReadMedia
000074  622c              STR      r4,[r5,#0x20]         ;370  ; g_u32BytesInStorageBuf
000076  69e8              LDR      r0,[r5,#0x1c]         ;370  ; g_u32LbaAddress
000078  490a              LDR      r1,|L8.164|
00007a  1900              ADDS     r0,r0,r4              ;370
00007c  6169              STR      r1,[r5,#0x14]         ;374  ; g_u32Address
00007e  61e8              STR      r0,[r5,#0x1c]         ;374  ; g_u32LbaAddress
000080  2040              MOVS     r0,#0x40              ;374
000082  7128              STRB     r0,[r5,#4]            ;374
000084  69a8              LDR      r0,[r5,#0x18]         ;375  ; g_u32Length
000086  2840              CMP      r0,#0x40              ;375
000088  d200              BCS      |L8.140|
00008a  7128              STRB     r0,[r5,#4]            ;376
                  |L8.140|
00008c  683a              LDR      r2,[r7,#0]            ;378
00008e  6aa8              LDR      r0,[r5,#0x28]         ;378  ; g_u32BulkBuf1
000090  4282              CMP      r2,r0                 ;378
000092  d1dc              BNE      |L8.78|
000094  792a              LDRB     r2,[r5,#4]            ;379  ; g_u8Size
000096  6a68              LDR      r0,[r5,#0x24]         ;379  ; g_u32BulkBuf0
                  |L8.152|
000098  1980              ADDS     r0,r0,r6              ;381
00009a  e7da              B        |L8.82|
;;;386    
                          ENDP

                  |L8.156|
                          DCD      0x40060040
                  |L8.160|
                          DCD      ||.data||
                  |L8.164|
                          DCD      ||.bss||+0x60

                          AREA ||i.MSC_ReadCapacity||, CODE, READONLY, ALIGN=2

                  MSC_ReadCapacity PROC
;;;441    
;;;442    void MSC_ReadCapacity(void)
000000  b508              PUSH     {r3,lr}
;;;443    {
;;;444        uint32_t tmp;
;;;445    
;;;446        memset((uint8_t *)MassCMD_BUF, 0, 36);
000002  2124              MOVS     r1,#0x24
000004  480b              LDR      r0,|L9.52|
000006  f7fffffe          BL       __aeabi_memclr4
;;;447    
;;;448        tmp = g_TotalSectors - 1;
00000a  480b              LDR      r0,|L9.56|
;;;449        *((uint8_t *)(MassCMD_BUF+0)) = *((uint8_t *)&tmp+3);
00000c  4669              MOV      r1,sp
00000e  6880              LDR      r0,[r0,#8]            ;448  ; g_TotalSectors
000010  1e40              SUBS     r0,r0,#1              ;448
000012  9000              STR      r0,[sp,#0]
000014  4807              LDR      r0,|L9.52|
000016  78c9              LDRB     r1,[r1,#3]
000018  7001              STRB     r1,[r0,#0]
;;;450        *((uint8_t *)(MassCMD_BUF+1)) = *((uint8_t *)&tmp+2);
00001a  4669              MOV      r1,sp
00001c  7889              LDRB     r1,[r1,#2]
00001e  7041              STRB     r1,[r0,#1]
;;;451        *((uint8_t *)(MassCMD_BUF+2)) = *((uint8_t *)&tmp+1);
000020  4669              MOV      r1,sp
000022  7849              LDRB     r1,[r1,#1]
000024  7081              STRB     r1,[r0,#2]
;;;452        *((uint8_t *)(MassCMD_BUF+3)) = *((uint8_t *)&tmp+0);
000026  4669              MOV      r1,sp
000028  7809              LDRB     r1,[r1,#0]
00002a  70c1              STRB     r1,[r0,#3]
;;;453        *((uint8_t *)(MassCMD_BUF+6)) = 0x02;
00002c  2102              MOVS     r1,#2
00002e  7181              STRB     r1,[r0,#6]
;;;454    }
000030  bd08              POP      {r3,pc}
;;;455    
                          ENDP

000032  0000              DCW      0x0000
                  |L9.52|
                          DCD      ||.bss||+0x30
                  |L9.56|
                          DCD      ||.data||

                          AREA ||i.MSC_ReadFormatCapacity||, CODE, READONLY, ALIGN=2

                  MSC_ReadFormatCapacity PROC
;;;317    
;;;318    void MSC_ReadFormatCapacity(void)
000000  b570              PUSH     {r4-r6,lr}
;;;319    {
;;;320        memset((uint8_t *)MassCMD_BUF, 0, 36);
000002  2124              MOVS     r1,#0x24
000004  480b              LDR      r0,|L10.52|
000006  f7fffffe          BL       __aeabi_memclr4
;;;321    
;;;322        *((uint8_t *)(MassCMD_BUF+3)) = 0x10;
00000a  480a              LDR      r0,|L10.52|
00000c  2110              MOVS     r1,#0x10
;;;323        *((uint8_t *)(MassCMD_BUF+4)) = *((uint8_t *)&g_TotalSectors+3);
00000e  4c0a              LDR      r4,|L10.56|
000010  70c1              STRB     r1,[r0,#3]            ;322
000012  78e1              LDRB     r1,[r4,#3]  ; g_TotalSectors
000014  7101              STRB     r1,[r0,#4]
;;;324        *((uint8_t *)(MassCMD_BUF+5)) = *((uint8_t *)&g_TotalSectors+2);
000016  78a2              LDRB     r2,[r4,#2]  ; g_TotalSectors
000018  7142              STRB     r2,[r0,#5]
;;;325        *((uint8_t *)(MassCMD_BUF+6)) = *((uint8_t *)&g_TotalSectors+1);
00001a  7863              LDRB     r3,[r4,#1]  ; g_TotalSectors
00001c  7183              STRB     r3,[r0,#6]
;;;326        *((uint8_t *)(MassCMD_BUF+7)) = *((uint8_t *)&g_TotalSectors+0);
00001e  7825              LDRB     r5,[r4,#0]  ; g_TotalSectors
000020  71c5              STRB     r5,[r0,#7]
;;;327        *((uint8_t *)(MassCMD_BUF+8)) = 0x02;
000022  2402              MOVS     r4,#2
000024  7204              STRB     r4,[r0,#8]
;;;328        *((uint8_t *)(MassCMD_BUF+10)) = 0x02;
000026  7284              STRB     r4,[r0,#0xa]
;;;329        *((uint8_t *)(MassCMD_BUF+12)) = *((uint8_t *)&g_TotalSectors+3);
000028  7301              STRB     r1,[r0,#0xc]
;;;330        *((uint8_t *)(MassCMD_BUF+13)) = *((uint8_t *)&g_TotalSectors+2);
00002a  7342              STRB     r2,[r0,#0xd]
;;;331        *((uint8_t *)(MassCMD_BUF+14)) = *((uint8_t *)&g_TotalSectors+1);
00002c  7383              STRB     r3,[r0,#0xe]
;;;332        *((uint8_t *)(MassCMD_BUF+15)) = *((uint8_t *)&g_TotalSectors+0);
00002e  73c5              STRB     r5,[r0,#0xf]
;;;333        *((uint8_t *)(MassCMD_BUF+18)) = 0x02;
000030  7484              STRB     r4,[r0,#0x12]
;;;334    }
000032  bd70              POP      {r4-r6,pc}
;;;335    
                          ENDP

                  |L10.52|
                          DCD      ||.bss||+0x30
                  |L10.56|
                          DCD      ||.data||+0x8

                          AREA ||i.MSC_ReadMedia||, CODE, READONLY, ALIGN=1

                  MSC_ReadMedia PROC
;;;890    
;;;891    void MSC_ReadMedia(uint32_t addr, uint32_t size, uint8_t *buffer)
000000  b510              PUSH     {r4,lr}
;;;892    {
;;;893        DataFlashRead( addr, size, (uint32_t)buffer);
000002  f7fffffe          BL       DataFlashRead
;;;894    }
000006  bd10              POP      {r4,pc}
;;;895    
                          ENDP


                          AREA ||i.MSC_ReadTrig||, CODE, READONLY, ALIGN=2

                  MSC_ReadTrig PROC
;;;386    
;;;387    void MSC_ReadTrig(void)
000000  b5f8              PUSH     {r3-r7,lr}
;;;388    {
;;;389        uint32_t u32Len;
;;;390    
;;;391        if (g_u32Length) {
000002  4d25              LDR      r5,|L12.152|
;;;392            if (g_u32BytesInStorageBuf) {
;;;393                /* Prepare next data packet */
;;;394                g_u8Size = EP2_MAX_PKT_SIZE;
;;;395                if (g_u8Size > g_u32Length)
;;;396                    g_u8Size = g_u32Length;
;;;397    
;;;398                if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
000004  4e25              LDR      r6,|L12.156|
000006  69ac              LDR      r4,[r5,#0x18]         ;391  ; g_u32Length
000008  2c00              CMP      r4,#0                 ;391
00000a  d041              BEQ      |L12.144|
;;;399                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), (uint8_t *)g_u32Address, g_u8Size);
00000c  4f23              LDR      r7,|L12.156|
00000e  6a28              LDR      r0,[r5,#0x20]         ;392  ; g_u32BytesInStorageBuf
000010  37c0              ADDS     r7,r7,#0xc0
000012  2800              CMP      r0,#0                 ;392
000014  d01f              BEQ      |L12.86|
000016  2040              MOVS     r0,#0x40              ;394
000018  7128              STRB     r0,[r5,#4]            ;394
00001a  2c40              CMP      r4,#0x40              ;395
00001c  d200              BCS      |L12.32|
00001e  712c              STRB     r4,[r5,#4]            ;396
                  |L12.32|
000020  6832              LDR      r2,[r6,#0]            ;398
000022  491d              LDR      r1,|L12.152|
000024  6aa8              LDR      r0,[r5,#0x28]  ; g_u32BulkBuf1
000026  6949              LDR      r1,[r1,#0x14]
000028  e02d              B        |L12.134|
                  |L12.42|
;;;400                else
;;;401                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
00002a  19c0              ADDS     r0,r0,r7
00002c  f7fffffe          BL       USBD_MemCopy
;;;402                g_u32Address += g_u8Size;
;;;403            } else {
;;;404                u32Len = g_u32Length;
;;;405                if (u32Len > STORAGE_BUFFER_SIZE)
;;;406                    u32Len = STORAGE_BUFFER_SIZE;
;;;407    
;;;408                MSC_ReadMedia(g_u32LbaAddress, u32Len, (uint8_t *)STORAGE_DATA_BUF);
;;;409                g_u32BytesInStorageBuf = u32Len;
;;;410                g_u32LbaAddress += u32Len;
;;;411                g_u32Address = STORAGE_DATA_BUF;
;;;412    
;;;413                /* Prepare next data packet */
;;;414                g_u8Size = EP2_MAX_PKT_SIZE;
;;;415                if (g_u8Size > g_u32Length)
;;;416                    g_u8Size = g_u32Length;
;;;417    
;;;418                if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
;;;419                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), (uint8_t *)g_u32Address, g_u8Size);
;;;420                else
;;;421                    USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size);
;;;422                g_u32Address += g_u8Size;
000030  7929              LDRB     r1,[r5,#4]  ; g_u8Size
000032  6968              LDR      r0,[r5,#0x14]  ; g_u32Address
000034  1840              ADDS     r0,r0,r1
;;;423            }
;;;424    
;;;425            /* DATA0/DATA1 Toggle */
;;;426            if (USBD_GET_EP_BUF_ADDR(EP2) == g_u32BulkBuf1)
000036  6168              STR      r0,[r5,#0x14]  ; g_u32Address
000038  6831              LDR      r1,[r6,#0]
00003a  6aa8              LDR      r0,[r5,#0x28]  ; g_u32BulkBuf1
00003c  4281              CMP      r1,r0
00003e  d100              BNE      |L12.66|
;;;427                USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0);
000040  6a68              LDR      r0,[r5,#0x24]  ; g_u32BulkBuf0
                  |L12.66|
;;;428            else
;;;429                USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf1);
000042  6030              STR      r0,[r6,#0]
;;;430    
;;;431            /* Trigger to send out the data packet */
;;;432            USBD_SET_PAYLOAD_LEN(EP2, g_u8Size);
000044  7928              LDRB     r0,[r5,#4]  ; g_u8Size
000046  6070              STR      r0,[r6,#4]
;;;433    
;;;434            g_u32Length -= g_u8Size;
000048  69a9              LDR      r1,[r5,#0x18]  ; g_u32Length
00004a  1a09              SUBS     r1,r1,r0
;;;435            g_u32BytesInStorageBuf -= g_u8Size;
00004c  61a9              STR      r1,[r5,#0x18]  ; g_u32Length
00004e  6a29              LDR      r1,[r5,#0x20]  ; g_u32BytesInStorageBuf
000050  1a08              SUBS     r0,r1,r0
000052  6228              STR      r0,[r5,#0x20]         ;429  ; g_u32BytesInStorageBuf
;;;436    
;;;437        } else
;;;438            USBD_SET_PAYLOAD_LEN(EP2, 0);
;;;439    }
000054  bdf8              POP      {r3-r7,pc}
                  |L12.86|
000056  2001              MOVS     r0,#1                 ;405
000058  0240              LSLS     r0,r0,#9              ;405
00005a  4284              CMP      r4,r0                 ;405
00005c  d900              BLS      |L12.96|
00005e  4604              MOV      r4,r0                 ;406
                  |L12.96|
000060  4a0f              LDR      r2,|L12.160|
000062  4621              MOV      r1,r4                 ;408
000064  69e8              LDR      r0,[r5,#0x1c]         ;408  ; g_u32LbaAddress
000066  f7fffffe          BL       MSC_ReadMedia
00006a  622c              STR      r4,[r5,#0x20]         ;410  ; g_u32BytesInStorageBuf
00006c  69e8              LDR      r0,[r5,#0x1c]         ;410  ; g_u32LbaAddress
00006e  490c              LDR      r1,|L12.160|
000070  1900              ADDS     r0,r0,r4              ;410
000072  6169              STR      r1,[r5,#0x14]         ;414  ; g_u32Address
000074  61e8              STR      r0,[r5,#0x1c]         ;414  ; g_u32LbaAddress
000076  2040              MOVS     r0,#0x40              ;414
000078  7128              STRB     r0,[r5,#4]            ;414
00007a  69a8              LDR      r0,[r5,#0x18]         ;415  ; g_u32Length
00007c  2840              CMP      r0,#0x40              ;415
00007e  d200              BCS      |L12.130|
000080  7128              STRB     r0,[r5,#4]            ;416
                  |L12.130|
000082  6832              LDR      r2,[r6,#0]            ;418
000084  6aa8              LDR      r0,[r5,#0x28]         ;418  ; g_u32BulkBuf1
                  |L12.134|
000086  4282              CMP      r2,r0                 ;398
000088  792a              LDRB     r2,[r5,#4]            ;421  ; g_u8Size
00008a  d1ce              BNE      |L12.42|
00008c  6a68              LDR      r0,[r5,#0x24]         ;419  ; g_u32BulkBuf0
00008e  e7cc              B        |L12.42|
                  |L12.144|
000090  2000              MOVS     r0,#0                 ;438
000092  6070              STR      r0,[r6,#4]            ;438
000094  bdf8              POP      {r3-r7,pc}
;;;440    
                          ENDP

000096  0000              DCW      0x0000
                  |L12.152|
                          DCD      ||.data||
                  |L12.156|
                          DCD      0x40060040
                  |L12.160|
                          DCD      ||.bss||+0x60

                          AREA ||i.MSC_RequestSense||, CODE, READONLY, ALIGN=2

                  MSC_RequestSense PROC
;;;295    
;;;296    void MSC_RequestSense(void)
000000  b530              PUSH     {r4,r5,lr}
;;;297    {
000002  b085              SUB      sp,sp,#0x14
;;;298        uint8_t tmp[20];
;;;299    
;;;300        memset(tmp, 0, 18);
000004  2112              MOVS     r1,#0x12
000006  4668              MOV      r0,sp
000008  f7fffffe          BL       __aeabi_memclr4
;;;301        if (g_u8Prevent) {
00000c  4812              LDR      r0,|L13.88|
00000e  2500              MOVS     r5,#0
000010  7881              LDRB     r1,[r0,#2]  ; g_u8Prevent
000012  2900              CMP      r1,#0
000014  d004              BEQ      |L13.32|
;;;302            g_u8Prevent = 0;
000016  7085              STRB     r5,[r0,#2]
;;;303            tmp[0]= 0x70;
000018  2070              MOVS     r0,#0x70
00001a  4669              MOV      r1,sp
00001c  7008              STRB     r0,[r1,#0]
00001e  e002              B        |L13.38|
                  |L13.32|
;;;304        } else
;;;305            tmp[1] = 0xf0;
000020  20f0              MOVS     r0,#0xf0
000022  4669              MOV      r1,sp
000024  7048              STRB     r0,[r1,#1]
                  |L13.38|
;;;306    
;;;307        tmp[2] = g_au8SenseKey[0];
000026  4c0c              LDR      r4,|L13.88|
000028  340c              ADDS     r4,r4,#0xc
00002a  7820              LDRB     r0,[r4,#0]  ; g_au8SenseKey
00002c  7088              STRB     r0,[r1,#2]
;;;308        tmp[7] = 0x0a;
00002e  200a              MOVS     r0,#0xa
000030  71c8              STRB     r0,[r1,#7]
;;;309        tmp[12] = g_au8SenseKey[1];
000032  7860              LDRB     r0,[r4,#1]  ; g_au8SenseKey
000034  7308              STRB     r0,[r1,#0xc]
;;;310        tmp[13] = g_au8SenseKey[2];
000036  78a0              LDRB     r0,[r4,#2]  ; g_au8SenseKey
000038  7348              STRB     r0,[r1,#0xd]
;;;311        USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP2)), tmp, 20);
00003a  4808              LDR      r0,|L13.92|
00003c  6800              LDR      r0,[r0,#0]
00003e  4907              LDR      r1,|L13.92|
000040  2214              MOVS     r2,#0x14
000042  31c0              ADDS     r1,r1,#0xc0
000044  1840              ADDS     r0,r0,r1
000046  4669              MOV      r1,sp
000048  f7fffffe          BL       USBD_MemCopy
;;;312    
;;;313        g_au8SenseKey[0] = 0;
00004c  7025              STRB     r5,[r4,#0]
;;;314        g_au8SenseKey[1] = 0;
00004e  7065              STRB     r5,[r4,#1]
;;;315        g_au8SenseKey[2] = 0;
000050  70a5              STRB     r5,[r4,#2]
;;;316    }
000052  b005              ADD      sp,sp,#0x14
000054  bd30              POP      {r4,r5,pc}
;;;317    
                          ENDP

000056  0000              DCW      0x0000
                  |L13.88|
                          DCD      ||.data||
                  |L13.92|
                          DCD      0x40060040

                          AREA ||i.MSC_Write||, CODE, READONLY, ALIGN=2

                  MSC_Write PROC
;;;532    
;;;533    void MSC_Write(void)
000000  b5f8              PUSH     {r3-r7,lr}
;;;534    {
;;;535        uint32_t lba, len;
;;;536    
;;;537        if (g_u32Length > EP3_MAX_PKT_SIZE) {
000002  4c2b              LDR      r4,|L14.176|
;;;538            if (USBD_GET_EP_BUF_ADDR(EP3) == g_u32BulkBuf0) {
;;;539                USBD_SET_EP_BUF_ADDR(EP3, g_u32BulkBuf1);
;;;540                USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
;;;541                USBD_MemCopy((uint8_t *)g_u32Address, (uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), EP3_MAX_PKT_SIZE);
000004  492b              LDR      r1,|L14.180|
000006  4620              MOV      r0,r4                 ;537
000008  6a43              LDR      r3,[r0,#0x24]
;;;542            } else {
;;;543                USBD_SET_EP_BUF_ADDR(EP3, g_u32BulkBuf0);
;;;544                USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
;;;545                USBD_MemCopy((uint8_t *)g_u32Address, (uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), EP3_MAX_PKT_SIZE);
00000a  6a86              LDR      r6,[r0,#0x28]
00000c  4f29              LDR      r7,|L14.180|
00000e  69a2              LDR      r2,[r4,#0x18]         ;539  ; g_u32Length
000010  185d              ADDS     r5,r3,r1              ;541
000012  1871              ADDS     r1,r6,r1
000014  6940              LDR      r0,[r0,#0x14]         ;541
000016  3fc0              SUBS     r7,r7,#0xc0           ;538
000018  2a40              CMP      r2,#0x40              ;537
00001a  d925              BLS      |L14.104|
00001c  693a              LDR      r2,[r7,#0x10]         ;538
00001e  2440              MOVS     r4,#0x40              ;540
000020  429a              CMP      r2,r3                 ;538
000022  d104              BNE      |L14.46|
000024  613e              STR      r6,[r7,#0x10]         ;539
000026  617c              STR      r4,[r7,#0x14]         ;540
000028  2240              MOVS     r2,#0x40              ;541
00002a  4629              MOV      r1,r5                 ;541
00002c  e002              B        |L14.52|
                  |L14.46|
00002e  613b              STR      r3,[r7,#0x10]         ;543
000030  617c              STR      r4,[r7,#0x14]         ;544
000032  2240              MOVS     r2,#0x40
                  |L14.52|
000034  f7fffffe          BL       USBD_MemCopy
;;;546            }
;;;547    
;;;548            g_u32Address += EP3_MAX_PKT_SIZE;
000038  4c1d              LDR      r4,|L14.176|
00003a  6960              LDR      r0,[r4,#0x14]  ; g_u32Address
00003c  3040              ADDS     r0,r0,#0x40
;;;549            g_u32Length -= EP3_MAX_PKT_SIZE;
00003e  6160              STR      r0,[r4,#0x14]  ; g_u32Address
000040  69a1              LDR      r1,[r4,#0x18]  ; g_u32Length
000042  3940              SUBS     r1,r1,#0x40
;;;550    
;;;551            /* Buffer full. Writer it to storage first. */
;;;552            if (g_u32Address >= (STORAGE_DATA_BUF + STORAGE_BUFFER_SIZE)) {
000044  61a1              STR      r1,[r4,#0x18]  ; g_u32Length
000046  491c              LDR      r1,|L14.184|
000048  4288              CMP      r0,r1
00004a  d30c              BCC      |L14.102|
;;;553                DataFlashWrite(g_u32DataFlashStartAddr, STORAGE_BUFFER_SIZE, (uint32_t)STORAGE_DATA_BUF);
00004c  2101              MOVS     r1,#1
00004e  4a1b              LDR      r2,|L14.188|
000050  0249              LSLS     r1,r1,#9
000052  6920              LDR      r0,[r4,#0x10]  ; g_u32DataFlashStartAddr
000054  f7fffffe          BL       DataFlashWrite
;;;554    
;;;555                g_u32Address = STORAGE_DATA_BUF;
000058  4818              LDR      r0,|L14.188|
;;;556                g_u32DataFlashStartAddr += STORAGE_BUFFER_SIZE;
00005a  6160              STR      r0,[r4,#0x14]  ; g_u32Address
00005c  6920              LDR      r0,[r4,#0x10]  ; g_u32DataFlashStartAddr
00005e  30ff              ADDS     r0,r0,#0xff
000060  30ff              ADDS     r0,r0,#0xff
000062  3002              ADDS     r0,#2
000064  6120              STR      r0,[r4,#0x10]  ; g_u32DataFlashStartAddr
                  |L14.102|
;;;557            }
;;;558        } else {
;;;559            if (USBD_GET_EP_BUF_ADDR(EP3) == g_u32BulkBuf0)
;;;560                USBD_MemCopy((uint8_t *)g_u32Address, (uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0), g_u32Length);
;;;561            else
;;;562                USBD_MemCopy((uint8_t *)g_u32Address, (uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), g_u32Length);
;;;563            g_u32Address += g_u32Length;
;;;564            g_u32Length = 0;
;;;565    
;;;566    
;;;567            if (g_sCBW.u8OPCode == UFI_WRITE_10) {
;;;568                lba = get_be32(&g_sCBW.au8Data[0]);
;;;569                len = g_sCBW.dCBWDataTransferLength;
;;;570    
;;;571                len = lba * UDC_SECTOR_SIZE + g_sCBW.dCBWDataTransferLength - g_u32DataFlashStartAddr;
;;;572                if (len)
;;;573                    DataFlashWrite(g_u32DataFlashStartAddr, len, (uint32_t)STORAGE_DATA_BUF);
;;;574            }
;;;575    
;;;576            g_u8BulkState = BULK_IN;
;;;577            MSC_AckCmd();
;;;578        }
;;;579    }
000066  bdf8              POP      {r3-r7,pc}
                  |L14.104|
000068  693e              LDR      r6,[r7,#0x10]         ;559
00006a  429e              CMP      r6,r3                 ;559
00006c  d100              BNE      |L14.112|
00006e  4629              MOV      r1,r5                 ;559
                  |L14.112|
000070  f7fffffe          BL       USBD_MemCopy
000074  69a1              LDR      r1,[r4,#0x18]         ;563  ; g_u32Length
000076  6960              LDR      r0,[r4,#0x14]         ;563  ; g_u32Address
000078  4d10              LDR      r5,|L14.188|
00007a  1840              ADDS     r0,r0,r1              ;563
00007c  6160              STR      r0,[r4,#0x14]         ;564  ; g_u32Address
00007e  2000              MOVS     r0,#0                 ;564
000080  3d60              SUBS     r5,r5,#0x60           ;567
000082  61a0              STR      r0,[r4,#0x18]         ;567  ; g_u32Length
000084  7be8              LDRB     r0,[r5,#0xf]          ;567  ; g_sCBW
000086  282a              CMP      r0,#0x2a              ;567
000088  d10c              BNE      |L14.164|
00008a  4628              MOV      r0,r5                 ;568
00008c  3011              ADDS     r0,r0,#0x11           ;568
00008e  f7fffffe          BL       get_be32
000092  68a9              LDR      r1,[r5,#8]            ;571  ; g_sCBW
000094  0240              LSLS     r0,r0,#9              ;571
000096  1841              ADDS     r1,r0,r1              ;571
000098  6920              LDR      r0,[r4,#0x10]         ;571  ; g_u32DataFlashStartAddr
00009a  1a09              SUBS     r1,r1,r0              ;571
00009c  d002              BEQ      |L14.164|
00009e  4a07              LDR      r2,|L14.188|
0000a0  f7fffffe          BL       DataFlashWrite
                  |L14.164|
0000a4  2001              MOVS     r0,#1                 ;576
0000a6  70e0              STRB     r0,[r4,#3]            ;576
0000a8  f7fffffe          BL       MSC_AckCmd
0000ac  bdf8              POP      {r3-r7,pc}
;;;580    
                          ENDP

0000ae  0000              DCW      0x0000
                  |L14.176|
                          DCD      ||.data||
                  |L14.180|
                          DCD      0x40060100
                  |L14.184|
                          DCD      ||.bss||+0x260
                  |L14.188|
                          DCD      ||.bss||+0x60

                          AREA ||i.MSC_WriteMedia||, CODE, READONLY, ALIGN=1

                  MSC_WriteMedia PROC
;;;895    
;;;896    void MSC_WriteMedia(uint32_t addr, uint32_t size, uint8_t *buffer)
000000  4770              BX       lr
;;;897    {
;;;898    }
;;;899    
                          ENDP


                          AREA ||i.USBD_IRQHandler||, CODE, READONLY, ALIGN=2

                  USBD_IRQHandler PROC
;;;86     
;;;87     void USBD_IRQHandler(void)
000000  b5f8              PUSH     {r3-r7,lr}
;;;88     {
;;;89         uint32_t u32IntSts = USBD_GET_INT_FLAG();
000002  4d36              LDR      r5,|L16.220|
000004  686c              LDR      r4,[r5,#4]
;;;90         uint32_t u32State = USBD_GET_BUS_STATE();
000006  6928              LDR      r0,[r5,#0x10]
;;;91     
;;;92     //------------------------------------------------------------------
;;;93         if (u32IntSts & USBD_INTSTS_FLDET) {
;;;94             // Floating detect
;;;95             USBD_CLR_INT_FLAG(USBD_INTSTS_FLDET);
;;;96     
;;;97             if (USBD_IS_ATTACHED()) {
;;;98                 /* USB Plug In */
;;;99                 USBD_ENABLE_USB();
000008  2790              MOVS     r7,#0x90
00000a  0706              LSLS     r6,r0,#28             ;90
00000c  0f36              LSRS     r6,r6,#28             ;90
00000e  0760              LSLS     r0,r4,#29             ;93
000010  2800              CMP      r0,#0                 ;93
000012  da0a              BGE      |L16.42|
000014  2004              MOVS     r0,#4                 ;95
000016  6068              STR      r0,[r5,#4]            ;95
000018  6968              LDR      r0,[r5,#0x14]         ;97
00001a  07c0              LSLS     r0,r0,#31             ;97
;;;100            } else {
;;;101                /* USB Un-plug */
;;;102                USBD_DISABLE_USB();
00001c  6928              LDR      r0,[r5,#0x10]
00001e  d001              BEQ      |L16.36|
000020  4338              ORRS     r0,r0,r7              ;99
000022  e001              B        |L16.40|
                  |L16.36|
000024  2180              MOVS     r1,#0x80
000026  4388              BICS     r0,r0,r1
                  |L16.40|
000028  6128              STR      r0,[r5,#0x10]         ;99
                  |L16.42|
;;;103            }
;;;104        }
;;;105    
;;;106    //------------------------------------------------------------------
;;;107        if (u32IntSts & USBD_INTSTS_BUS) {
00002a  07e0              LSLS     r0,r4,#31
00002c  d013              BEQ      |L16.86|
;;;108            /* Clear event flag */
;;;109            USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
00002e  2001              MOVS     r0,#1
000030  6068              STR      r0,[r5,#4]
;;;110    
;;;111            if (u32State & USBD_STATE_USBRST) {
000032  07f0              LSLS     r0,r6,#31
000034  d004              BEQ      |L16.64|
;;;112                /* Bus reset */
;;;113                USBD_ENABLE_USB();
000036  6928              LDR      r0,[r5,#0x10]
000038  4338              ORRS     r0,r0,r7
00003a  6128              STR      r0,[r5,#0x10]
;;;114                USBD_SwReset();
00003c  f7fffffe          BL       USBD_SwReset
                  |L16.64|
;;;115            }
;;;116            if (u32State & USBD_STATE_SUSPEND) {
000040  07b0              LSLS     r0,r6,#30
000042  d503              BPL      |L16.76|
;;;117                /* Enable USB but disable PHY */
;;;118                USBD_DISABLE_PHY();
000044  6928              LDR      r0,[r5,#0x10]
000046  2110              MOVS     r1,#0x10
000048  4388              BICS     r0,r0,r1
00004a  6128              STR      r0,[r5,#0x10]
                  |L16.76|
;;;119            }
;;;120            if (u32State & USBD_STATE_RESUME) {
00004c  0770              LSLS     r0,r6,#29
00004e  d502              BPL      |L16.86|
;;;121                /* Enable USB and enable PHY */
;;;122                USBD_ENABLE_USB();
000050  6928              LDR      r0,[r5,#0x10]
000052  4338              ORRS     r0,r0,r7
000054  6128              STR      r0,[r5,#0x10]
                  |L16.86|
;;;123            }
;;;124        }
;;;125    
;;;126    //------------------------------------------------------------------
;;;127        if (u32IntSts & USBD_INTSTS_USB) {
000056  07a0              LSLS     r0,r4,#30
000058  d53e              BPL      |L16.216|
;;;128            // USB event
;;;129            if (u32IntSts & USBD_INTSTS_SETUP) {
00005a  2c00              CMP      r4,#0
00005c  da0b              BGE      |L16.118|
;;;130                // Setup packet
;;;131                /* Clear event flag */
;;;132                USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
00005e  2001              MOVS     r0,#1
000060  07c0              LSLS     r0,r0,#31
000062  6068              STR      r0,[r5,#4]
;;;133    
;;;134                /* Clear the data IN/OUT ready flag of control end-points */
;;;135                USBD_STOP_TRANSACTION(EP0);
000064  6ae9              LDR      r1,[r5,#0x2c]
000066  2001              MOVS     r0,#1
000068  4301              ORRS     r1,r1,r0
00006a  62e9              STR      r1,[r5,#0x2c]
;;;136                USBD_STOP_TRANSACTION(EP1);
00006c  6be9              LDR      r1,[r5,#0x3c]
00006e  4301              ORRS     r1,r1,r0
000070  63e9              STR      r1,[r5,#0x3c]
;;;137    
;;;138                USBD_ProcessSetupPacket();
000072  f7fffffe          BL       USBD_ProcessSetupPacket
                  |L16.118|
;;;139            }
;;;140    
;;;141            // EP events
;;;142            if (u32IntSts & USBD_INTSTS_EP0) {
000076  03e0              LSLS     r0,r4,#15
000078  d504              BPL      |L16.132|
;;;143                /* Clear event flag */
;;;144                USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
00007a  2001              MOVS     r0,#1
00007c  0400              LSLS     r0,r0,#16
00007e  6068              STR      r0,[r5,#4]
;;;145                // control IN
;;;146                USBD_CtrlIn();
000080  f7fffffe          BL       USBD_CtrlIn
                  |L16.132|
;;;147            }
;;;148    
;;;149            if (u32IntSts & USBD_INTSTS_EP1) {
000084  03a0              LSLS     r0,r4,#14
000086  d504              BPL      |L16.146|
;;;150                /* Clear event flag */
;;;151                USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
000088  2001              MOVS     r0,#1
00008a  0440              LSLS     r0,r0,#17
00008c  6068              STR      r0,[r5,#4]
;;;152    
;;;153                // control OUT
;;;154                USBD_CtrlOut();
00008e  f7fffffe          BL       USBD_CtrlOut
                  |L16.146|
;;;155            }
;;;156    
;;;157            if (u32IntSts & USBD_INTSTS_EP2) {
000092  0360              LSLS     r0,r4,#13
000094  d504              BPL      |L16.160|
;;;158                /* Clear event flag */
;;;159                USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
000096  2001              MOVS     r0,#1
000098  0480              LSLS     r0,r0,#18
00009a  6068              STR      r0,[r5,#4]
;;;160                // Bulk IN
;;;161                EP2_Handler();
00009c  f7fffffe          BL       EP2_Handler
                  |L16.160|
;;;162            }
;;;163    
;;;164            if (u32IntSts & USBD_INTSTS_EP3) {
0000a0  0320              LSLS     r0,r4,#12
0000a2  d505              BPL      |L16.176|
;;;165                /* Clear event flag */
;;;166                USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
0000a4  2001              MOVS     r0,#1
0000a6  04c0              LSLS     r0,r0,#19
0000a8  6068              STR      r0,[r5,#4]
0000aa  490d              LDR      r1,|L16.224|
0000ac  2001              MOVS     r0,#1
0000ae  7048              STRB     r0,[r1,#1]
                  |L16.176|
;;;167                // Bulk OUT
;;;168                EP3_Handler();
;;;169            }
;;;170    
;;;171            if (u32IntSts & USBD_INTSTS_EP4) {
0000b0  02e0              LSLS     r0,r4,#11
0000b2  d502              BPL      |L16.186|
;;;172                /* Clear event flag */
;;;173                USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
0000b4  2001              MOVS     r0,#1
0000b6  0500              LSLS     r0,r0,#20
0000b8  6068              STR      r0,[r5,#4]
                  |L16.186|
;;;174            }
;;;175    
;;;176            if (u32IntSts & USBD_INTSTS_EP5) {
0000ba  02a0              LSLS     r0,r4,#10
0000bc  d502              BPL      |L16.196|
;;;177                /* Clear event flag */
;;;178                USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
0000be  2001              MOVS     r0,#1
0000c0  0540              LSLS     r0,r0,#21
0000c2  6068              STR      r0,[r5,#4]
                  |L16.196|
;;;179            }
;;;180    
;;;181            if (u32IntSts & USBD_INTSTS_EP6) {
0000c4  0260              LSLS     r0,r4,#9
0000c6  d502              BPL      |L16.206|
;;;182                /* Clear event flag */
;;;183                USBD_CLR_INT_FLAG(USBD_INTSTS_EP6);
0000c8  2001              MOVS     r0,#1
0000ca  0580              LSLS     r0,r0,#22
0000cc  6068              STR      r0,[r5,#4]
                  |L16.206|
;;;184            }
;;;185    
;;;186            if (u32IntSts & USBD_INTSTS_EP7) {
0000ce  0220              LSLS     r0,r4,#8
0000d0  d502              BPL      |L16.216|
;;;187                /* Clear event flag */
;;;188                USBD_CLR_INT_FLAG(USBD_INTSTS_EP7);
0000d2  2001              MOVS     r0,#1
0000d4  05c0              LSLS     r0,r0,#23
0000d6  6068              STR      r0,[r5,#4]
                  |L16.216|
;;;189            }
;;;190        }
;;;191        /* clear unknown event */
;;;192        USBD_CLR_INT_FLAG(u32IntSts);
0000d8  606c              STR      r4,[r5,#4]
;;;193    }
0000da  bdf8              POP      {r3-r7,pc}
;;;194    
                          ENDP

                  |L16.220|
                          DCD      0x40060000
                  |L16.224|
                          DCD      ||.data||

                          AREA ||i.USBD_MemCopy||, CODE, READONLY, ALIGN=1

                  USBD_MemCopy PROC
;;;341      */
;;;342    static __INLINE void USBD_MemCopy(uint8_t *dest, uint8_t *src, int32_t size)
000000  e003              B        |L17.10|
                  |L17.2|
;;;343    {
;;;344        while (size--) *dest++ = *src++;
000002  780b              LDRB     r3,[r1,#0]
000004  1c49              ADDS     r1,r1,#1
000006  7003              STRB     r3,[r0,#0]
000008  1c40              ADDS     r0,r0,#1
                  |L17.10|
00000a  1e52              SUBS     r2,r2,#1
00000c  d2f9              BCS      |L17.2|
;;;345    }
00000e  4770              BX       lr
;;;346    
                          ENDP


                          AREA ||i.USBD_SetStall||, CODE, READONLY, ALIGN=2

                  USBD_SetStall PROC
;;;355     */
;;;356    static __INLINE void USBD_SetStall(uint8_t ep)
000000  4b0a              LDR      r3,|L18.44|
;;;357    {
;;;358    	uint32_t u32CfgAddr;
;;;359    	uint32_t u32Cfg;
;;;360        int i;
;;;361    
;;;362        for (i=0; i<USBD_MAX_EP; i++)
000002  2100              MOVS     r1,#0
                  |L18.4|
;;;363        {
;;;364            u32CfgAddr = (uint32_t)(i << 4) + (uint32_t)&USBD->EP[0].CFG; /* USBD_CFG0 */
000004  010a              LSLS     r2,r1,#4
000006  18d2              ADDS     r2,r2,r3
;;;365            u32Cfg = *((__IO uint32_t *) (u32CfgAddr));
000008  6812              LDR      r2,[r2,#0]
;;;366    
;;;367            if ((u32Cfg & 0xf) == ep)
00000a  0712              LSLS     r2,r2,#28
00000c  0f12              LSRS     r2,r2,#28
00000e  4282              CMP      r2,r0
000010  d108              BNE      |L18.36|
;;;368            {
;;;369                u32CfgAddr = (uint32_t)(i << 4) + (uint32_t)&USBD->EP[0].CFGP; /* USBD_CFGP0 */
000012  0108              LSLS     r0,r1,#4
000014  4905              LDR      r1,|L18.44|
000016  1d09              ADDS     r1,r1,#4
000018  1840              ADDS     r0,r0,r1
;;;370                u32Cfg = *((__IO uint32_t *) (u32CfgAddr));
00001a  6801              LDR      r1,[r0,#0]
;;;371    
;;;372                *((__IO uint32_t *) (u32CfgAddr)) = (u32Cfg | USBD_CFGP_SSTALL);
00001c  2202              MOVS     r2,#2
00001e  4311              ORRS     r1,r1,r2
000020  6001              STR      r1,[r0,#0]
;;;373                break;
;;;374            }
;;;375        }
;;;376    }
000022  4770              BX       lr
                  |L18.36|
000024  1c49              ADDS     r1,r1,#1              ;362
000026  2908              CMP      r1,#8                 ;362
000028  dbec              BLT      |L18.4|
00002a  4770              BX       lr
;;;377    
                          ENDP

                  |L18.44|
                          DCD      0x40060028

                          AREA ||i.get_be32||, CODE, READONLY, ALIGN=1

                  get_be32 PROC
;;;76     
;;;77     static __INLINE uint32_t get_be32(uint8_t *buf)
000000  b510              PUSH     {r4,lr}
;;;78     {
000002  4604              MOV      r4,r0
;;;79         return ((uint32_t) buf[0] << 24) | ((uint32_t) buf[1] << 16) |
000004  f7fffffe          BL       __aeabi_uread4
000008  ba00              REV      r0,r0
00000a  0a00              LSRS     r0,r0,#8
00000c  78e1              LDRB     r1,[r4,#3]
00000e  0200              LSLS     r0,r0,#8
000010  4308              ORRS     r0,r0,r1
;;;80                ((uint32_t) buf[2] << 8) | ((uint32_t) buf[3]);
;;;81     }
000012  bd10              POP      {r4,pc}
;;;82     
                          ENDP


                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  g_sCBW
                          %        32
                  g_sCSW
                          %        16
                  MassBlock
                          %        48
                  Storage_Block
                          %        512

                          AREA ||.data||, DATA, ALIGN=2

                  g_u8EP2Ready
000000  00                DCB      0x00
                  g_u8EP3Ready
000001  00                DCB      0x00
                  g_u8Prevent
000002  00                DCB      0x00
                  g_u8BulkState
000003  00                DCB      0x00
                  g_u8Size
000004  00000000          DCB      0x00,0x00,0x00,0x00
                  g_TotalSectors
                          DCD      0x00000000
                  g_au8SenseKey
                          DCD      0x00000000
                  g_u32DataFlashStartAddr
                          DCD      0x00000000
                  g_u32Address
                          DCD      0x00000000
                  g_u32Length
                          DCD      0x00000000
                  g_u32LbaAddress
                          DCD      0x00000000
                  g_u32BytesInStorageBuf
                          DCD      0x00000000
                  g_u32BulkBuf0
                          DCD      0x00000000
                  g_u32BulkBuf1
                          DCD      0x00000000
                  g_au8ModePage_1C
00002c  1c060005          DCB      0x1c,0x06,0x00,0x05
000030  00000000          DCB      0x00,0x00,0x00,0x00
                  g_au8InquiryID
000034  00800000          DCB      0x00,0x80,0x00,0x00
000038  1f000000          DCB      0x1f,0x00,0x00,0x00
00003c  4e75766f          DCB      0x4e,0x75,0x76,0x6f
000040  746f6e20          DCB      0x74,0x6f,0x6e,0x20
000044  55534220          DCB      0x55,0x53,0x42,0x20
000048  4d617373          DCB      0x4d,0x61,0x73,0x73
00004c  2053746f          DCB      0x20,0x53,0x74,0x6f
000050  72616765          DCB      0x72,0x61,0x67,0x65
000054  312e3030          DCB      0x31,0x2e,0x30,0x30
                  g_au8ModePage_01
000058  010a0003          DCB      0x01,0x0a,0x00,0x03
00005c  00000000          DCB      0x00,0x00,0x00,0x00
000060  03000000          DCB      0x03,0x00,0x00,0x00
                  g_au8ModePage_05
000064  051e1388          DCB      0x05,0x1e,0x13,0x88
000068  08200200          DCB      0x08,0x20,0x02,0x00
00006c  01f40000          DCB      0x01,0xf4,0x00,0x00
000070  00000000          DCB      0x00,0x00,0x00,0x00
000074  00000005          DCB      0x00,0x00,0x00,0x05
000078  1e000000          DCB      0x1e,0x00,0x00,0x00
00007c  00000000          DCB      0x00,0x00,0x00,0x00
000080  01680000          DCB      0x01,0x68,0x00,0x00
                  g_au8ModePage_1B
000084  1b0a0001          DCB      0x1b,0x0a,0x00,0x01
000088  00000000          DCB      0x00,0x00,0x00,0x00
00008c  00000000          DCB      0x00,0x00,0x00,0x00

;*** Start embedded assembler ***

#line 1 "..\\MassStorage.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___13_MassStorage_c_3ebb586c____REV16|
#line 118 "..\\..\\..\\..\\Library\\CMSIS\\Include\\core_cmInstr.h"
|__asm___13_MassStorage_c_3ebb586c____REV16| PROC
#line 119

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___13_MassStorage_c_3ebb586c____REVSH|
#line 132
|__asm___13_MassStorage_c_3ebb586c____REVSH| PROC
#line 133

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
