; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\STM324xG_EVAL\stm324xg_eval_ioe.o --asm_dir=.\STM324xG_EVAL\ --list_dir=.\STM324xG_EVAL\ --depend=.\STM324xG_EVAL\stm324xg_eval_ioe.d --cpu=Cortex-M4.fp --apcs=interwork -O0 -Otime -I..\ -I..\..\..\Libraries\CMSIS\Device\ST\STM32F4xx\Include -I..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\Utilities\STM32_EVAL\Common -I..\..\..\Utilities\STM32_EVAL\STM3240_41_G_EVAL -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\ST\STM32F4xx -D__MICROLIB -DUSE_STM324xG_EVAL -DSTM32F4XX -DUSE_STDPERIPH_DRIVER --omf_browse=.\STM324xG_EVAL\stm324xg_eval_ioe.crf ..\..\..\Utilities\STM32_EVAL\STM3240_41_G_EVAL\stm324xg_eval_ioe.c]
                          THUMB

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

                  I2C_ReadDataBuffer PROC
;;;1239     */
;;;1240   uint16_t I2C_ReadDataBuffer(uint8_t DeviceAddr, uint32_t RegisterAddr)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1241   { 
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;1242     uint8_t tmp= 0;
000006  2600              MOVS     r6,#0
;;;1243     uint8_t IOE_BufferRX[2] = {0x00, 0x00};  
000008  2000              MOVS     r0,#0
00000a  9000              STR      r0,[sp,#0]
;;;1244     
;;;1245     /* Configure DMA Peripheral */
;;;1246     IOE_DMA_Config(IOE_DMA_RX, (uint8_t*)IOE_BufferRX);
00000c  4669              MOV      r1,sp
00000e  2001              MOVS     r0,#1
000010  f7fffffe          BL       IOE_DMA_Config
;;;1247     
;;;1248     /* Enable DMA NACK automatic generation */
;;;1249     I2C_DMALastTransferCmd(IOE_I2C, ENABLE);
000014  2101              MOVS     r1,#1
000016  485e              LDR      r0,|L1.400|
000018  f7fffffe          BL       I2C_DMALastTransferCmd
;;;1250     
;;;1251     /* Enable the I2C peripheral */
;;;1252     I2C_GenerateSTART(IOE_I2C, ENABLE);
00001c  2101              MOVS     r1,#1
00001e  485c              LDR      r0,|L1.400|
000020  f7fffffe          BL       I2C_GenerateSTART
;;;1253     
;;;1254     /* Test on SB Flag */
;;;1255     IOE_TimeOut = TIMEOUT_MAX;
000024  f44f5040          MOV      r0,#0x3000
000028  495a              LDR      r1,|L1.404|
00002a  6008              STR      r0,[r1,#0]  ; IOE_TimeOut
;;;1256     while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB)) 
00002c  e008              B        |L1.64|
                  |L1.46|
;;;1257     {
;;;1258       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
00002e  4859              LDR      r0,|L1.404|
000030  6801              LDR      r1,[r0,#0]  ; IOE_TimeOut
000032  6800              LDR      r0,[r0,#0]  ; IOE_TimeOut
000034  1e40              SUBS     r0,r0,#1
000036  4a57              LDR      r2,|L1.404|
000038  6010              STR      r0,[r2,#0]  ; IOE_TimeOut
00003a  b909              CBNZ     r1,|L1.64|
00003c  2002              MOVS     r0,#2
                  |L1.62|
;;;1259     }
;;;1260     
;;;1261     /* Send device address for write */
;;;1262     I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Transmitter);
;;;1263     
;;;1264     /* Test on ADDR Flag */
;;;1265     IOE_TimeOut = TIMEOUT_MAX;
;;;1266     while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
;;;1267     {
;;;1268       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1269     }
;;;1270     
;;;1271     /* Send the device's internal address to write to */
;;;1272     I2C_SendData(IOE_I2C, RegisterAddr);  
;;;1273     
;;;1274     /* Test on TXE FLag (data dent) */
;;;1275     IOE_TimeOut = TIMEOUT_MAX;
;;;1276     while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))  
;;;1277     {
;;;1278       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1279     }
;;;1280     
;;;1281     /* Send START condition a second time */  
;;;1282     I2C_GenerateSTART(IOE_I2C, ENABLE);
;;;1283     
;;;1284     /* Test on SB Flag */
;;;1285     IOE_TimeOut = TIMEOUT_MAX;
;;;1286     while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB)) 
;;;1287     {
;;;1288       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1289     }
;;;1290     
;;;1291     /* Send IOExpander address for read */
;;;1292     I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Receiver);
;;;1293     
;;;1294     /* Test on ADDR Flag */
;;;1295     IOE_TimeOut = TIMEOUT_MAX;
;;;1296     while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))   
;;;1297     {
;;;1298       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1299     }
;;;1300     
;;;1301     /* Enable I2C DMA request */
;;;1302     I2C_DMACmd(IOE_I2C,ENABLE);
;;;1303     
;;;1304     /* Enable DMA RX Channel */
;;;1305     DMA_Cmd(IOE_DMA_RX_STREAM, ENABLE);
;;;1306     
;;;1307     /* Wait until DMA Transfer Complete */
;;;1308     IOE_TimeOut = 2 * TIMEOUT_MAX;
;;;1309     while (!DMA_GetFlagStatus(IOE_DMA_RX_STREAM, IOE_DMA_RX_TCFLAG))
;;;1310     {
;;;1311       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1312     }        
;;;1313     
;;;1314     /* Send STOP Condition */
;;;1315     I2C_GenerateSTOP(IOE_I2C, ENABLE);
;;;1316     
;;;1317     /* Disable DMA RX Channel */
;;;1318     DMA_Cmd(IOE_DMA_RX_STREAM, DISABLE);
;;;1319     
;;;1320     /* Disable I2C DMA request */  
;;;1321     I2C_DMACmd(IOE_I2C,DISABLE);
;;;1322     
;;;1323     /* Clear DMA RX Transfer Complete Flag */
;;;1324     DMA_ClearFlag(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG);
;;;1325     
;;;1326     /* Reorganize received data */  
;;;1327     tmp = IOE_BufferRX[0];
;;;1328     IOE_BufferRX[0] = IOE_BufferRX[1];
;;;1329     IOE_BufferRX[1] = tmp;
;;;1330     
;;;1331     /* return a pointer to the IOE_Buffer */
;;;1332     return *(uint16_t *)IOE_BufferRX; 
;;;1333   }
00003e  bdf8              POP      {r3-r7,pc}
                  |L1.64|
000040  4955              LDR      r1,|L1.408|
000042  4853              LDR      r0,|L1.400|
000044  f7fffffe          BL       I2C_GetFlagStatus
000048  2800              CMP      r0,#0                 ;1256
00004a  d0f0              BEQ      |L1.46|
00004c  2200              MOVS     r2,#0                 ;1262
00004e  4621              MOV      r1,r4                 ;1262
000050  484f              LDR      r0,|L1.400|
000052  f7fffffe          BL       I2C_Send7bitAddress
000056  f44f5040          MOV      r0,#0x3000            ;1265
00005a  494e              LDR      r1,|L1.404|
00005c  6008              STR      r0,[r1,#0]            ;1265  ; IOE_TimeOut
00005e  e008              B        |L1.114|
                  |L1.96|
000060  484c              LDR      r0,|L1.404|
000062  6801              LDR      r1,[r0,#0]            ;1268  ; IOE_TimeOut
000064  6800              LDR      r0,[r0,#0]            ;1268  ; IOE_TimeOut
000066  1e40              SUBS     r0,r0,#1              ;1268
000068  4a4a              LDR      r2,|L1.404|
00006a  6010              STR      r0,[r2,#0]            ;1268  ; IOE_TimeOut
00006c  b909              CBNZ     r1,|L1.114|
00006e  2002              MOVS     r0,#2                 ;1268
000070  e7e5              B        |L1.62|
                  |L1.114|
000072  494a              LDR      r1,|L1.412|
000074  4846              LDR      r0,|L1.400|
000076  f7fffffe          BL       I2C_CheckEvent
00007a  2800              CMP      r0,#0                 ;1266
00007c  d0f0              BEQ      |L1.96|
00007e  b2e9              UXTB     r1,r5                 ;1272
000080  4843              LDR      r0,|L1.400|
000082  f7fffffe          BL       I2C_SendData
000086  f44f5040          MOV      r0,#0x3000            ;1275
00008a  4942              LDR      r1,|L1.404|
00008c  6008              STR      r0,[r1,#0]            ;1275  ; IOE_TimeOut
00008e  e008              B        |L1.162|
                  |L1.144|
000090  4840              LDR      r0,|L1.404|
000092  6801              LDR      r1,[r0,#0]            ;1278  ; IOE_TimeOut
000094  6800              LDR      r0,[r0,#0]            ;1278  ; IOE_TimeOut
000096  1e40              SUBS     r0,r0,#1              ;1278
000098  4a3e              LDR      r2,|L1.404|
00009a  6010              STR      r0,[r2,#0]            ;1278  ; IOE_TimeOut
00009c  b909              CBNZ     r1,|L1.162|
00009e  2002              MOVS     r0,#2                 ;1278
0000a0  e7cd              B        |L1.62|
                  |L1.162|
0000a2  493d              LDR      r1,|L1.408|
0000a4  317f              ADDS     r1,r1,#0x7f           ;1276
0000a6  483a              LDR      r0,|L1.400|
0000a8  f7fffffe          BL       I2C_GetFlagStatus
0000ac  b930              CBNZ     r0,|L1.188|
0000ae  493a              LDR      r1,|L1.408|
0000b0  1cc9              ADDS     r1,r1,#3              ;1276
0000b2  4837              LDR      r0,|L1.400|
0000b4  f7fffffe          BL       I2C_GetFlagStatus
0000b8  2800              CMP      r0,#0                 ;1276
0000ba  d0e9              BEQ      |L1.144|
                  |L1.188|
0000bc  2101              MOVS     r1,#1                 ;1282
0000be  4834              LDR      r0,|L1.400|
0000c0  f7fffffe          BL       I2C_GenerateSTART
0000c4  f44f5040          MOV      r0,#0x3000            ;1285
0000c8  4932              LDR      r1,|L1.404|
0000ca  6008              STR      r0,[r1,#0]            ;1285  ; IOE_TimeOut
0000cc  e008              B        |L1.224|
                  |L1.206|
0000ce  4831              LDR      r0,|L1.404|
0000d0  6801              LDR      r1,[r0,#0]            ;1288  ; IOE_TimeOut
0000d2  6800              LDR      r0,[r0,#0]            ;1288  ; IOE_TimeOut
0000d4  1e40              SUBS     r0,r0,#1              ;1288
0000d6  4a2f              LDR      r2,|L1.404|
0000d8  6010              STR      r0,[r2,#0]            ;1288  ; IOE_TimeOut
0000da  b909              CBNZ     r1,|L1.224|
0000dc  2002              MOVS     r0,#2                 ;1288
0000de  e7ae              B        |L1.62|
                  |L1.224|
0000e0  492d              LDR      r1,|L1.408|
0000e2  482b              LDR      r0,|L1.400|
0000e4  f7fffffe          BL       I2C_GetFlagStatus
0000e8  2800              CMP      r0,#0                 ;1286
0000ea  d0f0              BEQ      |L1.206|
0000ec  2201              MOVS     r2,#1                 ;1292
0000ee  4621              MOV      r1,r4                 ;1292
0000f0  4827              LDR      r0,|L1.400|
0000f2  f7fffffe          BL       I2C_Send7bitAddress
0000f6  f44f5040          MOV      r0,#0x3000            ;1295
0000fa  4926              LDR      r1,|L1.404|
0000fc  6008              STR      r0,[r1,#0]            ;1295  ; IOE_TimeOut
0000fe  e008              B        |L1.274|
                  |L1.256|
000100  4824              LDR      r0,|L1.404|
000102  6801              LDR      r1,[r0,#0]            ;1298  ; IOE_TimeOut
000104  6800              LDR      r0,[r0,#0]            ;1298  ; IOE_TimeOut
000106  1e40              SUBS     r0,r0,#1              ;1298
000108  4a22              LDR      r2,|L1.404|
00010a  6010              STR      r0,[r2,#0]            ;1298  ; IOE_TimeOut
00010c  b909              CBNZ     r1,|L1.274|
00010e  2002              MOVS     r0,#2                 ;1298
000110  e795              B        |L1.62|
                  |L1.274|
000112  4923              LDR      r1,|L1.416|
000114  481e              LDR      r0,|L1.400|
000116  f7fffffe          BL       I2C_CheckEvent
00011a  2800              CMP      r0,#0                 ;1296
00011c  d0f0              BEQ      |L1.256|
00011e  2101              MOVS     r1,#1                 ;1302
000120  481b              LDR      r0,|L1.400|
000122  f7fffffe          BL       I2C_DMACmd
000126  2101              MOVS     r1,#1                 ;1305
000128  481e              LDR      r0,|L1.420|
00012a  f7fffffe          BL       DMA_Cmd
00012e  f44f40c0          MOV      r0,#0x6000            ;1308
000132  4918              LDR      r1,|L1.404|
000134  6008              STR      r0,[r1,#0]            ;1308  ; IOE_TimeOut
000136  e008              B        |L1.330|
                  |L1.312|
000138  4816              LDR      r0,|L1.404|
00013a  6801              LDR      r1,[r0,#0]            ;1311  ; IOE_TimeOut
00013c  6800              LDR      r0,[r0,#0]            ;1311  ; IOE_TimeOut
00013e  1e40              SUBS     r0,r0,#1              ;1311
000140  4a14              LDR      r2,|L1.404|
000142  6010              STR      r0,[r2,#0]            ;1311  ; IOE_TimeOut
000144  b909              CBNZ     r1,|L1.330|
000146  2002              MOVS     r0,#2                 ;1311
000148  e779              B        |L1.62|
                  |L1.330|
00014a  4913              LDR      r1,|L1.408|
00014c  311f              ADDS     r1,r1,#0x1f           ;1309
00014e  4815              LDR      r0,|L1.420|
000150  f7fffffe          BL       DMA_GetFlagStatus
000154  2800              CMP      r0,#0                 ;1309
000156  d0ef              BEQ      |L1.312|
000158  2101              MOVS     r1,#1                 ;1315
00015a  480d              LDR      r0,|L1.400|
00015c  f7fffffe          BL       I2C_GenerateSTOP
000160  2100              MOVS     r1,#0                 ;1318
000162  4810              LDR      r0,|L1.420|
000164  f7fffffe          BL       DMA_Cmd
000168  2100              MOVS     r1,#0                 ;1321
00016a  4809              LDR      r0,|L1.400|
00016c  f7fffffe          BL       I2C_DMACmd
000170  4909              LDR      r1,|L1.408|
000172  311f              ADDS     r1,r1,#0x1f           ;1324
000174  480b              LDR      r0,|L1.420|
000176  f7fffffe          BL       DMA_ClearFlag
00017a  f89d6000          LDRB     r6,[sp,#0]            ;1327
00017e  f89d0001          LDRB     r0,[sp,#1]            ;1328
000182  f88d0000          STRB     r0,[sp,#0]            ;1328
000186  f88d6001          STRB     r6,[sp,#1]            ;1329
00018a  f8bd0000          LDRH     r0,[sp,#0]            ;1332
00018e  e756              B        |L1.62|
;;;1334   
                          ENDP

                  |L1.400|
                          DCD      0x40005400
                  |L1.404|
                          DCD      IOE_TimeOut
                  |L1.408|
                          DCD      0x10000001
                  |L1.412|
                          DCD      0x00070082
                  |L1.416|
                          DCD      0x00030002
                  |L1.420|
                          DCD      0x40026010

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

                  I2C_ReadDeviceRegister PROC
;;;1142     */
;;;1143   uint8_t I2C_ReadDeviceRegister(uint8_t DeviceAddr, uint8_t RegisterAddr)
000000  b538              PUSH     {r3-r5,lr}
;;;1144   {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;1145     uint8_t IOE_BufferRX[2] = {0x00, 0x00};  
000006  2000              MOVS     r0,#0
000008  9000              STR      r0,[sp,#0]
;;;1146     
;;;1147     /* Configure DMA Peripheral */
;;;1148     IOE_DMA_Config(IOE_DMA_RX, (uint8_t*)IOE_BufferRX);
00000a  4669              MOV      r1,sp
00000c  2001              MOVS     r0,#1
00000e  f7fffffe          BL       IOE_DMA_Config
;;;1149     
;;;1150     /* Enable DMA NACK automatic generation */
;;;1151     I2C_DMALastTransferCmd(IOE_I2C, ENABLE);
000012  2101              MOVS     r1,#1
000014  485a              LDR      r0,|L2.384|
000016  f7fffffe          BL       I2C_DMALastTransferCmd
;;;1152     
;;;1153     /* Enable the I2C peripheral */
;;;1154     I2C_GenerateSTART(IOE_I2C, ENABLE);
00001a  2101              MOVS     r1,#1
00001c  4858              LDR      r0,|L2.384|
00001e  f7fffffe          BL       I2C_GenerateSTART
;;;1155     
;;;1156     /* Test on SB Flag */
;;;1157     IOE_TimeOut = TIMEOUT_MAX;
000022  f44f5040          MOV      r0,#0x3000
000026  4957              LDR      r1,|L2.388|
000028  6008              STR      r0,[r1,#0]  ; IOE_TimeOut
;;;1158     while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB)) 
00002a  e008              B        |L2.62|
                  |L2.44|
;;;1159     {
;;;1160       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
00002c  4855              LDR      r0,|L2.388|
00002e  6801              LDR      r1,[r0,#0]  ; IOE_TimeOut
000030  6800              LDR      r0,[r0,#0]  ; IOE_TimeOut
000032  1e40              SUBS     r0,r0,#1
000034  4a53              LDR      r2,|L2.388|
000036  6010              STR      r0,[r2,#0]  ; IOE_TimeOut
000038  b909              CBNZ     r1,|L2.62|
00003a  2002              MOVS     r0,#2
                  |L2.60|
;;;1161     }
;;;1162     
;;;1163     /* Send device address for write */
;;;1164     I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Transmitter);
;;;1165     
;;;1166     /* Test on ADDR Flag */
;;;1167     IOE_TimeOut = TIMEOUT_MAX;
;;;1168     while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) 
;;;1169     {
;;;1170       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1171     }
;;;1172     
;;;1173     /* Send the device's internal address to write to */
;;;1174     I2C_SendData(IOE_I2C, RegisterAddr);  
;;;1175     
;;;1176     /* Test on TXE FLag (data dent) */
;;;1177     IOE_TimeOut = TIMEOUT_MAX;
;;;1178     while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))  
;;;1179     {
;;;1180       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1181     }
;;;1182     
;;;1183     /* Send START condition a second time */  
;;;1184     I2C_GenerateSTART(IOE_I2C, ENABLE);
;;;1185     
;;;1186     /* Test on SB Flag */
;;;1187     IOE_TimeOut = TIMEOUT_MAX;
;;;1188     while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB)) 
;;;1189     {
;;;1190       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1191     }
;;;1192     
;;;1193     /* Send IOExpander address for read */
;;;1194     I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Receiver);
;;;1195     
;;;1196     /* Test on ADDR Flag */
;;;1197     IOE_TimeOut = TIMEOUT_MAX;
;;;1198     while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))   
;;;1199     {
;;;1200       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1201     }
;;;1202       
;;;1203     /* Enable I2C DMA request */
;;;1204     I2C_DMACmd(IOE_I2C,ENABLE);
;;;1205     
;;;1206     /* Enable DMA RX Channel */
;;;1207     DMA_Cmd(IOE_DMA_RX_STREAM, ENABLE);
;;;1208     
;;;1209     /* Wait until DMA Transfer Complete */
;;;1210     IOE_TimeOut = 2 * TIMEOUT_MAX;
;;;1211     while (!DMA_GetFlagStatus(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG))
;;;1212     {
;;;1213       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1214     }        
;;;1215     
;;;1216     /* Send STOP Condition */
;;;1217     I2C_GenerateSTOP(IOE_I2C, ENABLE);
;;;1218     
;;;1219     /* Disable DMA RX Channel */
;;;1220     DMA_Cmd(IOE_DMA_RX_STREAM, DISABLE);
;;;1221     
;;;1222     /* Disable I2C DMA request */  
;;;1223     I2C_DMACmd(IOE_I2C,DISABLE);
;;;1224     
;;;1225     /* Clear DMA RX Transfer Complete Flag */
;;;1226    DMA_ClearFlag(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG);
;;;1227     
;;;1228     /* return a pointer to the IOE_Buffer */
;;;1229     return (uint8_t)IOE_BufferRX[0];
;;;1230   }
00003c  bd38              POP      {r3-r5,pc}
                  |L2.62|
00003e  4952              LDR      r1,|L2.392|
000040  484f              LDR      r0,|L2.384|
000042  f7fffffe          BL       I2C_GetFlagStatus
000046  2800              CMP      r0,#0                 ;1158
000048  d0f0              BEQ      |L2.44|
00004a  2200              MOVS     r2,#0                 ;1164
00004c  4621              MOV      r1,r4                 ;1164
00004e  484c              LDR      r0,|L2.384|
000050  f7fffffe          BL       I2C_Send7bitAddress
000054  f44f5040          MOV      r0,#0x3000            ;1167
000058  494a              LDR      r1,|L2.388|
00005a  6008              STR      r0,[r1,#0]            ;1167  ; IOE_TimeOut
00005c  e008              B        |L2.112|
                  |L2.94|
00005e  4849              LDR      r0,|L2.388|
000060  6801              LDR      r1,[r0,#0]            ;1170  ; IOE_TimeOut
000062  6800              LDR      r0,[r0,#0]            ;1170  ; IOE_TimeOut
000064  1e40              SUBS     r0,r0,#1              ;1170
000066  4a47              LDR      r2,|L2.388|
000068  6010              STR      r0,[r2,#0]            ;1170  ; IOE_TimeOut
00006a  b909              CBNZ     r1,|L2.112|
00006c  2002              MOVS     r0,#2                 ;1170
00006e  e7e5              B        |L2.60|
                  |L2.112|
000070  4946              LDR      r1,|L2.396|
000072  4843              LDR      r0,|L2.384|
000074  f7fffffe          BL       I2C_CheckEvent
000078  2800              CMP      r0,#0                 ;1168
00007a  d0f0              BEQ      |L2.94|
00007c  4629              MOV      r1,r5                 ;1174
00007e  4840              LDR      r0,|L2.384|
000080  f7fffffe          BL       I2C_SendData
000084  f44f5040          MOV      r0,#0x3000            ;1177
000088  493e              LDR      r1,|L2.388|
00008a  6008              STR      r0,[r1,#0]            ;1177  ; IOE_TimeOut
00008c  e008              B        |L2.160|
                  |L2.142|
00008e  483d              LDR      r0,|L2.388|
000090  6801              LDR      r1,[r0,#0]            ;1180  ; IOE_TimeOut
000092  6800              LDR      r0,[r0,#0]            ;1180  ; IOE_TimeOut
000094  1e40              SUBS     r0,r0,#1              ;1180
000096  4a3b              LDR      r2,|L2.388|
000098  6010              STR      r0,[r2,#0]            ;1180  ; IOE_TimeOut
00009a  b909              CBNZ     r1,|L2.160|
00009c  2002              MOVS     r0,#2                 ;1180
00009e  e7cd              B        |L2.60|
                  |L2.160|
0000a0  4939              LDR      r1,|L2.392|
0000a2  317f              ADDS     r1,r1,#0x7f           ;1178
0000a4  4836              LDR      r0,|L2.384|
0000a6  f7fffffe          BL       I2C_GetFlagStatus
0000aa  b930              CBNZ     r0,|L2.186|
0000ac  4936              LDR      r1,|L2.392|
0000ae  1cc9              ADDS     r1,r1,#3              ;1178
0000b0  4833              LDR      r0,|L2.384|
0000b2  f7fffffe          BL       I2C_GetFlagStatus
0000b6  2800              CMP      r0,#0                 ;1178
0000b8  d0e9              BEQ      |L2.142|
                  |L2.186|
0000ba  2101              MOVS     r1,#1                 ;1184
0000bc  4830              LDR      r0,|L2.384|
0000be  f7fffffe          BL       I2C_GenerateSTART
0000c2  f44f5040          MOV      r0,#0x3000            ;1187
0000c6  492f              LDR      r1,|L2.388|
0000c8  6008              STR      r0,[r1,#0]            ;1187  ; IOE_TimeOut
0000ca  e008              B        |L2.222|
                  |L2.204|
0000cc  482d              LDR      r0,|L2.388|
0000ce  6801              LDR      r1,[r0,#0]            ;1190  ; IOE_TimeOut
0000d0  6800              LDR      r0,[r0,#0]            ;1190  ; IOE_TimeOut
0000d2  1e40              SUBS     r0,r0,#1              ;1190
0000d4  4a2b              LDR      r2,|L2.388|
0000d6  6010              STR      r0,[r2,#0]            ;1190  ; IOE_TimeOut
0000d8  b909              CBNZ     r1,|L2.222|
0000da  2002              MOVS     r0,#2                 ;1190
0000dc  e7ae              B        |L2.60|
                  |L2.222|
0000de  492a              LDR      r1,|L2.392|
0000e0  4827              LDR      r0,|L2.384|
0000e2  f7fffffe          BL       I2C_GetFlagStatus
0000e6  2800              CMP      r0,#0                 ;1188
0000e8  d0f0              BEQ      |L2.204|
0000ea  2201              MOVS     r2,#1                 ;1194
0000ec  4621              MOV      r1,r4                 ;1194
0000ee  4824              LDR      r0,|L2.384|
0000f0  f7fffffe          BL       I2C_Send7bitAddress
0000f4  f44f5040          MOV      r0,#0x3000            ;1197
0000f8  4922              LDR      r1,|L2.388|
0000fa  6008              STR      r0,[r1,#0]            ;1197  ; IOE_TimeOut
0000fc  e008              B        |L2.272|
                  |L2.254|
0000fe  4821              LDR      r0,|L2.388|
000100  6801              LDR      r1,[r0,#0]            ;1200  ; IOE_TimeOut
000102  6800              LDR      r0,[r0,#0]            ;1200  ; IOE_TimeOut
000104  1e40              SUBS     r0,r0,#1              ;1200
000106  4a1f              LDR      r2,|L2.388|
000108  6010              STR      r0,[r2,#0]            ;1200  ; IOE_TimeOut
00010a  b909              CBNZ     r1,|L2.272|
00010c  2002              MOVS     r0,#2                 ;1200
00010e  e795              B        |L2.60|
                  |L2.272|
000110  491f              LDR      r1,|L2.400|
000112  481b              LDR      r0,|L2.384|
000114  f7fffffe          BL       I2C_CheckEvent
000118  2800              CMP      r0,#0                 ;1198
00011a  d0f0              BEQ      |L2.254|
00011c  2101              MOVS     r1,#1                 ;1204
00011e  4818              LDR      r0,|L2.384|
000120  f7fffffe          BL       I2C_DMACmd
000124  2101              MOVS     r1,#1                 ;1207
000126  481b              LDR      r0,|L2.404|
000128  f7fffffe          BL       DMA_Cmd
00012c  f44f40c0          MOV      r0,#0x6000            ;1210
000130  4914              LDR      r1,|L2.388|
000132  6008              STR      r0,[r1,#0]            ;1210  ; IOE_TimeOut
000134  e008              B        |L2.328|
                  |L2.310|
000136  4813              LDR      r0,|L2.388|
000138  6801              LDR      r1,[r0,#0]            ;1213  ; IOE_TimeOut
00013a  6800              LDR      r0,[r0,#0]            ;1213  ; IOE_TimeOut
00013c  1e40              SUBS     r0,r0,#1              ;1213
00013e  4a11              LDR      r2,|L2.388|
000140  6010              STR      r0,[r2,#0]            ;1213  ; IOE_TimeOut
000142  b909              CBNZ     r1,|L2.328|
000144  2002              MOVS     r0,#2                 ;1213
000146  e779              B        |L2.60|
                  |L2.328|
000148  490f              LDR      r1,|L2.392|
00014a  311f              ADDS     r1,r1,#0x1f           ;1211
00014c  4811              LDR      r0,|L2.404|
00014e  f7fffffe          BL       DMA_GetFlagStatus
000152  2800              CMP      r0,#0                 ;1211
000154  d0ef              BEQ      |L2.310|
000156  2101              MOVS     r1,#1                 ;1217
000158  4809              LDR      r0,|L2.384|
00015a  f7fffffe          BL       I2C_GenerateSTOP
00015e  2100              MOVS     r1,#0                 ;1220
000160  480c              LDR      r0,|L2.404|
000162  f7fffffe          BL       DMA_Cmd
000166  2100              MOVS     r1,#0                 ;1223
000168  4805              LDR      r0,|L2.384|
00016a  f7fffffe          BL       I2C_DMACmd
00016e  4906              LDR      r1,|L2.392|
000170  311f              ADDS     r1,r1,#0x1f           ;1226
000172  4808              LDR      r0,|L2.404|
000174  f7fffffe          BL       DMA_ClearFlag
000178  f89d0000          LDRB     r0,[sp,#0]            ;1229
00017c  e75e              B        |L2.60|
;;;1231   
                          ENDP

00017e  0000              DCW      0x0000
                  |L2.384|
                          DCD      0x40005400
                  |L2.388|
                          DCD      IOE_TimeOut
                  |L2.392|
                          DCD      0x10000001
                  |L2.396|
                          DCD      0x00070082
                  |L2.400|
                          DCD      0x00030002
                  |L2.404|
                          DCD      0x40026010

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

                  I2C_WriteDeviceRegister PROC
;;;1041     */
;;;1042   uint8_t I2C_WriteDeviceRegister(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t RegisterValue)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1043   {
000002  4604              MOV      r4,r0
000004  460f              MOV      r7,r1
000006  4615              MOV      r5,r2
;;;1044     uint32_t read_verif = 0;  
000008  2600              MOVS     r6,#0
;;;1045     uint8_t IOE_BufferTX = 0;
00000a  2000              MOVS     r0,#0
00000c  9000              STR      r0,[sp,#0]
;;;1046     
;;;1047     /* Get Value to be written */
;;;1048     IOE_BufferTX = RegisterValue;
00000e  9500              STR      r5,[sp,#0]
;;;1049     
;;;1050     /* Configure DMA Peripheral */
;;;1051     IOE_DMA_Config(IOE_DMA_TX, (uint8_t*)(&IOE_BufferTX));
000010  4669              MOV      r1,sp
000012  f7fffffe          BL       IOE_DMA_Config
;;;1052     
;;;1053     /* Enable the I2C peripheral */
;;;1054     I2C_GenerateSTART(IOE_I2C, ENABLE);
000016  2101              MOVS     r1,#1
000018  4844              LDR      r0,|L3.300|
00001a  f7fffffe          BL       I2C_GenerateSTART
;;;1055     
;;;1056     /* Test on SB Flag */
;;;1057     IOE_TimeOut = TIMEOUT_MAX;
00001e  f44f5040          MOV      r0,#0x3000
000022  4943              LDR      r1,|L3.304|
000024  6008              STR      r0,[r1,#0]  ; IOE_TimeOut
;;;1058     while (I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB) == RESET) 
000026  e008              B        |L3.58|
                  |L3.40|
;;;1059     {
;;;1060       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
000028  4841              LDR      r0,|L3.304|
00002a  6801              LDR      r1,[r0,#0]  ; IOE_TimeOut
00002c  6800              LDR      r0,[r0,#0]  ; IOE_TimeOut
00002e  1e40              SUBS     r0,r0,#1
000030  4a3f              LDR      r2,|L3.304|
000032  6010              STR      r0,[r2,#0]  ; IOE_TimeOut
000034  b909              CBNZ     r1,|L3.58|
000036  2002              MOVS     r0,#2
                  |L3.56|
;;;1061     }
;;;1062     
;;;1063     /* Transmit the slave address and enable writing operation */
;;;1064     I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Transmitter);
;;;1065     
;;;1066     /* Test on ADDR Flag */
;;;1067     IOE_TimeOut = TIMEOUT_MAX;
;;;1068     while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
;;;1069     {
;;;1070       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1071     }
;;;1072     
;;;1073     /* Transmit the first address for r/w operations */
;;;1074     I2C_SendData(IOE_I2C, RegisterAddr);
;;;1075     
;;;1076     /* Test on TXE FLag (data dent) */
;;;1077     IOE_TimeOut = TIMEOUT_MAX;
;;;1078     while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))  
;;;1079     {
;;;1080       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1081     }
;;;1082     
;;;1083     /* Enable I2C DMA request */
;;;1084     I2C_DMACmd(IOE_I2C,ENABLE);
;;;1085     
;;;1086     /* Enable DMA TX Channel */
;;;1087     DMA_Cmd(IOE_DMA_TX_STREAM, ENABLE);
;;;1088     
;;;1089     /* Wait until DMA Transfer Complete */
;;;1090     IOE_TimeOut = TIMEOUT_MAX;
;;;1091     while (!DMA_GetFlagStatus(IOE_DMA_TX_STREAM,IOE_DMA_TX_TCFLAG))
;;;1092     {
;;;1093       if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
;;;1094     }  
;;;1095     
;;;1096     /* Wait until BTF Flag is set before generating STOP */
;;;1097     IOE_TimeOut = 2 * TIMEOUT_MAX;
;;;1098     while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))  
;;;1099     {
;;;1100     }
;;;1101     
;;;1102     /* Send STOP Condition */
;;;1103     I2C_GenerateSTOP(IOE_I2C, ENABLE);
;;;1104     
;;;1105     /* Disable DMA TX Channel */
;;;1106     DMA_Cmd(IOE_DMA_TX_STREAM, DISABLE);
;;;1107     
;;;1108     /* Disable I2C DMA request */  
;;;1109     I2C_DMACmd(IOE_I2C,DISABLE);
;;;1110     
;;;1111     /* Clear DMA TX Transfer Complete Flag */
;;;1112     DMA_ClearFlag(IOE_DMA_TX_STREAM,IOE_DMA_TX_TCFLAG);
;;;1113     
;;;1114   #ifdef VERIFY_WRITTENDATA
;;;1115     /* Verify (if needed) that the loaded data is correct  */
;;;1116     
;;;1117     /* Read the just written register*/
;;;1118     read_verif = I2C_ReadDeviceRegister(DeviceAddr, RegisterAddr);
;;;1119     /* Load the register and verify its value  */
;;;1120     if (read_verif != RegisterValue)
;;;1121     {
;;;1122       /* Control data wrongly transferred */
;;;1123       read_verif = IOE_FAILURE;
;;;1124     }
;;;1125     else
;;;1126     {
;;;1127       /* Control data correctly transferred */
;;;1128       read_verif = 0;
;;;1129     }
;;;1130   #endif
;;;1131     
;;;1132     /* Return the verifying value: 0 (Passed) or 1 (Failed) */
;;;1133     return read_verif;
;;;1134   }
000038  bdf8              POP      {r3-r7,pc}
                  |L3.58|
00003a  493e              LDR      r1,|L3.308|
00003c  483b              LDR      r0,|L3.300|
00003e  f7fffffe          BL       I2C_GetFlagStatus
000042  2800              CMP      r0,#0                 ;1058
000044  d0f0              BEQ      |L3.40|
000046  2200              MOVS     r2,#0                 ;1064
000048  4621              MOV      r1,r4                 ;1064
00004a  4838              LDR      r0,|L3.300|
00004c  f7fffffe          BL       I2C_Send7bitAddress
000050  f44f5040          MOV      r0,#0x3000            ;1067
000054  4936              LDR      r1,|L3.304|
000056  6008              STR      r0,[r1,#0]            ;1067  ; IOE_TimeOut
000058  e008              B        |L3.108|
                  |L3.90|
00005a  4835              LDR      r0,|L3.304|
00005c  6801              LDR      r1,[r0,#0]            ;1070  ; IOE_TimeOut
00005e  6800              LDR      r0,[r0,#0]            ;1070  ; IOE_TimeOut
000060  1e40              SUBS     r0,r0,#1              ;1070
000062  4a33              LDR      r2,|L3.304|
000064  6010              STR      r0,[r2,#0]            ;1070  ; IOE_TimeOut
000066  b909              CBNZ     r1,|L3.108|
000068  2002              MOVS     r0,#2                 ;1070
00006a  e7e5              B        |L3.56|
                  |L3.108|
00006c  4932              LDR      r1,|L3.312|
00006e  482f              LDR      r0,|L3.300|
000070  f7fffffe          BL       I2C_CheckEvent
000074  2800              CMP      r0,#0                 ;1068
000076  d0f0              BEQ      |L3.90|
000078  4639              MOV      r1,r7                 ;1074
00007a  482c              LDR      r0,|L3.300|
00007c  f7fffffe          BL       I2C_SendData
000080  f44f5040          MOV      r0,#0x3000            ;1077
000084  492a              LDR      r1,|L3.304|
000086  6008              STR      r0,[r1,#0]            ;1077  ; IOE_TimeOut
000088  e008              B        |L3.156|
                  |L3.138|
00008a  4829              LDR      r0,|L3.304|
00008c  6801              LDR      r1,[r0,#0]            ;1080  ; IOE_TimeOut
00008e  6800              LDR      r0,[r0,#0]            ;1080  ; IOE_TimeOut
000090  1e40              SUBS     r0,r0,#1              ;1080
000092  4a27              LDR      r2,|L3.304|
000094  6010              STR      r0,[r2,#0]            ;1080  ; IOE_TimeOut
000096  b909              CBNZ     r1,|L3.156|
000098  2002              MOVS     r0,#2                 ;1080
00009a  e7cd              B        |L3.56|
                  |L3.156|
00009c  4925              LDR      r1,|L3.308|
00009e  317f              ADDS     r1,r1,#0x7f           ;1078
0000a0  4822              LDR      r0,|L3.300|
0000a2  f7fffffe          BL       I2C_GetFlagStatus
0000a6  b930              CBNZ     r0,|L3.182|
0000a8  4922              LDR      r1,|L3.308|
0000aa  1cc9              ADDS     r1,r1,#3              ;1078
0000ac  481f              LDR      r0,|L3.300|
0000ae  f7fffffe          BL       I2C_GetFlagStatus
0000b2  2800              CMP      r0,#0                 ;1078
0000b4  d0e9              BEQ      |L3.138|
                  |L3.182|
0000b6  2101              MOVS     r1,#1                 ;1084
0000b8  481c              LDR      r0,|L3.300|
0000ba  f7fffffe          BL       I2C_DMACmd
0000be  2101              MOVS     r1,#1                 ;1087
0000c0  481e              LDR      r0,|L3.316|
0000c2  f7fffffe          BL       DMA_Cmd
0000c6  f44f5040          MOV      r0,#0x3000            ;1090
0000ca  4919              LDR      r1,|L3.304|
0000cc  6008              STR      r0,[r1,#0]            ;1090  ; IOE_TimeOut
0000ce  e008              B        |L3.226|
                  |L3.208|
0000d0  4817              LDR      r0,|L3.304|
0000d2  6801              LDR      r1,[r0,#0]            ;1093  ; IOE_TimeOut
0000d4  6800              LDR      r0,[r0,#0]            ;1093  ; IOE_TimeOut
0000d6  1e40              SUBS     r0,r0,#1              ;1093
0000d8  4a15              LDR      r2,|L3.304|
0000da  6010              STR      r0,[r2,#0]            ;1093  ; IOE_TimeOut
0000dc  b909              CBNZ     r1,|L3.226|
0000de  2002              MOVS     r0,#2                 ;1093
0000e0  e7aa              B        |L3.56|
                  |L3.226|
0000e2  4917              LDR      r1,|L3.320|
0000e4  4815              LDR      r0,|L3.316|
0000e6  f7fffffe          BL       DMA_GetFlagStatus
0000ea  2800              CMP      r0,#0                 ;1091
0000ec  d0f0              BEQ      |L3.208|
0000ee  f44f40c0          MOV      r0,#0x6000            ;1097
0000f2  490f              LDR      r1,|L3.304|
0000f4  6008              STR      r0,[r1,#0]            ;1097  ; IOE_TimeOut
0000f6  bf00              NOP                            ;1098
                  |L3.248|
0000f8  490e              LDR      r1,|L3.308|
0000fa  1cc9              ADDS     r1,r1,#3              ;1098
0000fc  480b              LDR      r0,|L3.300|
0000fe  f7fffffe          BL       I2C_GetFlagStatus
000102  2800              CMP      r0,#0                 ;1098
000104  d0f8              BEQ      |L3.248|
000106  2101              MOVS     r1,#1                 ;1103
000108  4808              LDR      r0,|L3.300|
00010a  f7fffffe          BL       I2C_GenerateSTOP
00010e  2100              MOVS     r1,#0                 ;1106
000110  480a              LDR      r0,|L3.316|
000112  f7fffffe          BL       DMA_Cmd
000116  2100              MOVS     r1,#0                 ;1109
000118  4804              LDR      r0,|L3.300|
00011a  f7fffffe          BL       I2C_DMACmd
00011e  4908              LDR      r1,|L3.320|
000120  4806              LDR      r0,|L3.316|
000122  f7fffffe          BL       DMA_ClearFlag
000126  b2f0              UXTB     r0,r6                 ;1133
000128  e786              B        |L3.56|
;;;1135   
                          ENDP

00012a  0000              DCW      0x0000
                  |L3.300|
                          DCD      0x40005400
                  |L3.304|
                          DCD      IOE_TimeOut
                  |L3.308|
                          DCD      0x10000001
                  |L3.312|
                          DCD      0x00070082
                  |L3.316|
                          DCD      0x400260a0
                  |L3.320|
                          DCD      0x20200000

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

                  IOE_ClearGITPending PROC
;;;524      */
;;;525    uint8_t IOE_ClearGITPending(uint8_t DeviceAddr, uint8_t Global_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;526    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;527      /* Write 1 to the bits that have to be cleared */
;;;528      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_STA, Global_IT); 
000006  4622              MOV      r2,r4
000008  210b              MOVS     r1,#0xb
00000a  4628              MOV      r0,r5
00000c  f7fffffe          BL       I2C_WriteDeviceRegister
;;;529    
;;;530      /* If all OK return IOE_OK */
;;;531      return IOE_OK;
000010  2000              MOVS     r0,#0
;;;532    }
000012  bd70              POP      {r4-r6,pc}
;;;533    
                          ENDP


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

                  IOE_ClearIOITPending PROC
;;;566      */
;;;567    uint8_t IOE_ClearIOITPending(uint8_t DeviceAddr, uint8_t IO_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;568    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;569      /* Write 1 to the bits that have to be cleared */
;;;570      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_STA, IO_IT);  
000006  4622              MOV      r2,r4
000008  210d              MOVS     r1,#0xd
00000a  4628              MOV      r0,r5
00000c  f7fffffe          BL       I2C_WriteDeviceRegister
;;;571    
;;;572      /* Clear the Edge detection pending bit*/
;;;573      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_ED, IO_IT);
000010  4622              MOV      r2,r4
000012  2114              MOVS     r1,#0x14
000014  2088              MOVS     r0,#0x88
000016  f7fffffe          BL       I2C_WriteDeviceRegister
;;;574    
;;;575      /* Clear the Rising edge pending bit */
;;;576      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_RE, IO_IT);
00001a  4622              MOV      r2,r4
00001c  2115              MOVS     r1,#0x15
00001e  2088              MOVS     r0,#0x88
000020  f7fffffe          BL       I2C_WriteDeviceRegister
;;;577    
;;;578      /* Clear the Falling edge pending bit */
;;;579      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_FE, IO_IT);  
000024  4622              MOV      r2,r4
000026  2116              MOVS     r1,#0x16
000028  2088              MOVS     r0,#0x88
00002a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;580    
;;;581      /* If all OK return IOE_OK */
;;;582      return IOE_OK;
00002e  2000              MOVS     r0,#0
;;;583    }
000030  bd70              POP      {r4-r6,pc}
;;;584    
                          ENDP


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

                  IOE_Config PROC
;;;129      */
;;;130    uint8_t IOE_Config(void)
000000  b510              PUSH     {r4,lr}
;;;131    {
;;;132      /* Configure the needed pins */
;;;133      IOE_GPIO_Config(); 
000002  f7fffffe          BL       IOE_GPIO_Config
;;;134      
;;;135      IOE_I2C_Config();
000006  f7fffffe          BL       IOE_I2C_Config
;;;136        
;;;137      /* Read IO Expander 1 ID  */
;;;138      if(IOE_IsOperational(IOE_1_ADDR))
00000a  2082              MOVS     r0,#0x82
00000c  f7fffffe          BL       IOE_IsOperational
000010  b108              CBZ      r0,|L6.22|
;;;139      {
;;;140        return IOE1_NOT_OPERATIONAL;
000012  2004              MOVS     r0,#4
                  |L6.20|
;;;141      }
;;;142      if(IOE_IsOperational(IOE_2_ADDR))
;;;143      {
;;;144        return IOE2_NOT_OPERATIONAL;
;;;145      }
;;;146      
;;;147      /* Generate IOExpander Software reset */
;;;148      IOE_Reset(IOE_1_ADDR); 
;;;149      IOE_Reset(IOE_2_ADDR);
;;;150      
;;;151      /* ---------------------- IO Expander 1 configuration --------------------- */
;;;152      /* Enable the GPIO, Touch Screen and ADC functionalities */
;;;153      IOE_FnctCmd(IOE_1_ADDR, IOE_IO_FCT | IOE_TS_FCT | IOE_ADC_FCT, ENABLE);
;;;154      /* Configure the VBAT pin in output mode pin*/
;;;155      IOE_IOPinConfig(IOE_1_ADDR, VBAT_DIV_PIN , Direction_OUT);  
;;;156      /* ENABLE the alternate function for IN1 pin */
;;;157      IOE_IOAFConfig(IOE_1_ADDR, VBAT_DIV_PIN, ENABLE);
;;;158      
;;;159      /* Apply the default state for the out pins */
;;;160      IOE_WriteIOPin(VBAT_DIV_PIN, BitReset);
;;;161      /* Configure the MEMS interrupt pins in Input mode */
;;;162      IOE_IOPinConfig(IOE_2_ADDR, (uint32_t)(MEMS_INT1_PIN | MEMS_INT2_PIN), Direction_IN); 
;;;163      
;;;164      /* ENABLE the alternate function for the Joystick pins */
;;;165      IOE_IOAFConfig(IOE_2_ADDR, (uint32_t)(MEMS_INT1_PIN | MEMS_INT2_PIN), ENABLE);
;;;166      /* Configure the IOs to detect Falling and Rising Edges */
;;;167      IOE_IOEdgeConfig(IOE_2_ADDR, (uint32_t)(MEMS_INT1_PIN | MEMS_INT2_PIN), (uint32_t)(EDGE_FALLING | EDGE_RISING));
;;;168      /* Touch Screen controller configuration */
;;;169      IOE_TS_Config();
;;;170      
;;;171      /* ------------------------------------------------------------------------ */
;;;172      
;;;173      /* ---------------------- IO Expander 2 configuration --------------------- */
;;;174      /* Enable the GPIO, Temperature Sensor and ADC functionalities */
;;;175      IOE_FnctCmd(IOE_2_ADDR, IOE_IO_FCT | IOE_TEMPSENS_FCT | IOE_ADC_FCT, ENABLE);
;;;176      
;;;177      /* Configure the Audio Codec Reset pin in output mode pin*/
;;;178      IOE_IOPinConfig(IOE_2_ADDR, (uint32_t)(AUDIO_RESET_PIN), Direction_OUT);
;;;179      IOE_IOPinConfig(IOE_2_ADDR, (uint32_t)(MII_INT_PIN), Direction_IN);
;;;180          
;;;181      /* ENABLE the alternate function for IN1 pin */
;;;182      IOE_IOAFConfig(IOE_2_ADDR, (uint32_t)(AUDIO_RESET_PIN | MII_INT_PIN), ENABLE);
;;;183        
;;;184      /* Apply the default state for the out pins */
;;;185      IOE_WriteIOPin(AUDIO_RESET_PIN, BitReset);
;;;186      IOE_WriteIOPin(MII_INT_PIN, BitReset);
;;;187      /* Configure the Joystick pins in Input mode */
;;;188      IOE_IOPinConfig(IOE_2_ADDR, JOY_IO_PINS , Direction_IN); 
;;;189      
;;;190      /* ENABLE the alternate function for the Joystick pins */
;;;191      IOE_IOAFConfig(IOE_2_ADDR, JOY_IO_PINS, ENABLE);
;;;192      /* Configure the IOs to detect Falling and Rising Edges */
;;;193      IOE_IOEdgeConfig(IOE_2_ADDR, JOY_IO_PINS, (uint8_t)(EDGE_FALLING | EDGE_RISING));
;;;194      
;;;195      /* Temperature Sensor module configuration */
;;;196      IOE_TempSens_Config();
;;;197      /* ------------------------------------------------------------------------ */
;;;198      
;;;199      /* Configuration is OK */
;;;200      return IOE_OK; 
;;;201    }
000014  bd10              POP      {r4,pc}
                  |L6.22|
000016  2088              MOVS     r0,#0x88              ;142
000018  f7fffffe          BL       IOE_IsOperational
00001c  b108              CBZ      r0,|L6.34|
00001e  2005              MOVS     r0,#5                 ;144
000020  e7f8              B        |L6.20|
                  |L6.34|
000022  2082              MOVS     r0,#0x82              ;148
000024  f7fffffe          BL       IOE_Reset
000028  2088              MOVS     r0,#0x88              ;149
00002a  f7fffffe          BL       IOE_Reset
00002e  2201              MOVS     r2,#1                 ;153
000030  2107              MOVS     r1,#7                 ;153
000032  2082              MOVS     r0,#0x82              ;153
000034  f7fffffe          BL       IOE_FnctCmd
000038  2201              MOVS     r2,#1                 ;155
00003a  4611              MOV      r1,r2                 ;155
00003c  2082              MOVS     r0,#0x82              ;155
00003e  f7fffffe          BL       IOE_IOPinConfig
000042  2201              MOVS     r2,#1                 ;157
000044  4611              MOV      r1,r2                 ;157
000046  2082              MOVS     r0,#0x82              ;157
000048  f7fffffe          BL       IOE_IOAFConfig
00004c  2100              MOVS     r1,#0                 ;160
00004e  2001              MOVS     r0,#1                 ;160
000050  f7fffffe          BL       IOE_WriteIOPin
000054  2200              MOVS     r2,#0                 ;162
000056  210c              MOVS     r1,#0xc               ;162
000058  2088              MOVS     r0,#0x88              ;162
00005a  f7fffffe          BL       IOE_IOPinConfig
00005e  2201              MOVS     r2,#1                 ;165
000060  210c              MOVS     r1,#0xc               ;165
000062  2088              MOVS     r0,#0x88              ;165
000064  f7fffffe          BL       IOE_IOAFConfig
000068  2203              MOVS     r2,#3                 ;167
00006a  210c              MOVS     r1,#0xc               ;167
00006c  2088              MOVS     r0,#0x88              ;167
00006e  f7fffffe          BL       IOE_IOEdgeConfig
000072  f7fffffe          BL       IOE_TS_Config
000076  2201              MOVS     r2,#1                 ;175
000078  210d              MOVS     r1,#0xd               ;175
00007a  2088              MOVS     r0,#0x88              ;175
00007c  f7fffffe          BL       IOE_FnctCmd
000080  2201              MOVS     r2,#1                 ;178
000082  2104              MOVS     r1,#4                 ;178
000084  2088              MOVS     r0,#0x88              ;178
000086  f7fffffe          BL       IOE_IOPinConfig
00008a  2200              MOVS     r2,#0                 ;179
00008c  2101              MOVS     r1,#1                 ;179
00008e  2088              MOVS     r0,#0x88              ;179
000090  f7fffffe          BL       IOE_IOPinConfig
000094  2201              MOVS     r2,#1                 ;182
000096  2105              MOVS     r1,#5                 ;182
000098  2088              MOVS     r0,#0x88              ;182
00009a  f7fffffe          BL       IOE_IOAFConfig
00009e  2100              MOVS     r1,#0                 ;185
0000a0  2004              MOVS     r0,#4                 ;185
0000a2  f7fffffe          BL       IOE_WriteIOPin
0000a6  2100              MOVS     r1,#0                 ;186
0000a8  2001              MOVS     r0,#1                 ;186
0000aa  f7fffffe          BL       IOE_WriteIOPin
0000ae  2200              MOVS     r2,#0                 ;188
0000b0  21f8              MOVS     r1,#0xf8              ;188
0000b2  2088              MOVS     r0,#0x88              ;188
0000b4  f7fffffe          BL       IOE_IOPinConfig
0000b8  2201              MOVS     r2,#1                 ;191
0000ba  21f8              MOVS     r1,#0xf8              ;191
0000bc  2088              MOVS     r0,#0x88              ;191
0000be  f7fffffe          BL       IOE_IOAFConfig
0000c2  2203              MOVS     r2,#3                 ;193
0000c4  21f8              MOVS     r1,#0xf8              ;193
0000c6  2088              MOVS     r0,#0x88              ;193
0000c8  f7fffffe          BL       IOE_IOEdgeConfig
0000cc  f7fffffe          BL       IOE_TempSens_Config
0000d0  2000              MOVS     r0,#0                 ;200
0000d2  e79f              B        |L6.20|
;;;202    
                          ENDP


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

                  IOE_DMA_Config PROC
;;;1463   
;;;1464   static void IOE_DMA_Config(IOE_DMADirection_TypeDef Direction, uint8_t* buffer)
000000  b530              PUSH     {r4,r5,lr}
;;;1465   {
000002  b08f              SUB      sp,sp,#0x3c
000004  4604              MOV      r4,r0
000006  460d              MOV      r5,r1
;;;1466     DMA_InitTypeDef DMA_InitStructure;
;;;1467     
;;;1468     RCC_AHB1PeriphClockCmd(IOE_DMA_CLK, ENABLE);
000008  2101              MOVS     r1,#1
00000a  0548              LSLS     r0,r1,#21
00000c  f7fffffe          BL       RCC_AHB1PeriphClockCmd
;;;1469     
;;;1470     /* Initialize the DMA_Channel member */
;;;1471     DMA_InitStructure.DMA_Channel = IOE_DMA_CHANNEL;
000010  f04f7000          MOV      r0,#0x2000000
000014  9000              STR      r0,[sp,#0]
;;;1472     
;;;1473     /* Initialize the DMA_PeripheralBaseAddr member */
;;;1474     DMA_InitStructure.DMA_PeripheralBaseAddr = IOE_I2C_DR;
000016  4818              LDR      r0,|L7.120|
000018  9001              STR      r0,[sp,#4]
;;;1475     
;;;1476     /* Initialize the DMA_Memory0BaseAddr member */
;;;1477     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buffer;
00001a  9502              STR      r5,[sp,#8]
;;;1478     
;;;1479     /* Initialize the DMA_PeripheralInc member */
;;;1480     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
00001c  2000              MOVS     r0,#0
00001e  9005              STR      r0,[sp,#0x14]
;;;1481     
;;;1482     /* Initialize the DMA_MemoryInc member */
;;;1483     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
000020  f44f6080          MOV      r0,#0x400
000024  9006              STR      r0,[sp,#0x18]
;;;1484     
;;;1485     /* Initialize the DMA_PeripheralDataSize member */
;;;1486     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
000026  2000              MOVS     r0,#0
000028  9007              STR      r0,[sp,#0x1c]
;;;1487     
;;;1488     /* Initialize the DMA_MemoryDataSize member */
;;;1489     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
00002a  9008              STR      r0,[sp,#0x20]
;;;1490     
;;;1491     /* Initialize the DMA_Mode member */
;;;1492     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
00002c  9009              STR      r0,[sp,#0x24]
;;;1493     
;;;1494     /* Initialize the DMA_Priority member */
;;;1495     DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
00002e  900a              STR      r0,[sp,#0x28]
;;;1496     
;;;1497     /* Initialize the DMA_FIFOMode member */
;;;1498     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
000030  2004              MOVS     r0,#4
000032  900b              STR      r0,[sp,#0x2c]
;;;1499     
;;;1500     /* Initialize the DMA_FIFOThreshold member */
;;;1501     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
000034  2000              MOVS     r0,#0
000036  900c              STR      r0,[sp,#0x30]
;;;1502     
;;;1503     /* Initialize the DMA_MemoryBurst member */
;;;1504     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
000038  900d              STR      r0,[sp,#0x34]
;;;1505     
;;;1506     /* Initialize the DMA_PeripheralBurst member */
;;;1507     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
00003a  900e              STR      r0,[sp,#0x38]
;;;1508     
;;;1509     /* If using DMA for Reception */
;;;1510     if (Direction == IOE_DMA_RX)
00003c  2c01              CMP      r4,#1
00003e  d10a              BNE      |L7.86|
;;;1511     {    
;;;1512       /* Initialize the DMA_DIR member */
;;;1513       DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
000040  9003              STR      r0,[sp,#0xc]
;;;1514       
;;;1515       /* Initialize the DMA_BufferSize member */
;;;1516       DMA_InitStructure.DMA_BufferSize = 2;
000042  2002              MOVS     r0,#2
000044  9004              STR      r0,[sp,#0x10]
;;;1517       
;;;1518       DMA_DeInit(IOE_DMA_RX_STREAM);
000046  480d              LDR      r0,|L7.124|
000048  f7fffffe          BL       DMA_DeInit
;;;1519       
;;;1520       DMA_Init(IOE_DMA_RX_STREAM, &DMA_InitStructure);
00004c  4669              MOV      r1,sp
00004e  480b              LDR      r0,|L7.124|
000050  f7fffffe          BL       DMA_Init
000054  e00d              B        |L7.114|
                  |L7.86|
;;;1521     }
;;;1522     /* If using DMA for Transmission */
;;;1523     else if (Direction == IOE_DMA_TX)
000056  b964              CBNZ     r4,|L7.114|
;;;1524     { 
;;;1525       /* Initialize the DMA_DIR member */
;;;1526       DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
000058  2040              MOVS     r0,#0x40
00005a  9003              STR      r0,[sp,#0xc]
;;;1527       
;;;1528       /* Initialize the DMA_BufferSize member */
;;;1529       DMA_InitStructure.DMA_BufferSize = 1;
00005c  2001              MOVS     r0,#1
00005e  9004              STR      r0,[sp,#0x10]
;;;1530       
;;;1531       DMA_DeInit(IOE_DMA_TX_STREAM);
000060  4806              LDR      r0,|L7.124|
000062  3090              ADDS     r0,r0,#0x90
000064  f7fffffe          BL       DMA_DeInit
;;;1532       
;;;1533       DMA_Init(IOE_DMA_TX_STREAM, &DMA_InitStructure);
000068  4669              MOV      r1,sp
00006a  4804              LDR      r0,|L7.124|
00006c  3090              ADDS     r0,r0,#0x90
00006e  f7fffffe          BL       DMA_Init
                  |L7.114|
;;;1534     }
;;;1535   }
000072  b00f              ADD      sp,sp,#0x3c
000074  bd30              POP      {r4,r5,pc}
;;;1536   
                          ENDP

000076  0000              DCW      0x0000
                  |L7.120|
                          DCD      0x40005410
                  |L7.124|
                          DCD      0x40026010

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

                  IOE_EXTI_Config PROC
;;;1542     */
;;;1543   static void IOE_EXTI_Config(void)
000000  b500              PUSH     {lr}
;;;1544   {
000002  b085              SUB      sp,sp,#0x14
;;;1545     GPIO_InitTypeDef GPIO_InitStructure;
;;;1546     NVIC_InitTypeDef NVIC_InitStructure;
;;;1547     EXTI_InitTypeDef EXTI_InitStructure;
;;;1548    
;;;1549     /* Enable GPIO clock */
;;;1550     RCC_AHB1PeriphClockCmd(IOE_IT_GPIO_CLK, ENABLE);
000004  2101              MOVS     r1,#1
000006  0208              LSLS     r0,r1,#8
000008  f7fffffe          BL       RCC_AHB1PeriphClockCmd
;;;1551     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
00000c  2101              MOVS     r1,#1
00000e  0388              LSLS     r0,r1,#14
000010  f7fffffe          BL       RCC_APB2PeriphClockCmd
;;;1552   
;;;1553     /* Configure Button pin as input floating */
;;;1554     GPIO_InitStructure.GPIO_Pin = IOE_IT_PIN;
000014  2004              MOVS     r0,#4
000016  9003              STR      r0,[sp,#0xc]
;;;1555     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
000018  2000              MOVS     r0,#0
00001a  f88d0010          STRB     r0,[sp,#0x10]
;;;1556     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
00001e  f88d0013          STRB     r0,[sp,#0x13]
;;;1557     GPIO_Init(IOE_IT_GPIO_PORT, &GPIO_InitStructure);  
000022  a903              ADD      r1,sp,#0xc
000024  4812              LDR      r0,|L8.112|
000026  f7fffffe          BL       GPIO_Init
;;;1558     
;;;1559     /* Connect Button EXTI Line to Button GPIO Pin */
;;;1560     SYSCFG_EXTILineConfig(IOE_IT_EXTI_PORT_SOURCE, IOE_IT_EXTI_PIN_SOURCE);  
00002a  2102              MOVS     r1,#2
00002c  2008              MOVS     r0,#8
00002e  f7fffffe          BL       SYSCFG_EXTILineConfig
;;;1561     
;;;1562     /* Configure Button EXTI line */
;;;1563     EXTI_InitStructure.EXTI_Line = IOE_IT_EXTI_LINE;
000032  2004              MOVS     r0,#4
000034  9000              STR      r0,[sp,#0]
;;;1564     EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
000036  2000              MOVS     r0,#0
000038  f88d0004          STRB     r0,[sp,#4]
;;;1565     EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;  
00003c  2010              MOVS     r0,#0x10
00003e  f88d0005          STRB     r0,[sp,#5]
;;;1566     EXTI_InitStructure.EXTI_LineCmd = ENABLE;
000042  2001              MOVS     r0,#1
000044  f88d0006          STRB     r0,[sp,#6]
;;;1567     EXTI_Init(&EXTI_InitStructure);
000048  4668              MOV      r0,sp
00004a  f7fffffe          BL       EXTI_Init
;;;1568     
;;;1569     /* Enable and set Button EXTI Interrupt to the lowest priority */
;;;1570     NVIC_InitStructure.NVIC_IRQChannel = IOE_IT_EXTI_IRQn;
00004e  2008              MOVS     r0,#8
000050  f88d0008          STRB     r0,[sp,#8]
;;;1571     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
000054  200f              MOVS     r0,#0xf
000056  f88d0009          STRB     r0,[sp,#9]
;;;1572     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
00005a  f88d000a          STRB     r0,[sp,#0xa]
;;;1573     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
00005e  2001              MOVS     r0,#1
000060  f88d000b          STRB     r0,[sp,#0xb]
;;;1574     NVIC_Init(&NVIC_InitStructure);
000064  a802              ADD      r0,sp,#8
000066  f7fffffe          BL       NVIC_Init
;;;1575   }
00006a  b005              ADD      sp,sp,#0x14
00006c  bd00              POP      {pc}
;;;1576   
                          ENDP

00006e  0000              DCW      0x0000
                  |L8.112|
                          DCD      0x40022000

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

                  IOE_FnctCmd PROC
;;;664      */
;;;665    uint8_t IOE_FnctCmd(uint8_t DeviceAddr, uint8_t Fct, FunctionalState NewState)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;666    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
;;;667      uint8_t tmp = 0;
00000a  2500              MOVS     r5,#0
;;;668      
;;;669      /* Get the register value */
;;;670      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL2);
00000c  2104              MOVS     r1,#4
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  4605              MOV      r5,r0
;;;671      
;;;672      if (NewState != DISABLE)
000016  b10e              CBZ      r6,|L9.28|
;;;673      {
;;;674        /* Set the Functionalities to be Enabled */    
;;;675        tmp &= ~(uint8_t)Fct;
000018  43a5              BICS     r5,r5,r4
00001a  e000              B        |L9.30|
                  |L9.28|
;;;676      }
;;;677      else
;;;678      {
;;;679        /* Set the Functionalities to be Disabled */    
;;;680        tmp |= (uint8_t)Fct;  
00001c  4325              ORRS     r5,r5,r4
                  |L9.30|
;;;681      }
;;;682      
;;;683      /* Set the register value */
;;;684      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL2, tmp);
00001e  462a              MOV      r2,r5
000020  2104              MOVS     r1,#4
000022  4638              MOV      r0,r7
000024  f7fffffe          BL       I2C_WriteDeviceRegister
;;;685      
;;;686      /* If all OK return IOE_OK */
;;;687      return IOE_OK;    
000028  2000              MOVS     r0,#0
;;;688    }
00002a  e8bd81f0          POP      {r4-r8,pc}
;;;689    
                          ENDP


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

                  IOE_GITCmd PROC
;;;727      */
;;;728    uint8_t IOE_GITCmd(uint8_t DeviceAddr, FunctionalState NewState)
000000  b570              PUSH     {r4-r6,lr}
;;;729    {
000002  4606              MOV      r6,r0
000004  460d              MOV      r5,r1
;;;730      uint8_t tmp = 0;
000006  2400              MOVS     r4,#0
;;;731      
;;;732      /* Read the Interrupt Control register  */
;;;733      I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_CTRL);
000008  2109              MOVS     r1,#9
00000a  4630              MOV      r0,r6
00000c  f7fffffe          BL       I2C_ReadDeviceRegister
;;;734      
;;;735      if (NewState != DISABLE)
000010  b115              CBZ      r5,|L10.24|
;;;736      {
;;;737        /* Set the global interrupts to be Enabled */    
;;;738        tmp |= (uint8_t)IOE_GIT_EN;
000012  f0440401          ORR      r4,r4,#1
000016  e001              B        |L10.28|
                  |L10.24|
;;;739      }
;;;740      else
;;;741      {
;;;742        /* Set the global interrupts to be Disabled */    
;;;743        tmp &= ~(uint8_t)IOE_GIT_EN;
000018  f0240401          BIC      r4,r4,#1
                  |L10.28|
;;;744      }  
;;;745      
;;;746      /* Write Back the Interrupt Control register */
;;;747      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_CTRL, tmp);
00001c  4622              MOV      r2,r4
00001e  2109              MOVS     r1,#9
000020  4630              MOV      r0,r6
000022  f7fffffe          BL       I2C_WriteDeviceRegister
;;;748    
;;;749      /* If all OK return IOE_OK */
;;;750      return IOE_OK;     
000026  2000              MOVS     r0,#0
;;;751    }
000028  bd70              POP      {r4-r6,pc}
;;;752    
                          ENDP


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

                  IOE_GITConfig PROC
;;;767      */
;;;768    uint8_t IOE_GITConfig(uint8_t DeviceAddr, uint8_t Global_IT, FunctionalState NewState)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;769    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
;;;770      uint8_t tmp = 0;
00000a  2500              MOVS     r5,#0
;;;771      
;;;772      /* Get the current value of the INT_EN register */
;;;773      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_EN);
00000c  210a              MOVS     r1,#0xa
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  4605              MOV      r5,r0
;;;774      
;;;775      if (NewState != DISABLE)
000016  b10e              CBZ      r6,|L11.28|
;;;776      {
;;;777        /* Set the interrupts to be Enabled */    
;;;778        tmp |= (uint8_t)Global_IT;  
000018  4325              ORRS     r5,r5,r4
00001a  e000              B        |L11.30|
                  |L11.28|
;;;779      }
;;;780      else
;;;781      {
;;;782        /* Set the interrupts to be Disabled */    
;;;783        tmp &= ~(uint8_t)Global_IT;
00001c  43a5              BICS     r5,r5,r4
                  |L11.30|
;;;784      }
;;;785      /* Set the register */
;;;786      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_EN, tmp);
00001e  462a              MOV      r2,r5
000020  210a              MOVS     r1,#0xa
000022  4638              MOV      r0,r7
000024  f7fffffe          BL       I2C_WriteDeviceRegister
;;;787      
;;;788      /* If all OK return IOE_OK */
;;;789      return IOE_OK;  
000028  2000              MOVS     r0,#0
;;;790    }
00002a  e8bd81f0          POP      {r4-r8,pc}
;;;791    
                          ENDP


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

                  IOE_GPIO_Config PROC
;;;1397     */
;;;1398   static void IOE_GPIO_Config(void)
000000  b51c              PUSH     {r2-r4,lr}
;;;1399   {
;;;1400     GPIO_InitTypeDef GPIO_InitStructure;
;;;1401     
;;;1402     /* Enable IOE_I2C and IOE_I2C_GPIO_PORT & Alternate Function clocks */
;;;1403     RCC_APB1PeriphClockCmd(IOE_I2C_CLK, ENABLE);
000002  2101              MOVS     r1,#1
000004  0548              LSLS     r0,r1,#21
000006  f7fffffe          BL       RCC_APB1PeriphClockCmd
;;;1404     RCC_AHB1PeriphClockCmd(IOE_I2C_SCL_GPIO_CLK | IOE_I2C_SDA_GPIO_CLK |
00000a  2101              MOVS     r1,#1
00000c  f44f7081          MOV      r0,#0x102
000010  f7fffffe          BL       RCC_AHB1PeriphClockCmd
;;;1405                            IOE_IT_GPIO_CLK, ENABLE);
;;;1406     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
000014  2101              MOVS     r1,#1
000016  0388              LSLS     r0,r1,#14
000018  f7fffffe          BL       RCC_APB2PeriphClockCmd
;;;1407     
;;;1408     /* Reset IOE_I2C IP */
;;;1409     RCC_APB1PeriphResetCmd(IOE_I2C_CLK, ENABLE);
00001c  2101              MOVS     r1,#1
00001e  0548              LSLS     r0,r1,#21
000020  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;1410     
;;;1411     /* Release reset signal of IOE_I2C IP */
;;;1412     RCC_APB1PeriphResetCmd(IOE_I2C_CLK, DISABLE);
000024  2100              MOVS     r1,#0
000026  f44f1000          MOV      r0,#0x200000
00002a  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;1413     
;;;1414     /* IOE_I2C SCL and SDA pins configuration */
;;;1415     GPIO_InitStructure.GPIO_Pin = IOE_I2C_SCL_PIN;
00002e  2040              MOVS     r0,#0x40
000030  9000              STR      r0,[sp,#0]
;;;1416     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
000032  2002              MOVS     r0,#2
000034  f88d0004          STRB     r0,[sp,#4]
;;;1417     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
000038  f88d0005          STRB     r0,[sp,#5]
;;;1418     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
00003c  2001              MOVS     r0,#1
00003e  f88d0006          STRB     r0,[sp,#6]
;;;1419     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
000042  2000              MOVS     r0,#0
000044  f88d0007          STRB     r0,[sp,#7]
;;;1420     GPIO_Init(IOE_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);
000048  4669              MOV      r1,sp
00004a  4812              LDR      r0,|L12.148|
00004c  f7fffffe          BL       GPIO_Init
;;;1421   
;;;1422     GPIO_InitStructure.GPIO_Pin = IOE_I2C_SDA_PIN;
000050  f44f7000          MOV      r0,#0x200
000054  9000              STR      r0,[sp,#0]
;;;1423     GPIO_Init(IOE_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
000056  4669              MOV      r1,sp
000058  480e              LDR      r0,|L12.148|
00005a  f7fffffe          BL       GPIO_Init
;;;1424     
;;;1425     GPIO_PinAFConfig(IOE_I2C_SCL_GPIO_PORT, IOE_I2C_SCL_SOURCE, IOE_I2C_SCL_AF);
00005e  2204              MOVS     r2,#4
000060  2106              MOVS     r1,#6
000062  480c              LDR      r0,|L12.148|
000064  f7fffffe          BL       GPIO_PinAFConfig
;;;1426     GPIO_PinAFConfig(IOE_I2C_SDA_GPIO_PORT, IOE_I2C_SDA_SOURCE, IOE_I2C_SDA_AF);  
000068  2204              MOVS     r2,#4
00006a  2109              MOVS     r1,#9
00006c  4809              LDR      r0,|L12.148|
00006e  f7fffffe          BL       GPIO_PinAFConfig
;;;1427     
;;;1428     /* Set EXTI pin as Input PullUp - IO_Expander_INT */
;;;1429     GPIO_InitStructure.GPIO_Pin = IOE_IT_PIN;
000072  2004              MOVS     r0,#4
000074  9000              STR      r0,[sp,#0]
;;;1430     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
000076  2000              MOVS     r0,#0
000078  f88d0004          STRB     r0,[sp,#4]
;;;1431     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
00007c  f88d0007          STRB     r0,[sp,#7]
;;;1432     GPIO_Init(IOE_IT_GPIO_PORT, &GPIO_InitStructure);  
000080  4669              MOV      r1,sp
000082  4805              LDR      r0,|L12.152|
000084  f7fffffe          BL       GPIO_Init
;;;1433     
;;;1434     /* Connect Button EXTI Line to Button GPIO Pin */
;;;1435     SYSCFG_EXTILineConfig(IOE_IT_EXTI_PORT_SOURCE, IOE_IT_EXTI_PIN_SOURCE);  
000088  2102              MOVS     r1,#2
00008a  2008              MOVS     r0,#8
00008c  f7fffffe          BL       SYSCFG_EXTILineConfig
;;;1436   }
000090  bd1c              POP      {r2-r4,pc}
;;;1437   
                          ENDP

000092  0000              DCW      0x0000
                  |L12.148|
                          DCD      0x40020400
                  |L12.152|
                          DCD      0x40022000

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

                  IOE_GetGITStatus PROC
;;;491      */
;;;492    FlagStatus IOE_GetGITStatus(uint8_t DeviceAddr, uint8_t Global_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;493    {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
;;;494      __IO uint8_t tmp = 0;
000006  2500              MOVS     r5,#0
;;;495     
;;;496      /* get the Interrupt status */
;;;497      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_STA);
000008  210b              MOVS     r1,#0xb
00000a  4630              MOV      r0,r6
00000c  f7fffffe          BL       I2C_ReadDeviceRegister
000010  4605              MOV      r5,r0
;;;498      
;;;499      if ((tmp & (uint8_t)Global_IT) != 0)
000012  4225              TST      r5,r4
000014  d001              BEQ      |L13.26|
;;;500      {
;;;501        return SET;
000016  2001              MOVS     r0,#1
                  |L13.24|
;;;502      }
;;;503      else
;;;504      {
;;;505        return RESET;
;;;506      }
;;;507    }
000018  bd70              POP      {r4-r6,pc}
                  |L13.26|
00001a  2000              MOVS     r0,#0                 ;505
00001c  e7fc              B        |L13.24|
;;;508    
                          ENDP


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

                  IOE_GetIOITStatus PROC
;;;541      */
;;;542    FlagStatus IOE_GetIOITStatus(uint8_t DeviceAddr, uint8_t IO_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;543    {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
;;;544      uint8_t tmp = 0;
000006  2500              MOVS     r5,#0
;;;545     
;;;546      /* get the Interrupt status */
;;;547      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_STA);
000008  210d              MOVS     r1,#0xd
00000a  4630              MOV      r0,r6
00000c  f7fffffe          BL       I2C_ReadDeviceRegister
000010  4605              MOV      r5,r0
;;;548      
;;;549      if ((tmp & (uint8_t)IO_IT) != 0)
000012  4225              TST      r5,r4
000014  d001              BEQ      |L14.26|
;;;550      {
;;;551        return SET;
000016  2001              MOVS     r0,#1
                  |L14.24|
;;;552      }
;;;553      else
;;;554      {
;;;555        return RESET;
;;;556      }
;;;557    }
000018  bd70              POP      {r4-r6,pc}
                  |L14.26|
00001a  2000              MOVS     r0,#0                 ;555
00001c  e7fc              B        |L14.24|
;;;558    
                          ENDP


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

                  IOE_I2C_Config PROC
;;;1442     */
;;;1443   static void IOE_I2C_Config(void)
000000  b51f              PUSH     {r0-r4,lr}
;;;1444   {
;;;1445     I2C_InitTypeDef I2C_InitStructure;
;;;1446     
;;;1447     /* IOE_I2C configuration */
;;;1448     I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
000002  2000              MOVS     r0,#0
000004  f8ad0004          STRH     r0,[sp,#4]
;;;1449     I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
000008  f64b70ff          MOV      r0,#0xbfff
00000c  f8ad0006          STRH     r0,[sp,#6]
;;;1450     I2C_InitStructure.I2C_OwnAddress1 = 0x00;
000010  2000              MOVS     r0,#0
000012  f8ad0008          STRH     r0,[sp,#8]
;;;1451     I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
000016  f44f6080          MOV      r0,#0x400
00001a  f8ad000a          STRH     r0,[sp,#0xa]
;;;1452     I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
00001e  0100              LSLS     r0,r0,#4
000020  f8ad000c          STRH     r0,[sp,#0xc]
;;;1453     I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
000024  4803              LDR      r0,|L15.52|
000026  9000              STR      r0,[sp,#0]
;;;1454     
;;;1455     I2C_Init(IOE_I2C, &I2C_InitStructure);
000028  4669              MOV      r1,sp
00002a  4803              LDR      r0,|L15.56|
00002c  f7fffffe          BL       I2C_Init
;;;1456   }
000030  bd1f              POP      {r0-r4,pc}
;;;1457   
                          ENDP

000032  0000              DCW      0x0000
                  |L15.52|
                          DCD      0x000186a0
                  |L15.56|
                          DCD      0x40005400

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

                  IOE_IOAFConfig PROC
;;;923      */
;;;924    uint8_t IOE_IOAFConfig(uint8_t DeviceAddr, uint8_t IO_Pin, FunctionalState NewState)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;925    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
;;;926      uint8_t tmp = 0;
00000a  2500              MOVS     r5,#0
;;;927      
;;;928      /* Get the current state of the GPIO_AF register */
;;;929      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_AF);
00000c  2117              MOVS     r1,#0x17
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  4605              MOV      r5,r0
;;;930      
;;;931      if (NewState != DISABLE)
000016  b10e              CBZ      r6,|L16.28|
;;;932      {
;;;933        /* Enable the selected pins alternate function */
;;;934        tmp |= (uint8_t)IO_Pin;
000018  4325              ORRS     r5,r5,r4
00001a  e000              B        |L16.30|
                  |L16.28|
;;;935      }
;;;936      else
;;;937      {
;;;938        /* Disable the selected pins alternate function */   
;;;939        tmp &= ~(uint8_t)IO_Pin;   
00001c  43a5              BICS     r5,r5,r4
                  |L16.30|
;;;940      }
;;;941      
;;;942      /* Write back the new value in GPIO_AF register */  
;;;943      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_AF, tmp);  
00001e  462a              MOV      r2,r5
000020  2117              MOVS     r1,#0x17
000022  4638              MOV      r0,r7
000024  f7fffffe          BL       I2C_WriteDeviceRegister
;;;944    
;;;945      /* If all OK return IOE_OK */
;;;946      return IOE_OK;
000028  2000              MOVS     r0,#0
;;;947    }
00002a  e8bd81f0          POP      {r4-r8,pc}
;;;948    
                          ENDP


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

                  IOE_IOEdgeConfig PROC
;;;958      */
;;;959    uint8_t IOE_IOEdgeConfig(uint8_t DeviceAddr, uint8_t IO_Pin, uint8_t Edge)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;960    {
000004  4680              MOV      r8,r0
000006  460c              MOV      r4,r1
000008  4615              MOV      r5,r2
;;;961      uint8_t tmp1 = 0, tmp2 = 0;   
00000a  2600              MOVS     r6,#0
00000c  2700              MOVS     r7,#0
;;;962      
;;;963      /* Get the registers values */
;;;964      tmp1 = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_FE);
00000e  2116              MOVS     r1,#0x16
000010  4640              MOV      r0,r8
000012  f7fffffe          BL       I2C_ReadDeviceRegister
000016  4606              MOV      r6,r0
;;;965      tmp2 = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_RE);
000018  2115              MOVS     r1,#0x15
00001a  4640              MOV      r0,r8
00001c  f7fffffe          BL       I2C_ReadDeviceRegister
000020  4607              MOV      r7,r0
;;;966    
;;;967      /* Disable the Falling Edge */
;;;968      tmp1 &= ~(uint8_t)IO_Pin;
000022  43a6              BICS     r6,r6,r4
;;;969      /* Disable the Falling Edge */
;;;970      tmp2 &= ~(uint8_t)IO_Pin;
000024  43a7              BICS     r7,r7,r4
;;;971    
;;;972      /* Enable the Falling edge if selected */
;;;973      if (Edge & EDGE_FALLING)
000026  f0150f01          TST      r5,#1
00002a  d000              BEQ      |L17.46|
;;;974      {
;;;975        tmp1 |= (uint8_t)IO_Pin;
00002c  4326              ORRS     r6,r6,r4
                  |L17.46|
;;;976      }
;;;977    
;;;978      /* Enable the Rising edge if selected */
;;;979      if (Edge & EDGE_RISING)
00002e  f0150f02          TST      r5,#2
000032  d000              BEQ      |L17.54|
;;;980      {
;;;981        tmp2 |= (uint8_t)IO_Pin;
000034  4327              ORRS     r7,r7,r4
                  |L17.54|
;;;982      }
;;;983    
;;;984      /* Write back the registers values */
;;;985      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_FE, tmp1);
000036  4632              MOV      r2,r6
000038  2116              MOVS     r1,#0x16
00003a  4640              MOV      r0,r8
00003c  f7fffffe          BL       I2C_WriteDeviceRegister
;;;986      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_RE, tmp2);
000040  463a              MOV      r2,r7
000042  2115              MOVS     r1,#0x15
000044  4640              MOV      r0,r8
000046  f7fffffe          BL       I2C_WriteDeviceRegister
;;;987      
;;;988      /* if OK return 0 */
;;;989      return IOE_OK;
00004a  2000              MOVS     r0,#0
;;;990    }
00004c  e8bd81f0          POP      {r4-r8,pc}
;;;991    
                          ENDP


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

                  IOE_IOITConfig PROC
;;;801      */
;;;802    uint8_t IOE_IOITConfig(uint8_t DeviceAddr, uint8_t IO_IT, FunctionalState NewState)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;803    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
;;;804      uint8_t tmp = 0;
00000a  2500              MOVS     r5,#0
;;;805     
;;;806      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_EN);
00000c  210c              MOVS     r1,#0xc
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  4605              MOV      r5,r0
;;;807      
;;;808      if (NewState != DISABLE)
000016  b10e              CBZ      r6,|L18.28|
;;;809      {
;;;810        /* Set the interrupts to be Enabled */    
;;;811        tmp |= (uint8_t)IO_IT;
000018  4325              ORRS     r5,r5,r4
00001a  e000              B        |L18.30|
                  |L18.28|
;;;812      }
;;;813      else
;;;814      {
;;;815        /* Set the interrupts to be Disabled */    
;;;816        tmp &= ~(uint8_t)IO_IT;
00001c  43a5              BICS     r5,r5,r4
                  |L18.30|
;;;817      }
;;;818      
;;;819      /* Set the register */
;;;820      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_EN, tmp);
00001e  462a              MOV      r2,r5
000020  210c              MOVS     r1,#0xc
000022  4638              MOV      r0,r7
000024  f7fffffe          BL       I2C_WriteDeviceRegister
;;;821      
;;;822      /* If all OK return IOE_OK */
;;;823      return IOE_OK;   
000028  2000              MOVS     r0,#0
;;;824    }
00002a  e8bd81f0          POP      {r4-r8,pc}
;;;825    
                          ENDP


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

                  IOE_IOPinConfig PROC
;;;697      */
;;;698    uint8_t IOE_IOPinConfig(uint8_t DeviceAddr, uint8_t IO_Pin, uint8_t Direction)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;699    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
;;;700      uint8_t tmp = 0;   
00000a  2500              MOVS     r5,#0
;;;701      
;;;702      /* Get all the Pins direction */
;;;703      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_DIR);
00000c  2113              MOVS     r1,#0x13
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  4605              MOV      r5,r0
;;;704      
;;;705      if (Direction != Direction_IN)
000016  b10e              CBZ      r6,|L19.28|
;;;706      {
;;;707        tmp |= (uint8_t)IO_Pin;
000018  4325              ORRS     r5,r5,r4
00001a  e000              B        |L19.30|
                  |L19.28|
;;;708      }  
;;;709      else 
;;;710      {
;;;711        tmp &= ~(uint8_t)IO_Pin;
00001c  43a5              BICS     r5,r5,r4
                  |L19.30|
;;;712      }
;;;713      
;;;714      /* Write the register new value */
;;;715      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_DIR, tmp);
00001e  462a              MOV      r2,r5
000020  2113              MOVS     r1,#0x13
000022  4638              MOV      r0,r7
000024  f7fffffe          BL       I2C_WriteDeviceRegister
;;;716      
;;;717      /* If all OK return IOE_OK */
;;;718      return IOE_OK;      
000028  2000              MOVS     r0,#0
;;;719    }
00002a  e8bd81f0          POP      {r4-r8,pc}
;;;720    
                          ENDP


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

                  IOE_ITConfig PROC
;;;211      */
;;;212    uint8_t IOE_ITConfig(uint32_t IOE_ITSRC_Source)
000000  b510              PUSH     {r4,lr}
;;;213    {   
000002  4604              MOV      r4,r0
;;;214      /* Configure the Interrupt output pin to generate low level (INT_CTRL) */
;;;215      IOE_ITOutConfig(Polarity_High, Type_Level);  
000004  2100              MOVS     r1,#0
000006  2004              MOVS     r0,#4
000008  f7fffffe          BL       IOE_ITOutConfig
;;;216      
;;;217      /* Manage the Joystick Interrupts */  
;;;218      if (IOE_ITSRC_Source & IOE_ITSRC_JOYSTICK)
00000c  f0140f04          TST      r4,#4
000010  d01a              BEQ      |L20.72|
;;;219      {   
;;;220        /* Enable the Global interrupt */  
;;;221        IOE_GITCmd(IOE_2_ADDR, ENABLE);     
000012  2101              MOVS     r1,#1
000014  2088              MOVS     r0,#0x88
000016  f7fffffe          BL       IOE_GITCmd
;;;222            
;;;223        /* Enable the Joystick pins to generate interrupt (GPIO_INT_EN) */
;;;224        IOE_IOITConfig(IOE_2_ADDR, IOE_JOY_IT, ENABLE);   
00001a  2201              MOVS     r2,#1
00001c  21f8              MOVS     r1,#0xf8
00001e  2088              MOVS     r0,#0x88
000020  f7fffffe          BL       IOE_IOITConfig
;;;225        
;;;226        /* Enable the Global GPIO Interrupt */
;;;227        IOE_GITConfig(IOE_2_ADDR, IOE_GIT_GPIO, ENABLE);    
000024  2201              MOVS     r2,#1
000026  2180              MOVS     r1,#0x80
000028  2088              MOVS     r0,#0x88
00002a  f7fffffe          BL       IOE_GITConfig
;;;228        
;;;229        /* Read the GPIO_IT_STA to clear all pending bits if any */
;;;230        I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_INT_STA);    
00002e  210d              MOVS     r1,#0xd
000030  2088              MOVS     r0,#0x88
000032  f7fffffe          BL       I2C_ReadDeviceRegister
;;;231        
;;;232        /* Enable the Joystick pins to generate interrupt */
;;;233        IOE_IOITConfig(IOE_2_ADDR, IOE_JOY_IT, ENABLE);  
000036  2201              MOVS     r2,#1
000038  21f8              MOVS     r1,#0xf8
00003a  2088              MOVS     r0,#0x88
00003c  f7fffffe          BL       IOE_IOITConfig
;;;234        
;;;235        /* Read the GPIO_IT_STA to clear all pending bits if any */
;;;236        I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_INT_STA);     
000040  210d              MOVS     r1,#0xd
000042  2088              MOVS     r0,#0x88
000044  f7fffffe          BL       I2C_ReadDeviceRegister
                  |L20.72|
;;;237      }
;;;238    
;;;239      /* Manage the MEMS Interrupts lines  */  
;;;240      if (IOE_ITSRC_Source & IOE_ITSRC_INMEMS)
000048  f0140f02          TST      r4,#2
00004c  d01a              BEQ      |L20.132|
;;;241      {   
;;;242        /* Enable the Global interrupt */  
;;;243        IOE_GITCmd(IOE_1_ADDR, ENABLE);     
00004e  2101              MOVS     r1,#1
000050  2082              MOVS     r0,#0x82
000052  f7fffffe          BL       IOE_GITCmd
;;;244            
;;;245        /* Enable the pins to generate interrupt (GPIO_INT_EN) */
;;;246        IOE_IOITConfig(IOE_1_ADDR, IOE_INMEMS_IT, ENABLE);   
000056  2201              MOVS     r2,#1
000058  210c              MOVS     r1,#0xc
00005a  2082              MOVS     r0,#0x82
00005c  f7fffffe          BL       IOE_IOITConfig
;;;247        
;;;248        /* Enable the Global GPIO Interrupt */
;;;249        IOE_GITConfig(IOE_1_ADDR, IOE_GIT_GPIO, ENABLE);    
000060  2201              MOVS     r2,#1
000062  2180              MOVS     r1,#0x80
000064  2082              MOVS     r0,#0x82
000066  f7fffffe          BL       IOE_GITConfig
;;;250        
;;;251        /* Read the GPIO_IT_STA to clear all pending bits if any */
;;;252        I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_INT_STA);    
00006a  210d              MOVS     r1,#0xd
00006c  2082              MOVS     r0,#0x82
00006e  f7fffffe          BL       I2C_ReadDeviceRegister
;;;253        
;;;254        /* Enable the pins to generate interrupt */
;;;255        IOE_IOITConfig(IOE_1_ADDR, IOE_INMEMS_IT, ENABLE);  
000072  2201              MOVS     r2,#1
000074  210c              MOVS     r1,#0xc
000076  2082              MOVS     r0,#0x82
000078  f7fffffe          BL       IOE_IOITConfig
;;;256        
;;;257        /* Read the GPIO_IT_STA to clear all pending bits if any */
;;;258        I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_INT_STA);     
00007c  210d              MOVS     r1,#0xd
00007e  2082              MOVS     r0,#0x82
000080  f7fffffe          BL       I2C_ReadDeviceRegister
                  |L20.132|
;;;259      }  
;;;260      
;;;261      /* Manage the Touch Screen Interrupts */  
;;;262      if (IOE_ITSRC_Source & IOE_ITSRC_TSC)
000084  f0140f01          TST      r4,#1
000088  d00c              BEQ      |L20.164|
;;;263      {   
;;;264        /* Enable the Global interrupt */  
;;;265        IOE_GITCmd(IOE_1_ADDR, ENABLE);     
00008a  2101              MOVS     r1,#1
00008c  2082              MOVS     r0,#0x82
00008e  f7fffffe          BL       IOE_GITCmd
;;;266               
;;;267        /* Enable the Global GPIO Interrupt */
;;;268        IOE_GITConfig(IOE_1_ADDR, (uint8_t)(IOE_GIT_TOUCH | IOE_GIT_FTH | IOE_GIT_FOV), ENABLE);    
000092  2201              MOVS     r2,#1
000094  2107              MOVS     r1,#7
000096  2082              MOVS     r0,#0x82
000098  f7fffffe          BL       IOE_GITConfig
;;;269        
;;;270        /* Read the GPIO_IT_STA to clear all pending bits if any */
;;;271        I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_INT_STA); 
00009c  210d              MOVS     r1,#0xd
00009e  2082              MOVS     r0,#0x82
0000a0  f7fffffe          BL       I2C_ReadDeviceRegister
                  |L20.164|
;;;272      }
;;;273      
;;;274      /* Configure the Interrupt line as EXTI source */
;;;275      IOE_EXTI_Config();    
0000a4  f7fffffe          BL       IOE_EXTI_Config
;;;276      
;;;277      /* If all OK return IOE_OK */
;;;278      return IOE_OK;
0000a8  2000              MOVS     r0,#0
;;;279    }
0000aa  bd10              POP      {r4,pc}
;;;280    
                          ENDP


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

                  IOE_ITOutConfig PROC
;;;1001     */
;;;1002   uint8_t IOE_ITOutConfig(uint8_t Polarity, uint8_t Type)
000000  b570              PUSH     {r4-r6,lr}
;;;1003   {
000002  4605              MOV      r5,r0
000004  460e              MOV      r6,r1
;;;1004     uint8_t tmp = 0;
000006  2400              MOVS     r4,#0
;;;1005     
;;;1006     /*  Get the register IOE_REG_INT_CTRL value */ 
;;;1007     tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_INT_CTRL);
000008  2109              MOVS     r1,#9
00000a  2082              MOVS     r0,#0x82
00000c  f7fffffe          BL       I2C_ReadDeviceRegister
000010  4604              MOV      r4,r0
;;;1008     
;;;1009     /* Mask the polarity and type bits */
;;;1010     tmp &= ~(uint8_t)0x06;
000012  f0240406          BIC      r4,r4,#6
;;;1011       
;;;1012     /* Modify the Interrupt Output line configuration */
;;;1013     tmp |= (uint8_t)(Polarity | Type);
000016  ea450006          ORR      r0,r5,r6
00001a  4304              ORRS     r4,r4,r0
;;;1014     
;;;1015     /* Set the register */
;;;1016     I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_CTRL, tmp);
00001c  4622              MOV      r2,r4
00001e  2109              MOVS     r1,#9
000020  2082              MOVS     r0,#0x82
000022  f7fffffe          BL       I2C_WriteDeviceRegister
;;;1017     
;;;1018     
;;;1019     /*  Get the register IOE_REG_INT_CTRL value */ 
;;;1020     tmp = I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_INT_CTRL);
000026  2109              MOVS     r1,#9
000028  2088              MOVS     r0,#0x88
00002a  f7fffffe          BL       I2C_ReadDeviceRegister
00002e  4604              MOV      r4,r0
;;;1021     /* Mask the polarity and type bits */
;;;1022     tmp &= ~(uint8_t)0x06;
000030  f0240406          BIC      r4,r4,#6
;;;1023       
;;;1024     /* Modify the Interrupt Output line configuration */
;;;1025     tmp |= (uint8_t)(Polarity | Type);
000034  ea450006          ORR      r0,r5,r6
000038  4304              ORRS     r4,r4,r0
;;;1026     
;;;1027     /* Set the register */
;;;1028     I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_INT_CTRL, tmp);  
00003a  4622              MOV      r2,r4
00003c  2109              MOVS     r1,#9
00003e  2088              MOVS     r0,#0x88
000040  f7fffffe          BL       I2C_WriteDeviceRegister
;;;1029     
;;;1030     /* If all OK return IOE_OK */
;;;1031     return IOE_OK;  
000044  2000              MOVS     r0,#0
;;;1032   }
000046  bd70              POP      {r4-r6,pc}
;;;1033   
                          ENDP


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

                  IOE_IsOperational PROC
;;;591      */
;;;592    uint8_t IOE_IsOperational(uint8_t DeviceAddr)
000000  b510              PUSH     {r4,lr}
;;;593    {
000002  4604              MOV      r4,r0
;;;594      /* Return Error if the ID is not correct */
;;;595      if( IOE_ReadID(DeviceAddr) != (uint16_t)STMPE811_ID )
000004  4620              MOV      r0,r4
000006  f7fffffe          BL       IOE_ReadID
00000a  f5a06100          SUB      r1,r0,#0x800
00000e  3911              SUBS     r1,r1,#0x11
000010  d006              BEQ      |L22.32|
;;;596      {
;;;597        /* Check if a Timeout occurred */
;;;598        if (IOE_TimeOut == 0)
000012  4804              LDR      r0,|L22.36|
000014  6800              LDR      r0,[r0,#0]  ; IOE_TimeOut
000016  b908              CBNZ     r0,|L22.28|
;;;599        {
;;;600          return(IOE_TimeoutUserCallback());
000018  2002              MOVS     r0,#2
                  |L22.26|
;;;601        }
;;;602        else
;;;603        {
;;;604          return IOE_FAILURE; /* ID is not Correct */
;;;605        }
;;;606      } 
;;;607      else 
;;;608      {
;;;609        return IOE_OK; /* ID is correct */
;;;610      }
;;;611    }
00001a  bd10              POP      {r4,pc}
                  |L22.28|
00001c  2001              MOVS     r0,#1                 ;604
00001e  e7fc              B        |L22.26|
                  |L22.32|
000020  2000              MOVS     r0,#0                 ;609
000022  e7fa              B        |L22.26|
;;;612    
                          ENDP

                  |L22.36|
                          DCD      IOE_TimeOut

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

                  IOE_JoyStickGetState PROC
;;;376    JOYState_TypeDef
;;;377     IOE_JoyStickGetState(void)
000000  b510              PUSH     {r4,lr}
;;;378    {
;;;379      uint8_t tmp = 0;
000002  2400              MOVS     r4,#0
;;;380      /* Read the status of all pins */
;;;381      tmp = (uint32_t)I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_GPIO_MP_STA);
000004  2112              MOVS     r1,#0x12
000006  2088              MOVS     r0,#0x88
000008  f7fffffe          BL       I2C_ReadDeviceRegister
00000c  4604              MOV      r4,r0
;;;382       
;;;383      /* Check the pressed keys */
;;;384      if ((tmp & JOY_IO_NONE) == JOY_IO_NONE)
00000e  f00400f8          AND      r0,r4,#0xf8
000012  28f8              CMP      r0,#0xf8
000014  d101              BNE      |L23.26|
;;;385      {
;;;386        return (JOYState_TypeDef) JOY_NONE;
000016  2000              MOVS     r0,#0
                  |L23.24|
;;;387      }
;;;388      else if (!(tmp & JOY_IO_SEL))
;;;389      {
;;;390        return (JOYState_TypeDef) JOY_SEL;
;;;391      }
;;;392      else if (!(tmp & JOY_IO_DOWN))
;;;393      {
;;;394        return (JOYState_TypeDef) JOY_DOWN;
;;;395      }
;;;396      else if (!(tmp & JOY_IO_LEFT))
;;;397      {
;;;398        return (JOYState_TypeDef) JOY_LEFT;
;;;399      }
;;;400      else if (!(tmp & JOY_IO_RIGHT))
;;;401      {
;;;402        return (JOYState_TypeDef) JOY_RIGHT;
;;;403      }
;;;404      else if (!(tmp & JOY_IO_UP))
;;;405      {
;;;406        return (JOYState_TypeDef) JOY_UP;
;;;407      }
;;;408      else
;;;409      { 
;;;410        return (JOYState_TypeDef) JOY_NONE;
;;;411      }
;;;412    }
000018  bd10              POP      {r4,pc}
                  |L23.26|
00001a  f0140f80          TST      r4,#0x80              ;388
00001e  d101              BNE      |L23.36|
000020  2001              MOVS     r0,#1                 ;390
000022  e7f9              B        |L23.24|
                  |L23.36|
000024  f0140f40          TST      r4,#0x40              ;392
000028  d101              BNE      |L23.46|
00002a  2002              MOVS     r0,#2                 ;394
00002c  e7f4              B        |L23.24|
                  |L23.46|
00002e  f0140f20          TST      r4,#0x20              ;396
000032  d101              BNE      |L23.56|
000034  2003              MOVS     r0,#3                 ;398
000036  e7ef              B        |L23.24|
                  |L23.56|
000038  f0140f10          TST      r4,#0x10              ;400
00003c  d101              BNE      |L23.66|
00003e  2004              MOVS     r0,#4                 ;402
000040  e7ea              B        |L23.24|
                  |L23.66|
000042  f0140f08          TST      r4,#8                 ;404
000046  d101              BNE      |L23.76|
000048  2005              MOVS     r0,#5                 ;406
00004a  e7e5              B        |L23.24|
                  |L23.76|
00004c  2000              MOVS     r0,#0                 ;410
00004e  e7e3              B        |L23.24|
;;;413    
                          ENDP


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

                  IOE_ReadID PROC
;;;639      */
;;;640    uint16_t IOE_ReadID(uint8_t DeviceAddr)
000000  b570              PUSH     {r4-r6,lr}
;;;641    {
000002  4605              MOV      r5,r0
;;;642      uint16_t tmp = 0;
000004  2400              MOVS     r4,#0
;;;643    
;;;644      /* Read device ID  */
;;;645      tmp = I2C_ReadDeviceRegister(DeviceAddr, 0);
000006  2100              MOVS     r1,#0
000008  4628              MOV      r0,r5
00000a  f7fffffe          BL       I2C_ReadDeviceRegister
00000e  4604              MOV      r4,r0
;;;646      tmp = (uint32_t)(tmp << 8);
000010  0224              LSLS     r4,r4,#8
;;;647      tmp |= (uint32_t)I2C_ReadDeviceRegister(DeviceAddr, 1);
000012  2101              MOVS     r1,#1
000014  4628              MOV      r0,r5
000016  f7fffffe          BL       I2C_ReadDeviceRegister
00001a  4304              ORRS     r4,r4,r0
;;;648      
;;;649      /* Return the ID */
;;;650      return (uint16_t)tmp;
00001c  4620              MOV      r0,r4
;;;651    }
00001e  bd70              POP      {r4-r6,pc}
;;;652    
                          ENDP


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

                  IOE_ReadIOPin PROC
;;;334      */
;;;335    uint8_t IOE_ReadIOPin(uint32_t IO_Pin)
000000  b570              PUSH     {r4-r6,lr}
;;;336    {
000002  4604              MOV      r4,r0
;;;337      uint8_t DeviceAddr = 0;
000004  2600              MOVS     r6,#0
;;;338      uint8_t tmp = 0;  
000006  2500              MOVS     r5,#0
;;;339      if (IO_Pin & IO1_IN_ALL_PINS)
000008  f0140f0c          TST      r4,#0xc
00000c  d001              BEQ      |L25.18|
;;;340      {
;;;341        DeviceAddr = IOE_1_ADDR;
00000e  2682              MOVS     r6,#0x82
000010  e006              B        |L25.32|
                  |L25.18|
;;;342      }
;;;343      else if (IO_Pin & IO2_IN_ALL_PINS)
000012  f0140ff8          TST      r4,#0xf8
000016  d001              BEQ      |L25.28|
;;;344      {
;;;345        DeviceAddr = IOE_2_ADDR;
000018  2688              MOVS     r6,#0x88
00001a  e001              B        |L25.32|
                  |L25.28|
;;;346      }
;;;347      else 
;;;348      {
;;;349        return PARAM_ERROR;
00001c  2003              MOVS     r0,#3
                  |L25.30|
;;;350      }
;;;351      
;;;352      /* Get all the Pins status */
;;;353      tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_MP_STA);
;;;354      if ((tmp & (uint8_t)IO_Pin) != 0)
;;;355      {
;;;356        return BitSet;
;;;357      }  
;;;358      else 
;;;359      {
;;;360        return BitReset;
;;;361      }
;;;362    }
00001e  bd70              POP      {r4-r6,pc}
                  |L25.32|
000020  2112              MOVS     r1,#0x12              ;353
000022  4630              MOV      r0,r6                 ;353
000024  f7fffffe          BL       I2C_ReadDeviceRegister
000028  4605              MOV      r5,r0                 ;353
00002a  b2e0              UXTB     r0,r4                 ;354
00002c  4205              TST      r5,r0                 ;354
00002e  d001              BEQ      |L25.52|
000030  2001              MOVS     r0,#1                 ;356
000032  e7f4              B        |L25.30|
                  |L25.52|
000034  2000              MOVS     r0,#0                 ;360
000036  e7f2              B        |L25.30|
;;;363    
                          ENDP


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

                  IOE_Reset PROC
;;;618      */
;;;619    uint8_t IOE_Reset(uint8_t DeviceAddr)
000000  b510              PUSH     {r4,lr}
;;;620    {
000002  4604              MOV      r4,r0
;;;621      /* Power Down the IO_Expander */
;;;622      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL1, 0x02);
000004  2202              MOVS     r2,#2
000006  2103              MOVS     r1,#3
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;623    
;;;624      /* wait for a delay to insure registers erasing */
;;;625      _delay_(2); 
00000e  2002              MOVS     r0,#2
000010  f7fffffe          BL       delay
;;;626      
;;;627      /* Power On the Codec after the power off => all registers are reinitialized*/
;;;628      I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL1, 0x00);
000014  2200              MOVS     r2,#0
000016  2103              MOVS     r1,#3
000018  4620              MOV      r0,r4
00001a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;629      
;;;630      /* If all OK return IOE_OK */
;;;631      return IOE_OK;    
00001e  2000              MOVS     r0,#0
;;;632    }
000020  bd10              POP      {r4,pc}
;;;633    
                          ENDP


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

                  IOE_TS_Config PROC
;;;830      */
;;;831    uint8_t IOE_TS_Config(void)
000000  b510              PUSH     {r4,lr}
;;;832    {
;;;833      uint8_t tmp = 0;  
000002  2400              MOVS     r4,#0
;;;834      
;;;835      /* Enable TSC Fct: already done in IOE_Config */
;;;836      tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_SYS_CTRL2);
000004  2104              MOVS     r1,#4
000006  2082              MOVS     r0,#0x82
000008  f7fffffe          BL       I2C_ReadDeviceRegister
00000c  4604              MOV      r4,r0
;;;837      tmp &= ~(uint32_t)(IOE_TS_FCT | IOE_ADC_FCT);
00000e  f0240403          BIC      r4,r4,#3
;;;838      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_SYS_CTRL2, tmp); 
000012  4622              MOV      r2,r4
000014  2104              MOVS     r1,#4
000016  2082              MOVS     r0,#0x82
000018  f7fffffe          BL       I2C_WriteDeviceRegister
;;;839      
;;;840      /* Enable the TSC global interrupts */
;;;841      tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_INT_EN);
00001c  210a              MOVS     r1,#0xa
00001e  2082              MOVS     r0,#0x82
000020  f7fffffe          BL       I2C_ReadDeviceRegister
000024  4604              MOV      r4,r0
;;;842      tmp |= (uint32_t)(IOE_GIT_TOUCH | IOE_GIT_FTH | IOE_GIT_FOV);
000026  f0440407          ORR      r4,r4,#7
;;;843      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_EN, tmp); 
00002a  4622              MOV      r2,r4
00002c  210a              MOVS     r1,#0xa
00002e  2082              MOVS     r0,#0x82
000030  f7fffffe          BL       I2C_WriteDeviceRegister
;;;844      
;;;845      /* Select Sample Time, bit number and ADC Reference */
;;;846      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_ADC_CTRL1, 0x49);
000034  2249              MOVS     r2,#0x49
000036  2120              MOVS     r1,#0x20
000038  2082              MOVS     r0,#0x82
00003a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;847      
;;;848      /* Wait for ~20 ms */
;;;849      _delay_(2);  
00003e  2002              MOVS     r0,#2
000040  f7fffffe          BL       delay
;;;850      
;;;851      /* Select the ADC clock speed: 3.25 MHz */
;;;852      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_ADC_CTRL2, 0x01);
000044  2201              MOVS     r2,#1
000046  2121              MOVS     r1,#0x21
000048  2082              MOVS     r0,#0x82
00004a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;853      
;;;854      /* Select TSC pins in non default mode */  
;;;855      tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_AF);
00004e  2117              MOVS     r1,#0x17
000050  2082              MOVS     r0,#0x82
000052  f7fffffe          BL       I2C_ReadDeviceRegister
000056  4604              MOV      r4,r0
;;;856      tmp &= ~(uint8_t)TOUCH_IO_ALL;
000058  f024041e          BIC      r4,r4,#0x1e
;;;857      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_AF, tmp); 
00005c  4622              MOV      r2,r4
00005e  2117              MOVS     r1,#0x17
000060  2082              MOVS     r0,#0x82
000062  f7fffffe          BL       I2C_WriteDeviceRegister
;;;858      
;;;859      /* Select 2 nF filter capacitor */
;;;860      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CFG, 0x9A);   
000066  229a              MOVS     r2,#0x9a
000068  2141              MOVS     r1,#0x41
00006a  2082              MOVS     r0,#0x82
00006c  f7fffffe          BL       I2C_WriteDeviceRegister
;;;861      
;;;862      /* Select single point reading  */
;;;863      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_TH, 0x01);
000070  2201              MOVS     r2,#1
000072  214a              MOVS     r1,#0x4a
000074  2082              MOVS     r0,#0x82
000076  f7fffffe          BL       I2C_WriteDeviceRegister
;;;864      
;;;865      /* Write 0x01 to clear the FIFO memory content. */
;;;866      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_STA, 0x01);
00007a  2201              MOVS     r2,#1
00007c  214b              MOVS     r1,#0x4b
00007e  2082              MOVS     r0,#0x82
000080  f7fffffe          BL       I2C_WriteDeviceRegister
;;;867      
;;;868      /* Write 0x00 to put the FIFO back into operation mode  */
;;;869      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_STA, 0x00);
000084  2200              MOVS     r2,#0
000086  214b              MOVS     r1,#0x4b
000088  2082              MOVS     r0,#0x82
00008a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;870      
;;;871      /* set the data format for Z value: 7 fractional part and 1 whole part */
;;;872      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_FRACT_XYZ, 0x01);
00008e  2201              MOVS     r2,#1
000090  2156              MOVS     r1,#0x56
000092  2082              MOVS     r0,#0x82
000094  f7fffffe          BL       I2C_WriteDeviceRegister
;;;873      
;;;874      /* set the driving capability of the device for TSC pins: 50mA */
;;;875      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_I_DRIVE, 0x01);
000098  2201              MOVS     r2,#1
00009a  2158              MOVS     r1,#0x58
00009c  2082              MOVS     r0,#0x82
00009e  f7fffffe          BL       I2C_WriteDeviceRegister
;;;876      
;;;877      /* Use no tracking index, touch-screen controller operation mode (XYZ) and 
;;;878         enable the TSC */
;;;879      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CTRL, 0x01);
0000a2  2201              MOVS     r2,#1
0000a4  2140              MOVS     r1,#0x40
0000a6  2082              MOVS     r0,#0x82
0000a8  f7fffffe          BL       I2C_WriteDeviceRegister
;;;880      
;;;881      /*  Clear all the status pending bits */
;;;882      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_STA, 0xFF); 
0000ac  22ff              MOVS     r2,#0xff
0000ae  210b              MOVS     r1,#0xb
0000b0  2082              MOVS     r0,#0x82
0000b2  f7fffffe          BL       I2C_WriteDeviceRegister
;;;883      
;;;884      /* Initialize the TS structure to their default values */ 
;;;885      TS_State.TouchDetected = TS_State.X = TS_State.Y = TS_State.Z = 0;
0000b6  2000              MOVS     r0,#0
0000b8  4902              LDR      r1,|L27.196|
0000ba  80c8              STRH     r0,[r1,#6]
0000bc  8088              STRH     r0,[r1,#4]
0000be  8048              STRH     r0,[r1,#2]
0000c0  8008              STRH     r0,[r1,#0]
;;;886      
;;;887      /* All configuration done */
;;;888      return IOE_OK;  
;;;889    }
0000c2  bd10              POP      {r4,pc}
;;;890    
                          ENDP

                  |L27.196|
                          DCD      TS_State

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

                  IOE_TS_GetState PROC
;;;418      */
;;;419    TS_STATE* IOE_TS_GetState(void)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;420    {
;;;421      uint32_t xDiff, yDiff , x , y;
;;;422      static uint32_t _x = 0, _y = 0;
;;;423      
;;;424      /* Check if the Touch detect event happened */
;;;425      TS_State.TouchDetected = (I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CTRL) & 0x80);
000004  2140              MOVS     r1,#0x40
000006  2082              MOVS     r0,#0x82
000008  f7fffffe          BL       I2C_ReadDeviceRegister
00000c  f0000080          AND      r0,r0,#0x80
000010  4920              LDR      r1,|L28.148|
000012  8008              STRH     r0,[r1,#0]
;;;426      if(TS_State.TouchDetected) 
000014  4608              MOV      r0,r1
000016  8800              LDRH     r0,[r0,#0]  ; TS_State
000018  b320              CBZ      r0,|L28.100|
;;;427      {
;;;428        x = IOE_TS_Read_X();
00001a  f7fffffe          BL       IOE_TS_Read_X
00001e  4605              MOV      r5,r0
;;;429        y = IOE_TS_Read_Y();
000020  f7fffffe          BL       IOE_TS_Read_Y
000024  4604              MOV      r4,r0
;;;430        xDiff = x > _x? (x - _x): (_x - x);
000026  481c              LDR      r0,|L28.152|
000028  6800              LDR      r0,[r0,#0]  ; _x
00002a  4285              CMP      r5,r0
00002c  d903              BLS      |L28.54|
00002e  481a              LDR      r0,|L28.152|
000030  6800              LDR      r0,[r0,#0]  ; _x
000032  1a28              SUBS     r0,r5,r0
000034  e002              B        |L28.60|
                  |L28.54|
000036  4818              LDR      r0,|L28.152|
000038  6800              LDR      r0,[r0,#0]  ; _x
00003a  1b40              SUBS     r0,r0,r5
                  |L28.60|
00003c  4606              MOV      r6,r0
;;;431        yDiff = y > _y? (y - _y): (_y - y);       
00003e  4817              LDR      r0,|L28.156|
000040  6800              LDR      r0,[r0,#0]  ; _y
000042  4284              CMP      r4,r0
000044  d903              BLS      |L28.78|
000046  4815              LDR      r0,|L28.156|
000048  6800              LDR      r0,[r0,#0]  ; _y
00004a  1a20              SUBS     r0,r4,r0
00004c  e002              B        |L28.84|
                  |L28.78|
00004e  4813              LDR      r0,|L28.156|
000050  6800              LDR      r0,[r0,#0]  ; _y
000052  1b00              SUBS     r0,r0,r4
                  |L28.84|
000054  4607              MOV      r7,r0
;;;432        if (xDiff + yDiff > 5)
000056  19f0              ADDS     r0,r6,r7
000058  2805              CMP      r0,#5
00005a  d903              BLS      |L28.100|
;;;433        {
;;;434          _x = x;
00005c  480e              LDR      r0,|L28.152|
00005e  6005              STR      r5,[r0,#0]  ; _x
;;;435          _y = y;       
000060  480e              LDR      r0,|L28.156|
000062  6004              STR      r4,[r0,#0]  ; _y
                  |L28.100|
;;;436        }
;;;437      }  
;;;438      /* Update the X position */
;;;439      TS_State.X = _x;
000064  480c              LDR      r0,|L28.152|
000066  6800              LDR      r0,[r0,#0]  ; _x
000068  490a              LDR      r1,|L28.148|
00006a  8048              STRH     r0,[r1,#2]
;;;440        
;;;441      /* Update the Y position */  
;;;442      TS_State.Y = _y;
00006c  480b              LDR      r0,|L28.156|
00006e  6800              LDR      r0,[r0,#0]  ; _y
000070  8088              STRH     r0,[r1,#4]
;;;443      /* Update the Z Pression index */  
;;;444      TS_State.Z = IOE_TS_Read_Z();  
000072  f7fffffe          BL       IOE_TS_Read_Z
000076  4907              LDR      r1,|L28.148|
000078  80c8              STRH     r0,[r1,#6]
;;;445      
;;;446      /* Clear the interrupt pending bit and enable the FIFO again */
;;;447      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_STA, 0x01);
00007a  2201              MOVS     r2,#1
00007c  214b              MOVS     r1,#0x4b
00007e  2082              MOVS     r0,#0x82
000080  f7fffffe          BL       I2C_WriteDeviceRegister
;;;448      I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_STA, 0x00);
000084  2200              MOVS     r2,#0
000086  214b              MOVS     r1,#0x4b
000088  2082              MOVS     r0,#0x82
00008a  f7fffffe          BL       I2C_WriteDeviceRegister
;;;449      
;;;450      /* Return pointer to the updated structure */
;;;451      return &TS_State; 
00008e  4801              LDR      r0,|L28.148|
;;;452    }
000090  e8bd81f0          POP      {r4-r8,pc}
;;;453    
                          ENDP

                  |L28.148|
                          DCD      TS_State
                  |L28.152|
                          DCD      ||_x||
                  |L28.156|
                          DCD      ||_y||

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

                  IOE_TS_Read_X PROC
;;;1339     */
;;;1340   static uint16_t IOE_TS_Read_X(void)
000000  b570              PUSH     {r4-r6,lr}
;;;1341   {
;;;1342     int32_t x, xr;
;;;1343    
;;;1344     x = I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_Y);
000002  214f              MOVS     r1,#0x4f
000004  2082              MOVS     r0,#0x82
000006  f7fffffe          BL       I2C_ReadDataBuffer
00000a  4605              MOV      r5,r0
;;;1345     
;;;1346     /* first correction */
;;;1347     xr =  (x * 320) >> 12;
00000c  eb050085          ADD      r0,r5,r5,LSL #2
000010  f3401493          SBFX     r4,r0,#6,#20
;;;1348     /* second correction */
;;;1349     xr = ((xr * 32)/29) - 17;
000014  0160              LSLS     r0,r4,#5
000016  211d              MOVS     r1,#0x1d
000018  fb90f0f1          SDIV     r0,r0,r1
00001c  f1a00411          SUB      r4,r0,#0x11
;;;1350     
;;;1351     if(xr <= 0)
000020  2c00              CMP      r4,#0
000022  dc00              BGT      |L29.38|
;;;1352       xr = 0;
000024  2400              MOVS     r4,#0
                  |L29.38|
;;;1353     
;;;1354     return (uint16_t)(xr); 
000026  b2a0              UXTH     r0,r4
;;;1355   }
000028  bd70              POP      {r4-r6,pc}
;;;1356   
                          ENDP


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

                  IOE_TS_Read_Y PROC
;;;1361     */
;;;1362   static uint16_t IOE_TS_Read_Y(void)
000000  b570              PUSH     {r4-r6,lr}
;;;1363   {
;;;1364     int32_t y, yr;
;;;1365     y= I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_X);
000002  214d              MOVS     r1,#0x4d
000004  2082              MOVS     r0,#0x82
000006  f7fffffe          BL       I2C_ReadDataBuffer
00000a  4605              MOV      r5,r0
;;;1366     
;;;1367     yr= (y * 240) >> 12;
00000c  ebc51005          RSB      r0,r5,r5,LSL #4
000010  f3402413          SBFX     r4,r0,#8,#20
;;;1368     yr = ((yr * 240) / 217) - 12;
000014  ebc41004          RSB      r0,r4,r4,LSL #4
000018  0100              LSLS     r0,r0,#4
00001a  21d9              MOVS     r1,#0xd9
00001c  fb90f0f1          SDIV     r0,r0,r1
000020  f1a0040c          SUB      r4,r0,#0xc
;;;1369     
;;;1370     if(yr <= 0)
000024  2c00              CMP      r4,#0
000026  dc00              BGT      |L30.42|
;;;1371       yr = 0;
000028  2400              MOVS     r4,#0
                  |L30.42|
;;;1372     
;;;1373     return (uint16_t)(yr); 
00002a  b2a0              UXTH     r0,r4
;;;1374   }
00002c  bd70              POP      {r4-r6,pc}
;;;1375   
                          ENDP


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

                  IOE_TS_Read_Z PROC
;;;1380     */
;;;1381   static uint16_t IOE_TS_Read_Z(void)
000000  b510              PUSH     {r4,lr}
;;;1382   {
;;;1383     uint32_t z;
;;;1384     z = I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_Z);
000002  2151              MOVS     r1,#0x51
000004  2082              MOVS     r0,#0x82
000006  f7fffffe          BL       I2C_ReadDataBuffer
00000a  4604              MOV      r4,r0
;;;1385     
;;;1386     
;;;1387     if(z <= 0)
00000c  b904              CBNZ     r4,|L31.16|
;;;1388       z = 0;
00000e  2400              MOVS     r4,#0
                  |L31.16|
;;;1389     
;;;1390     return (uint16_t)(z); 
000010  b2a0              UXTH     r0,r4
;;;1391   }
000012  bd10              POP      {r4,pc}
;;;1392   
                          ENDP


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

                  IOE_TempSens_Config PROC
;;;895      */
;;;896    uint8_t IOE_TempSens_Config(void)
000000  b510              PUSH     {r4,lr}
;;;897    {
;;;898      __IO uint8_t tmp = 0;
000002  2400              MOVS     r4,#0
;;;899      
;;;900      /* Enable Temperature Sensor Fct: already done in IOE_Config */
;;;901      tmp = I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_SYS_CTRL2);
000004  2104              MOVS     r1,#4
000006  2088              MOVS     r0,#0x88
000008  f7fffffe          BL       I2C_ReadDeviceRegister
00000c  4604              MOV      r4,r0
;;;902      tmp &= ~(uint32_t)(IOE_TEMPSENS_FCT | IOE_ADC_FCT);
00000e  f0240409          BIC      r4,r4,#9
;;;903      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_SYS_CTRL2, tmp);  
000012  4622              MOV      r2,r4
000014  2104              MOVS     r1,#4
000016  2088              MOVS     r0,#0x88
000018  f7fffffe          BL       I2C_WriteDeviceRegister
;;;904      
;;;905      /* Enable the TEMPSENS module */
;;;906      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_TEMP_CTRL, 0x01);
00001c  2201              MOVS     r2,#1
00001e  2160              MOVS     r1,#0x60
000020  2088              MOVS     r0,#0x88
000022  f7fffffe          BL       I2C_WriteDeviceRegister
;;;907      
;;;908      /* Aquire data enable */
;;;909      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_TEMP_CTRL, 0x3);
000026  2203              MOVS     r2,#3
000028  2160              MOVS     r1,#0x60
00002a  2088              MOVS     r0,#0x88
00002c  f7fffffe          BL       I2C_WriteDeviceRegister
;;;910      
;;;911      /* All configuration done */
;;;912      return IOE_OK;
000030  2000              MOVS     r0,#0
;;;913    }
000032  bd10              POP      {r4,pc}
;;;914    
                          ENDP


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

                  IOE_TempSens_GetData PROC
;;;458      */
;;;459    uint32_t IOE_TempSens_GetData(void)
000000  b510              PUSH     {r4,lr}
;;;460    {  
;;;461      static __IO uint32_t tmp = 0;  
;;;462        
;;;463      /* Acquire data enable */
;;;464      I2C_WriteDeviceRegister(IOE_2_ADDR, IOE_REG_TEMP_CTRL, 0x03);
000002  2203              MOVS     r2,#3
000004  2160              MOVS     r1,#0x60
000006  2088              MOVS     r0,#0x88
000008  f7fffffe          BL       I2C_WriteDeviceRegister
;;;465      
;;;466      /* Enable the TEMPSENS module */
;;;467      tmp = (uint32_t)((I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_TEMP_DATA) & 0x03) << 8); 
00000c  2161              MOVS     r1,#0x61
00000e  2088              MOVS     r0,#0x88
000010  f7fffffe          BL       I2C_ReadDeviceRegister
000014  0780              LSLS     r0,r0,#30
000016  0d80              LSRS     r0,r0,#22
000018  4910              LDR      r1,|L33.92|
00001a  6008              STR      r0,[r1,#0]  ; tmp
;;;468      tmp |= (uint32_t)I2C_ReadDeviceRegister(IOE_2_ADDR, IOE_REG_TEMP_DATA + 1); 
00001c  2162              MOVS     r1,#0x62
00001e  2088              MOVS     r0,#0x88
000020  f7fffffe          BL       I2C_ReadDeviceRegister
000024  490d              LDR      r1,|L33.92|
000026  6809              LDR      r1,[r1,#0]  ; tmp
000028  4308              ORRS     r0,r0,r1
00002a  490c              LDR      r1,|L33.92|
00002c  6008              STR      r0,[r1,#0]  ; tmp
;;;469      
;;;470      tmp = (uint32_t)((33 * tmp * 100) / 751);
00002e  4608              MOV      r0,r1
000030  6800              LDR      r0,[r0,#0]  ; tmp
000032  eb001040          ADD      r0,r0,r0,LSL #5
000036  2164              MOVS     r1,#0x64
000038  4348              MULS     r0,r1,r0
00003a  f24021ef          MOV      r1,#0x2ef
00003e  fbb0f0f1          UDIV     r0,r0,r1
000042  4906              LDR      r1,|L33.92|
000044  6008              STR      r0,[r1,#0]  ; tmp
;;;471      tmp = (uint32_t)((tmp + 5) / 10);
000046  4608              MOV      r0,r1
000048  6800              LDR      r0,[r0,#0]  ; tmp
00004a  1d40              ADDS     r0,r0,#5
00004c  210a              MOVS     r1,#0xa
00004e  fbb0f0f1          UDIV     r0,r0,r1
000052  4902              LDR      r1,|L33.92|
000054  6008              STR      r0,[r1,#0]  ; tmp
;;;472      
;;;473      /* return the temperature row value */
;;;474      return tmp;
000056  4608              MOV      r0,r1
000058  6800              LDR      r0,[r0,#0]  ; tmp
;;;475    }
00005a  bd10              POP      {r4,pc}
;;;476    
                          ENDP

                  |L33.92|
                          DCD      tmp

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

                  IOE_WriteIOPin PROC
;;;291      */
;;;292    uint8_t IOE_WriteIOPin(uint8_t IO_Pin, IOE_BitValue_TypeDef BitVal)
000000  b570              PUSH     {r4-r6,lr}
;;;293    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;294      uint8_t DeviceAddr = 0;
000006  2600              MOVS     r6,#0
;;;295      
;;;296      /* Get the IO expander Address according to which pin is to be controlled */
;;;297      if (IO_Pin & IO1_OUT_ALL_PINS)
000008  f0140f01          TST      r4,#1
00000c  d001              BEQ      |L34.18|
;;;298      {
;;;299        DeviceAddr = IOE_1_ADDR;
00000e  2682              MOVS     r6,#0x82
000010  e006              B        |L34.32|
                  |L34.18|
;;;300      }
;;;301      else if (IO_Pin & IO2_OUT_ALL_PINS)
000012  f0140f05          TST      r4,#5
000016  d001              BEQ      |L34.28|
;;;302      {
;;;303        DeviceAddr = IOE_2_ADDR;
000018  2688              MOVS     r6,#0x88
00001a  e001              B        |L34.32|
                  |L34.28|
;;;304      }
;;;305      else
;;;306      {
;;;307        return PARAM_ERROR;
00001c  2003              MOVS     r0,#3
                  |L34.30|
;;;308      }
;;;309      
;;;310      /* Apply the bit value to the selected pin */
;;;311      if (BitVal == BitReset)
;;;312      {
;;;313        /* Set the register */
;;;314        I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_CLR_PIN, IO_Pin);
;;;315      }
;;;316      else
;;;317      {
;;;318        /* Set the register */
;;;319        I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_SET_PIN, IO_Pin);
;;;320      }
;;;321      
;;;322      return IOE_OK;
;;;323    }
00001e  bd70              POP      {r4-r6,pc}
                  |L34.32|
000020  b92d              CBNZ     r5,|L34.46|
000022  4622              MOV      r2,r4                 ;314
000024  2111              MOVS     r1,#0x11              ;314
000026  4630              MOV      r0,r6                 ;314
000028  f7fffffe          BL       I2C_WriteDeviceRegister
00002c  e004              B        |L34.56|
                  |L34.46|
00002e  4622              MOV      r2,r4                 ;319
000030  2110              MOVS     r1,#0x10              ;319
000032  4630              MOV      r0,r6                 ;319
000034  f7fffffe          BL       I2C_WriteDeviceRegister
                  |L34.56|
000038  2000              MOVS     r0,#0                 ;322
00003a  e7f0              B        |L34.30|
;;;324    
                          ENDP


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

                  delay PROC
;;;1582     */
;;;1583   static void delay(__IO uint32_t nCount)
000000  4601              MOV      r1,r0
;;;1584   {
;;;1585     __IO uint32_t index = 0; 
000002  bf00              NOP      
;;;1586     for(index = (100000 * nCount); index != 0; index--)
000004  4a03              LDR      r2,|L35.20|
000006  fb01f002          MUL      r0,r1,r2
00000a  e000              B        |L35.14|
                  |L35.12|
00000c  1e40              SUBS     r0,r0,#1
                  |L35.14|
00000e  2800              CMP      r0,#0
000010  d1fc              BNE      |L35.12|
;;;1587     {
;;;1588     }
;;;1589   }
000012  4770              BX       lr
;;;1590   #endif /* USE_Delay*/
                          ENDP

                  |L35.20|
                          DCD      0x000186a0

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

                  IOE_TimeOut
                          DCD      0x00003000
                  ||_x||
                          DCD      0x00000000
                  ||_y||
                          DCD      0x00000000
                  tmp
                          DCD      0x00000000
                  TS_State
                          %        8

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\Utilities\\STM32_EVAL\\STM3240_41_G_EVAL\\stm324xg_eval_ioe.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___19_stm324xg_eval_ioe_c_5aedb819____REV16|
#line 114 "C:\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___19_stm324xg_eval_ioe_c_5aedb819____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___19_stm324xg_eval_ioe_c_5aedb819____REVSH|
#line 128
|__asm___19_stm324xg_eval_ioe_c_5aedb819____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
