📄 msd.txt
字号:
;;;66 /* rise CS and MOSI for 80 clocks cycles */
;;;67 for (i = 0; i <= 9; i++)
;;;68 {
;;;69 /* Send dummy byte 0xFF */
;;;70 MSD_WriteByte(DUMMY);
000012 20ff MOVS r0,#0xff
000014 f7fffffe BL MSD_WriteByte
000018 1c64 ADDS r4,r4,#1 ;67
00001a 2c09 CMP r4,#9 ;67
00001c d9f9 BLS |L7.18|
;;;71 }
;;;72 /*------------Put MSD in SPI mode--------------*/
;;;73 /* MSD initialized and set to SPI mode properly */
;;;74 return (MSD_GoIdleState());
00001e e8bd4010 POP {r4,lr}
000022 f7ffbffe B.W MSD_GoIdleState
;;;75 }
;;;76
ENDP
000026 0000 DCW 0x0000
|L7.40|
000028 40011800 DCD 0x40011800
AREA ||i.MSD_GetDataResponse||, CODE, READONLY, ALIGN=1
MSD_GetDataResponse PROC
;;;554 u8 MSD_GetDataResponse(void)
;;;555 {
000000 b570 PUSH {r4-r6,lr}
;;;556 u32 i = 0;
000002 2500 MOVS r5,#0
|L8.4|
;;;557 u8 response, rvalue;
;;;558
;;;559 while (i <= 64)
;;;560 {
;;;561 /* Read resonse */
;;;562 response = MSD_ReadByte();
000004 f7fffffe BL MSD_ReadByte
;;;563 /* Mask unused bits */
;;;564 response &= 0x1F;
000008 f000041f AND r4,r0,#0x1f
;;;565
;;;566 switch (response)
00000c 2c05 CMP r4,#5
00000e d00a BEQ |L8.38|
000010 2c0b CMP r4,#0xb
000012 d003 BEQ |L8.28|
000014 2c0d CMP r4,#0xd
000016 d103 BNE |L8.32|
;;;567 {
;;;568 case MSD_DATA_OK:
;;;569 {
;;;570 rvalue = MSD_DATA_OK;
;;;571 break;
;;;572 }
;;;573
;;;574 case MSD_DATA_CRC_ERROR:
;;;575 return MSD_DATA_CRC_ERROR;
;;;576
;;;577 case MSD_DATA_WRITE_ERROR:
;;;578 return MSD_DATA_WRITE_ERROR;
000018 200d MOVS r0,#0xd
;;;579
;;;580 default:
;;;581 {
;;;582 rvalue = MSD_DATA_OTHER_ERROR;
;;;583 break;
;;;584 }
;;;585 }
;;;586 /* Exit loop in case of data ok */
;;;587 if (rvalue == MSD_DATA_OK)
;;;588 break;
;;;589 /* Increment loop counter */
;;;590 i++;
;;;591 }
;;;592 /* Wait null data */
;;;593 while (MSD_ReadByte() == 0);
;;;594 /* Return response */
;;;595 return response;
;;;596 }
00001a bd70 POP {r4-r6,pc}
|L8.28|
00001c 200b MOVS r0,#0xb ;575
00001e bd70 POP {r4-r6,pc}
|L8.32|
000020 1c6d ADDS r5,r5,#1 ;590
000022 2d40 CMP r5,#0x40 ;559
000024 d9ee BLS |L8.4|
|L8.38|
000026 f7fffffe BL MSD_ReadByte
00002a 2800 CMP r0,#0 ;593
00002c d0fb BEQ |L8.38|
00002e 4620 MOV r0,r4 ;595
000030 bd70 POP {r4-r6,pc}
;;;597
ENDP
AREA ||i.MSD_WriteBlock||, CODE, READONLY, ALIGN=2
MSD_WriteBlock PROC
;;;88 u8 MSD_WriteBlock(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
;;;89 {
000000 e92d47f0 PUSH {r4-r10,lr}
;;;90 u32 i = 0;
;;;91 u8 rvalue = MSD_RESPONSE_FAILURE;
;;;92
;;;93 /* MSD chip select low */
;;;94 MSD_CS_LOW();
000004 f8df8068 LDR r8,|L9.112|
000008 4605 MOV r5,r0 ;89
00000a 4689 MOV r9,r1 ;89
00000c 4616 MOV r6,r2 ;89
00000e 2400 MOVS r4,#0 ;90
000010 27ff MOVS r7,#0xff ;91
000012 2108 MOVS r1,#8
000014 4640 MOV r0,r8
000016 f7fffffe BL GPIO_ResetBits
;;;95 /* Send CMD24 (MSD_WRITE_BLOCK) to write multiple block */
;;;96 MSD_SendCmd(MSD_WRITE_BLOCK, WriteAddr, 0xFF);
00001a 22ff MOVS r2,#0xff
00001c 4649 MOV r1,r9
00001e 2018 MOVS r0,#0x18
000020 f7fffffe BL MSD_SendCmd
;;;97
;;;98 /* Check if the MSD acknowledged the write block command: R1 response (0x00: no errors) */
;;;99 if (!MSD_GetResponse(MSD_RESPONSE_NO_ERROR))
000024 2000 MOVS r0,#0
000026 f7fffffe BL MSD_GetResponse
00002a b9b0 CBNZ r0,|L9.90|
;;;100 {
;;;101 /* Send a dummy byte */
;;;102 MSD_WriteByte(DUMMY);
00002c 20ff MOVS r0,#0xff
00002e f7fffffe BL MSD_WriteByte
;;;103 /* Send the data token to signify the start of the data */
;;;104 MSD_WriteByte(0xFE);
000032 20fe MOVS r0,#0xfe
000034 f7fffffe BL MSD_WriteByte
;;;105 /* Write the block data to MSD : write count data by block */
;;;106 for (i = 0; i < NumByteToWrite; i++)
000038 e004 B |L9.68|
|L9.58|
;;;107 {
;;;108 /* Send the pointed byte */
;;;109 MSD_WriteByte(*pBuffer);
00003a 7828 LDRB r0,[r5,#0]
00003c f7fffffe BL MSD_WriteByte
;;;110 /* Point to the next location where the byte read will be saved */
;;;111 pBuffer++;
000040 1c6d ADDS r5,r5,#1
000042 1c64 ADDS r4,r4,#1 ;106
|L9.68|
000044 42b4 CMP r4,r6 ;106
000046 d3f8 BCC |L9.58|
;;;112 }
;;;113 /* Put CRC bytes (not really needed by us, but required by MSD) */
;;;114 MSD_ReadByte();
000048 f7fffffe BL MSD_ReadByte
;;;115 MSD_ReadByte();
00004c f7fffffe BL MSD_ReadByte
;;;116 /* Read data response */
;;;117 if (MSD_GetDataResponse() == MSD_DATA_OK)
000050 f7fffffe BL MSD_GetDataResponse
000054 2805 CMP r0,#5
000056 d100 BNE |L9.90|
;;;118 {
;;;119 rvalue = MSD_RESPONSE_NO_ERROR;
000058 2700 MOVS r7,#0
|L9.90|
;;;120 }
;;;121 }
;;;122
;;;123 /* MSD chip select high */
;;;124 MSD_CS_HIGH();
00005a 2108 MOVS r1,#8
00005c 4640 MOV r0,r8
00005e f7fffffe BL GPIO_SetBits
;;;125 /* Send dummy byte: 8 Clock pulses of delay */
;;;126 MSD_WriteByte(DUMMY);
000062 20ff MOVS r0,#0xff
000064 f7fffffe BL MSD_WriteByte
;;;127 /* Returns the reponse */
;;;128 return rvalue;
000068 4638 MOV r0,r7
;;;129 }
00006a e8bd87f0 POP {r4-r10,pc}
;;;130
ENDP
00006e 0000 DCW 0x0000
|L9.112|
000070 40011800 DCD 0x40011800
AREA ||i.MSD_ReadBlock||, CODE, READONLY, ALIGN=2
MSD_ReadBlock PROC
;;;142 u8 MSD_ReadBlock(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
;;;143 {
000000 e92d47f0 PUSH {r4-r10,lr}
;;;144 u32 i = 0;
;;;145 u8 rvalue = MSD_RESPONSE_FAILURE;
;;;146
;;;147 /* MSD chip select low */
;;;148 MSD_CS_LOW();
000004 4f18 LDR r7,|L10.104|
000006 4605 MOV r5,r0 ;143
000008 4689 MOV r9,r1 ;143
00000a 4616 MOV r6,r2 ;143
00000c 2400 MOVS r4,#0 ;144
00000e f04f08ff MOV r8,#0xff ;145
000012 2108 MOVS r1,#8
000014 4638 MOV r0,r7
000016 f7fffffe BL GPIO_ResetBits
;;;149 /* Send CMD17 (MSD_READ_SINGLE_BLOCK) to read one block */
;;;150 MSD_SendCmd(MSD_READ_SINGLE_BLOCK, ReadAddr, 0xFF);
00001a 22ff MOVS r2,#0xff
00001c 4649 MOV r1,r9
00001e 2011 MOVS r0,#0x11
000020 f7fffffe BL MSD_SendCmd
;;;151
;;;152 /* Check if the MSD acknowledged the read block command: R1 response (0x00: no errors) */
;;;153 if (!MSD_GetResponse(MSD_RESPONSE_NO_ERROR))
000024 2000 MOVS r0,#0
000026 f7fffffe BL MSD_GetResponse
00002a b990 CBNZ r0,|L10.82|
;;;154 {
;;;155 /* Now look for the data token to signify the start of the data */
;;;156 if (!MSD_GetResponse(MSD_START_DATA_SINGLE_BLOCK_READ))
00002c 20fe MOVS r0,#0xfe
00002e f7fffffe BL MSD_GetResponse
000032 b970 CBNZ r0,|L10.82|
000034 e005 B |L10.66|
;;;157 {
;;;158 /* Read the MSD block data : read NumByteToRead data */
;;;159 for (i = 0; i < NumByteToRead; i++)
;;;160 {
;;;161 /* Save the received data */
;;;162 *pBuffer = MSD_ReadByte();
000036 bf00 NOP
|L10.56|
000038 f7fffffe BL MSD_ReadByte
00003c f8050b01 STRB r0,[r5],#1
000040 1c64 ADDS r4,r4,#1 ;159
|L10.66|
000042 42b4 CMP r4,r6 ;159
000044 d3f8 BCC |L10.56|
;;;163 /* Point to the next location where the byte read will be saved */
;;;164 pBuffer++;
;;;165 }
;;;166 /* Get CRC bytes (not really needed by us, but required by MSD) */
;;;167 MSD_ReadByte();
000046 f7fffffe BL MSD_ReadByte
;;;168 MSD_ReadByte();
00004a f7fffffe BL MSD_ReadByte
;;;169 /* Set response value to success */
;;;170 rvalue = MSD_RESPONSE_NO_ERROR;
00004e f04f0800 MOV r8,#0
|L10.82|
;;;171 }
;;;172 }
;;;173
;;;174 /* MSD chip select high */
;;;175 MSD_CS_HIGH();
000052 2108 MOVS r1,#8
000054 4638 MOV r0,r7
000056 f7fffffe BL GPIO_SetBits
;;;176 /* Send dummy byte: 8 Clock pulses of delay */
;;;177 MSD_WriteByte(DUMMY);
00005a 20ff MOVS r0,#0xff
00005c f7fffffe BL MSD_WriteByte
;;;178 /* Returns the reponse */
;;;179 return rvalue;
000060 4640 MOV r0,r8
;;;180 }
000062 e8bd87f0 POP {r4-r10,pc}
;;;181
ENDP
000066 0000 DCW 0x0000
|L10.104|
000068 40011800 DCD 0x40011800
AREA ||i.MSD_WriteBuffer||, CODE, READONLY, ALIGN=2
MSD_WriteBuffer PROC
;;;193 u8 MSD_WriteBuffer(u8* pBuffer, u32 WriteAddr, u32 NumByteToWrite)
;;;194 {
000000 e92d47f0 PUSH {r4-r10,lr}
;;;195 u32 i = 0, NbrOfBlock = 0, Offset = 0;
;;;196 u8 rvalue = MSD_RESPONSE_FAILURE;
;;;197
;;;198 /* Calculate number of blocks to write */
;;;199 NbrOfBlock = NumByteToWrite / BLOCK_SIZE;
;;;200 /* MSD chip select low */
;;;201 MSD_CS_LOW();
000004 f8dfa080 LDR r10,|L11.136|
000008 4605 MOV r5,r0 ;194
00000a 4689 MOV r9,r1 ;194
00000c 2600 MOVS r6,#0 ;195
00000e 24ff MOVS r4,#0xff ;196
000010 0a57 LSRS r7,r2,#9 ;199
000012 2108 MOVS r1,#8
000014 4650 MOV r0,r10
000016 f7fffffe BL GPIO_ResetBits
;;;202
;;;203 /* Data transfer */
;;;204 while (NbrOfBlock --)
00001a e02a B |L11.114|
|L11.28|
;;;205 {
;;;206 /* Send CMD24 (MSD_WRITE_BLOCK) to write blocks */
;;;207 MSD_SendCmd(MSD_WRITE_BLOCK, WriteAddr + Offset, 0xFF);
00001c eb090106 ADD r1,r9,r6
000020 22ff MOVS r2,#0xff
000022 2018 MOVS r0,#0x18
000024 f7fffffe BL MSD_SendCmd
;;;208
;;;209 /* Check if the MSD acknowledged the write block command: R1 response (0x00: no errors) */
;;;210 if (MSD_GetResponse(MSD_RESPONSE_NO_ERROR))
000028 2000 MOVS r0,#0
00002a f7fffffe BL MSD_GetResponse
00002e 2800 CMP r0,#0
;;;211 {
;;;212 return MSD_RESPONSE_FAILURE;
000030 f04f00ff MOV r0,#0xff
000034 d001 BEQ |L11.58|
|L11.54|
;;;213 }
;;;214 /* Send dummy byte */
;;;215 MSD_WriteByte(DUMMY);
;;;216 /* Send the data token to signify the start of the data */
;;;217 MSD_WriteByte(MSD_START_DATA_SINGLE_BLOCK_WRITE);
;;;218 /* Write the block data to MSD : write count data by block */
;;;219 for (i = 0; i < BLOCK_SIZE; i++)
;;;220 {
;;;221 /* Send the pointed byte */
;;;222 MSD_WriteByte(*pBuffer);
;;;223 /* Point to the next location where the byte read will be saved */
;;;224 pBuffer++;
;;;225 }
;;;226 /* Set next write address */
;;;227 Offset += 512;
;;;228 /* Put CRC bytes (not really needed by us, but required by MSD) */
;;;229 MSD_ReadByte();
;;;230 MSD_ReadByte();
;;;231 /* Read data response */
;;;232 if (MSD_GetDataResponse() == MSD_DATA_OK)
;;;233 {
;;;234 /* Set response value to success */
;;;235 rvalue = MSD_RESPONSE_NO_ERROR;
;;;236 }
;;;237 else
;;;238 {
;;;239 /* Set response value to failure */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -