开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
Flash.s43
资源名称：VsonBryanFaxConexant070517.rar　[点击查看]
上传用户：xhjmsc
上传日期：2019-09-13
资源大小：389k
文件大小：27k
源码类别：

传真(Fax)编程

开发平台：

C/C++

Flash.s43：源码内容
  1.         NAME Flash
  3.         RTMODEL "__double_size", "32"
  4.         RTMODEL "__pic", "no"
  5.         RTMODEL "__reg_r4", "free"
  6.         RTMODEL "__reg_r5", "free"
  7.         RTMODEL "__rt_version", "1"
  9.         RSEG CSTACK:DATA:SORT:NOROOT(1)
  11.         EXTERN COLUMN_ADDRESS_LOW
  12.         EXTERN COLUMN_ADDRESS_HIGH
  13.         EXTERN ROW_ADDRESS_LOW
  14.         EXTERN ROW_ADDRESS_HIGH
  15.         EXTERN COMMAND_VAL
  16.         EXTERN ADDRESS_VALUE
  17.         EXTERN FLASH_STATUS
  18.         EXTERN aucUartRxBuf
  19.         EXTERN ATcmdDelay
  20.         FUNCTION ATcmdDelay,0202H
  21.         EXTERN FLASH_READ_DATA
  22.         EXTERN ?longjmp_r4
  23.         EXTERN ?longjmp_r5
  24.         EXTERN ?setjmp_r4
  25.         EXTERN ?setjmp_r5
  27.         PUBWEAK ?setjmp_save_r4
  28.         PUBWEAK ?setjmp_save_r5
  29.         PUBLIC ADDRESS_LATCH_INTO
  30.         FUNCTION ADDRESS_LATCH_INTO,0203H
  31.         LOCFRAME CSTACK, 2, STACK
  32.         PUBLIC COMMAND_LATCH_INTO
  33.         FUNCTION COMMAND_LATCH_INTO,0203H
  34.         LOCFRAME CSTACK, 2, STACK
  35.         PUBLIC ERASE_ONE_BLOCK
  36.         FUNCTION ERASE_ONE_BLOCK,021203H
  37.         LOCFRAME CSTACK, 4, STACK
  38.         PUBLIC FLASH_READ_ID
  39.         FUNCTION FLASH_READ_ID,021203H
  40.         LOCFRAME CSTACK, 2, STACK
  41.         PUBLIC Flash_Reset
  42.         FUNCTION Flash_Reset,021203H
  43.         LOCFRAME CSTACK, 4, STACK
  44.         PUBWEAK P2IN
  45.         PUBWEAK P2OUT
  46.         PUBWEAK P5DIR
  47.         PUBWEAK P5IN
  48.         PUBWEAK P5OUT
  49.         PUBLIC PROGRAM_256_BYTE
  50.         FUNCTION PROGRAM_256_BYTE,021203H
  51.         LOCFRAME CSTACK, 8, STACK
  52.         PUBLIC PROGRAM_ONE_PAGE
  53.         FUNCTION PROGRAM_ONE_PAGE,021203H
  54.         LOCFRAME CSTACK, 8, STACK
  55.         PUBLIC READ_256_BYTE
  56.         FUNCTION READ_256_BYTE,021203H
  57.         LOCFRAME CSTACK, 6, STACK
  58.         PUBLIC READ_ONE_DATA
  59.         FUNCTION READ_ONE_DATA,0203H
  60.         LOCFRAME CSTACK, 2, STACK
  61.         PUBLIC READ_STATUS
  62.         FUNCTION READ_STATUS,021203H
  63.         LOCFRAME CSTACK, 2, STACK
  64.         PUBLIC ZERO_ADDRESS
  65.         FUNCTION ZERO_ADDRESS,0203H
  66.         LOCFRAME CSTACK, 2, STACK
  67.         
  68.         CFI Names cfiNames0
  69.         CFI StackFrame CFA SP DATA
  70.         CFI Resource PC:16, SP:16, SR:16, R4:16, R5:16, R6:16, R7:16, R8:16
  71.         CFI Resource R9:16, R10:16, R11:16, R12:16, R13:16, R14:16, R15:16
  72.         CFI EndNames cfiNames0
  73.         
  74.         CFI Common cfiCommon0 Using cfiNames0
  75.         CFI CodeAlign 2
  76.         CFI DataAlign 2
  77.         CFI ReturnAddress PC CODE
  78.         CFI CFA SP+2
  79.         CFI PC Frame(CFA, -2)
  80.         CFI SR Undefined
  81.         CFI R4 SameValue
  82.         CFI R5 SameValue
  83.         CFI R6 SameValue
  84.         CFI R7 SameValue
  85.         CFI R8 SameValue
  86.         CFI R9 SameValue
  87.         CFI R10 SameValue
  88.         CFI R11 SameValue
  89.         CFI R12 Undefined
  90.         CFI R13 Undefined
  91.         CFI R14 Undefined
  92.         CFI R15 Undefined
  93.         CFI EndCommon cfiCommon0
  94.         
  95. // E:projectFaxProgramVson_Bryan_Fax_Conexant_070423filesFlash.c
  96. //    1 //Flash model HY27UF081G2M
  97. //    2 
  98. //    3 #include "includeH.h"
  100.         ASEGN DATA16_AN:DATA:NOROOT,028H
  101. // unsigned char const volatile __data P2IN
  102. P2IN:
  103.         DS8 1
  105.         ASEGN DATA16_AN:DATA:NOROOT,029H
  106. // unsigned char volatile __data P2OUT
  107. P2OUT:
  108.         DS8 1
  110.         ASEGN DATA16_AN:DATA:NOROOT,030H
  111. // unsigned char const volatile __data P5IN
  112. P5IN:
  113.         DS8 1
  115.         ASEGN DATA16_AN:DATA:NOROOT,031H
  116. // unsigned char volatile __data P5OUT
  117. P5OUT:
  118.         DS8 1
  120.         ASEGN DATA16_AN:DATA:NOROOT,032H
  121. // unsigned char volatile __data P5DIR
  122. P5DIR:
  123.         DS8 1
  124. //    4 
  125. //    5 
  126. //    6 //***********************************************************************************
  127. //    7 /*
  128. //    8 void FlashPageCopy(void)
  129. //    9 {
  130. //   10          unsigned char ucFlashSttsOverflowCnt=0;
  131. //   11          COMMAND_VAL=0x00; //#0X00 //00H READ1 0-527BYTE
  132. //   12  COMMAND_LATCH_INTO();
  133. //   13 //ADDRESS
  134. //   14  ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  135. //   15  ADDRESS_LATCH_INTO();
  136. //   16 
  137. //   17  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  138. //   18  ADDRESS_LATCH_INTO();
  139. //   19 
  140. //   20  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  141. //   21  ADDRESS_LATCH_INTO();
  142. //   22 
  143. //   23  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  144. //   24  ADDRESS_LATCH_INTO();
  145. //   25  FLASH_CON_PORT_OUT &=~ ALE;
  146. //   26 
  147. //   27  COMMAND_VAL=0X35;
  148. //   28  COMMAND_LATCH_INTO();
  149. //   29  //ATcmdDelay();
  150. //   30  while((FLASH_CON_PORT_IN & RB)==0);
  151. //   31    
  152. //   32          COMMAND_VAL=0x85;
  153. //   33  COMMAND_LATCH_INTO();
  154. //   34 
  155. //   35 //ADDRESS
  156. //   36  ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  157. //   37  ADDRESS_LATCH_INTO();
  158. //   38 
  159. //   39  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  160. //   40  ADDRESS_LATCH_INTO();
  161. //   41 
  162. //   42  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  163. //   43  ADDRESS_LATCH_INTO();
  164. //   44 
  165. //   45  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  166. //   46  ADDRESS_LATCH_INTO();
  167. //   47 
  168. //   48  FLASH_CON_PORT_OUT &=~ ALE;
  169. //   49 
  170. //   50  COMMAND_VAL=cFlashWriteInitiateCmd; //10H INITIATES PROGRAM
  171. //   51  COMMAND_LATCH_INTO();
  172. //   52 
  173. //   53  READ_STATUS();
  174. //   54  ucFlashSttsOverflowCnt=0;
  175. //   55  if(FLASH_STATUS==1&&(ucFlashSttsOverflowCnt++)<2)
  176. //   56  {
  177. //   57  ;
  178. //   58  }
  179. //   59 }
  180. //   60 */
  181. //   61 //***********************************************************************************
  183.         RSEG CODE:CODE:SORT:NOROOT(1)
  184. //   62 void ZERO_ADDRESS(void)
  185. ZERO_ADDRESS:
  186.         CFI Block cfiBlock0 Using cfiCommon0
  187.         CFI Function ZERO_ADDRESS
  188. //   63 {
  189. //   64  COLUMN_ADDRESS_LOW=0X00;
  190. MOV.B #0x0, &COLUMN_ADDRESS_LOW
  191. //   65  COLUMN_ADDRESS_HIGH=0X00;
  192. MOV.B #0x0, &COLUMN_ADDRESS_HIGH
  193. //   66  ROW_ADDRESS_LOW=0X00;
  194. MOV.B #0x0, &ROW_ADDRESS_LOW
  195. //   67  ROW_ADDRESS_HIGH=0X00;
  196. MOV.B #0x0, &ROW_ADDRESS_HIGH
  197. //   68 }
  198. RET
  199.         CFI EndBlock cfiBlock0
  200. //   69 
  202.         RSEG CODE:CODE:NOROOT(1)
  203. //   70 void ERASE_ONE_BLOCK(void)
  204. ERASE_ONE_BLOCK:
  205.         CFI Block cfiBlock1 Using cfiCommon0
  206.         CFI Function ERASE_ONE_BLOCK
  207. //   71 {
  208.         FUNCALL ERASE_ONE_BLOCK, Flash_Reset
  209.         LOCFRAME CSTACK, 4, STACK
  210.         FUNCALL ERASE_ONE_BLOCK, COMMAND_LATCH_INTO
  211.         LOCFRAME CSTACK, 4, STACK
  212.         FUNCALL ERASE_ONE_BLOCK, ADDRESS_LATCH_INTO
  213.         LOCFRAME CSTACK, 4, STACK
  214.         FUNCALL ERASE_ONE_BLOCK, ADDRESS_LATCH_INTO
  215.         LOCFRAME CSTACK, 4, STACK
  216.         FUNCALL ERASE_ONE_BLOCK, COMMAND_LATCH_INTO
  217.         LOCFRAME CSTACK, 4, STACK
  218.         FUNCALL ERASE_ONE_BLOCK, READ_STATUS
  219.         LOCFRAME CSTACK, 4, STACK
  220. PUSH.W R10
  221.         CFI R10 Frame(CFA, -4)
  222.         CFI CFA SP+4
  223. //   72                 unsigned int wGeneralCount = 0;
  224. MOV.W #0x0, R10
  225. //   73 //COMMAND
  226. //   74  Flash_Reset();
  227. CALL #Flash_Reset
  228. //   75 
  229. //   76  COMMAND_VAL=0X60;
  230. MOV.B #0x60, &COMMAND_VAL
  231. //   77  COMMAND_LATCH_INTO();
  232. CALL #COMMAND_LATCH_INTO
  233. //   78 
  234. //   79 //ADDRESS
  235. //   80  /* ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  236. //   81  ADDRESS_LATCH_INTO();
  237. //   82 
  238. //   83  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  239. //   84  ADDRESS_LATCH_INTO();                 */ //a bug of Sep. 15
  240. //   85 
  241. //   86  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  242. MOV.B &ROW_ADDRESS_LOW, &ADDRESS_VALUE
  243. //   87  ADDRESS_LATCH_INTO();
  244. CALL #ADDRESS_LATCH_INTO
  245. //   88 
  246. //   89  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  247. MOV.B &ROW_ADDRESS_HIGH, &ADDRESS_VALUE
  248. //   90  ADDRESS_LATCH_INTO();
  249. CALL #ADDRESS_LATCH_INTO
  250. //   91  FLASH_CON_PORT_OUT &=~ ALE;
  251. BIC.B #0x2, &0x29
  252. //   92 
  253. //   93  COMMAND_VAL=0XD0;
  254. MOV.B #0xd0, &COMMAND_VAL
  255. //   94  COMMAND_LATCH_INTO();
  256. CALL #COMMAND_LATCH_INTO
  257. //   95  //delay1ms();
  258. //   96 
  259. //   97  READ_STATUS();
  260. CALL #READ_STATUS
  261. //   98  while(wGeneralCount++<0xffff) //Jan. 18, 2007
  262. ??ERASE_ONE_BLOCK_0:
  263. MOV.W R10, R14
  264. MOV.W #0x1, R10
  265. ADD.W R14, R10
  266. CMP.W #0xffff, R14
  267. JEQ ??ERASE_ONE_BLOCK_1
  268. //   99  {if (FLASH_STATUS==0) break;}
  269. CMP.B #0x0, &FLASH_STATUS
  270. JNE ??ERASE_ONE_BLOCK_0
  271. //  100 
  272. //  101 }
  273. ??ERASE_ONE_BLOCK_1:
  274. POP.W R10
  275.         CFI R10 SameValue
  276.         CFI CFA SP+2
  277. RET
  278.         CFI EndBlock cfiBlock1
  279. //  102 
  280. //  103 //***********************************************************************************
  281. //  104 
  283.         RSEG CODE:CODE:NOROOT(1)
  284. //  105 void PROGRAM_ONE_PAGE(unsigned char ucFlashWriteData)
  285. PROGRAM_ONE_PAGE:
  286.         CFI Block cfiBlock2 Using cfiCommon0
  287.         CFI Function PROGRAM_ONE_PAGE
  288. //  106 {
  289.         FUNCALL PROGRAM_ONE_PAGE, COMMAND_LATCH_INTO
  290.         LOCFRAME CSTACK, 8, STACK
  291.         FUNCALL PROGRAM_ONE_PAGE, ADDRESS_LATCH_INTO
  292.         LOCFRAME CSTACK, 8, STACK
  293.         FUNCALL PROGRAM_ONE_PAGE, ADDRESS_LATCH_INTO
  294.         LOCFRAME CSTACK, 8, STACK
  295.         FUNCALL PROGRAM_ONE_PAGE, ADDRESS_LATCH_INTO
  296.         LOCFRAME CSTACK, 8, STACK
  297.         FUNCALL PROGRAM_ONE_PAGE, ADDRESS_LATCH_INTO
  298.         LOCFRAME CSTACK, 8, STACK
  299.         FUNCALL PROGRAM_ONE_PAGE, COMMAND_LATCH_INTO
  300.         LOCFRAME CSTACK, 8, STACK
  301.         FUNCALL PROGRAM_ONE_PAGE, READ_STATUS
  302.         LOCFRAME CSTACK, 8, STACK
  303. PUSH.W R10
  304.         CFI R10 Frame(CFA, -4)
  305.         CFI CFA SP+4
  306. PUSH.W R11
  307.         CFI R11 Frame(CFA, -6)
  308.         CFI CFA SP+6
  309. PUSH.W R8
  310.         CFI R8 Frame(CFA, -8)
  311.         CFI CFA SP+8
  312. MOV.B R12, R10
  313. //  107     unsigned int wByteCount;
  314. //  108     unsigned char ucFlashSttsOverflowCnt=0;
  315. MOV.B #0x0, R8
  316. //  109 //COMMAND
  317. //  110  COMMAND_VAL=cFlashWriteCmd;
  318. MOV.B #0x80, &COMMAND_VAL
  319. //  111  COMMAND_LATCH_INTO();
  320. CALL #COMMAND_LATCH_INTO
  321. //  112 
  322. //  113 //ADDRESS
  323. //  114  ADDRESS_VALUE=0;//COLUMN_ADDRESS_LOW; //#0X00
  324. MOV.B #0x0, &ADDRESS_VALUE
  325. //  115  ADDRESS_LATCH_INTO();
  326. CALL #ADDRESS_LATCH_INTO
  327. //  116 
  328. //  117  ADDRESS_VALUE=0;//COLUMN_ADDRESS_HIGH; //#0X00
  329. MOV.B #0x0, &ADDRESS_VALUE
  330. //  118  ADDRESS_LATCH_INTO();
  331. CALL #ADDRESS_LATCH_INTO
  332. //  119 
  333. //  120  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  334. MOV.B &ROW_ADDRESS_LOW, &ADDRESS_VALUE
  335. //  121  ADDRESS_LATCH_INTO();
  336. CALL #ADDRESS_LATCH_INTO
  337. //  122 
  338. //  123  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  339. MOV.B &ROW_ADDRESS_HIGH, &ADDRESS_VALUE
  340. //  124  ADDRESS_LATCH_INTO();
  341. CALL #ADDRESS_LATCH_INTO
  342. //  125 
  343. //  126  FLASH_CON_PORT_OUT &=~ ALE;
  344. BIC.B #0x2, &0x29
  345. //  127  //CALL DELAY_100US
  346. //  128  //for(wGeneralCnt=0;wGeneralCnt<0xff;wGeneralCnt++); //delay
  347. //  129 
  348. //  130  DATA_PORT_OUT_INITIAL;
  349. MOV.B #0xff, &0x32
  350. //  131  for(wByteCount=0;wByteCount<2112;wByteCount++)
  351. MOV.W #0x0, R11
  352. ??PROGRAM_ONE_PAGE_0:
  353. CMP.W #0x840, R11
  354. JC ??PROGRAM_ONE_PAGE_1
  355. //  132  {
  356. //  133  //FLASH_WRITE_DATA=0x55;
  357. //  134  //WRITE_ONE_DATA();
  358. //  135  FLASH_CON_PORT_OUT&=~WE;
  359. BIC.B #0x1, &0x29
  360. //  136    DATA_PORT_OUT=ucFlashWriteData;
  361. MOV.B R10, &0x31
  362. //  137    FLASH_CON_PORT_OUT |= WE;
  363. BIS.B #0x1, &0x29
  364. //  138  }
  365. ADD.W #0x1, R11
  366. JMP ??PROGRAM_ONE_PAGE_0
  367. //  139 
  368. //  140  COMMAND_VAL=cFlashWriteInitiateCmd; //10H INITIATES PROGRAM
  369. ??PROGRAM_ONE_PAGE_1:
  370. MOV.B #0x10, &COMMAND_VAL
  371. //  141  COMMAND_LATCH_INTO();
  372. CALL #COMMAND_LATCH_INTO
  373. //  142 
  374. //  143  READ_STATUS();
  375. CALL #READ_STATUS
  376. //  144  ucFlashSttsOverflowCnt=0;
  377. MOV.B #0x0, R8
  378. //  145  if(FLASH_STATUS==1&&(ucFlashSttsOverflowCnt++)<2)
  379. CMP.B #0x1, &FLASH_STATUS
  380. JNE ??PROGRAM_ONE_PAGE_2
  381. ADD.B #0x1, R8
  382. //  146  {
  383. //  147  ;// Dec. 02,2006
  384. //  148  //ERASE_ONE_BLOCK();
  385. //  149  //PROGRAM_ONE_PAGE();
  386. //  150  }
  387. //  151 }
  388. ??PROGRAM_ONE_PAGE_2:
  389. POP.W R8
  390.         CFI R8 SameValue
  391.         CFI CFA SP+6
  392. POP.W R11
  393.         CFI R11 SameValue
  394.         CFI CFA SP+4
  395. POP.W R10
  396.         CFI R10 SameValue
  397.         CFI CFA SP+2
  398. RET
  399.         CFI EndBlock cfiBlock2
  400. //  152 
  401. //  153 //***********************************************************************************
  402. //  154 //***********************************************************************************
  404.         RSEG CODE:CODE:NOROOT(1)
  405. //  155 void PROGRAM_256_BYTE(void)
  406. PROGRAM_256_BYTE:
  407.         CFI Block cfiBlock3 Using cfiCommon0
  408.         CFI Function PROGRAM_256_BYTE
  409. //  156 {
  410.         FUNCALL PROGRAM_256_BYTE, COMMAND_LATCH_INTO
  411.         LOCFRAME CSTACK, 8, STACK
  412.         FUNCALL PROGRAM_256_BYTE, ADDRESS_LATCH_INTO
  413.         LOCFRAME CSTACK, 8, STACK
  414.         FUNCALL PROGRAM_256_BYTE, ADDRESS_LATCH_INTO
  415.         LOCFRAME CSTACK, 8, STACK
  416.         FUNCALL PROGRAM_256_BYTE, ADDRESS_LATCH_INTO
  417.         LOCFRAME CSTACK, 8, STACK
  418.         FUNCALL PROGRAM_256_BYTE, ADDRESS_LATCH_INTO
  419.         LOCFRAME CSTACK, 8, STACK
  420.         FUNCALL PROGRAM_256_BYTE, COMMAND_LATCH_INTO
  421.         LOCFRAME CSTACK, 8, STACK
  422.         FUNCALL PROGRAM_256_BYTE, READ_STATUS
  423.         LOCFRAME CSTACK, 8, STACK
  424. PUSH.W R10
  425.         CFI R10 Frame(CFA, -4)
  426.         CFI CFA SP+4
  427. PUSH.W R11
  428.         CFI R11 Frame(CFA, -6)
  429.         CFI CFA SP+6
  430. PUSH.W R8
  431.         CFI R8 Frame(CFA, -8)
  432.         CFI CFA SP+8
  433. //  157     unsigned int wGeneralCnt=0;
  434. MOV.W #0x0, R10
  435. //  158     unsigned char ucFlashSttsOverflowCnt=0,ucRxIndex=0;
  436. MOV.B #0x0, R11
  437. MOV.B #0x0, R8
  438. //  159 //COMMAND
  439. //  160  COMMAND_VAL=0X80;
  440. MOV.B #0x80, &COMMAND_VAL
  441. //  161  COMMAND_LATCH_INTO();
  442. CALL #COMMAND_LATCH_INTO
  443. //  162 
  444. //  163 //ADDRESS
  445. //  164  ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  446. MOV.B &COLUMN_ADDRESS_LOW, &ADDRESS_VALUE
  447. //  165  ADDRESS_LATCH_INTO();
  448. CALL #ADDRESS_LATCH_INTO
  449. //  166 
  450. //  167  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  451. MOV.B &COLUMN_ADDRESS_HIGH, &ADDRESS_VALUE
  452. //  168  ADDRESS_LATCH_INTO();
  453. CALL #ADDRESS_LATCH_INTO
  454. //  169 
  455. //  170  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  456. MOV.B &ROW_ADDRESS_LOW, &ADDRESS_VALUE
  457. //  171  ADDRESS_LATCH_INTO();
  458. CALL #ADDRESS_LATCH_INTO
  459. //  172 
  460. //  173  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  461. MOV.B &ROW_ADDRESS_HIGH, &ADDRESS_VALUE
  462. //  174  ADDRESS_LATCH_INTO();
  463. CALL #ADDRESS_LATCH_INTO
  464. //  175 
  465. //  176  FLASH_CON_PORT_OUT &=~ ALE;
  466. BIC.B #0x2, &0x29
  467. //  177  //CALL DELAY_100US
  468. //  178  for(wGeneralCnt=0;wGeneralCnt<0xff;wGeneralCnt++);
  469. MOV.W #0x0, R10
  470. ??PROGRAM_256_BYTE_0:
  471. CMP.W #0xff, R10
  472. JC ??PROGRAM_256_BYTE_2
  473. ADD.W #0x1, R10
  474. JMP ??PROGRAM_256_BYTE_0
  475. //  179  DATA_PORT_OUT_INITIAL;
  476. ??PROGRAM_256_BYTE_2:
  477. MOV.B #0xff, &0x32
  478. //  180  for(ucRxIndex=0;ucRxIndex<255;ucRxIndex++)
  479. MOV.B #0x0, R8
  480. ??PROGRAM_256_BYTE_1:
  481. CMP.B #0xff, R8
  482. JC ??PROGRAM_256_BYTE_3
  483. //  181  {
  484. //  182  FLASH_CON_PORT_OUT&=~WE;
  485. BIC.B #0x1, &0x29
  486. //  183    DATA_PORT_OUT=aucUartRxBuf[ucRxIndex];
  487. MOV.B R8, R14
  488. AND.W #0xff, R14
  489. MOV.B aucUartRxBuf(R14), &0x31
  490. //  184    FLASH_CON_PORT_OUT |= WE; //LATCH INTO ONE DATA
  491. BIS.B #0x1, &0x29
  492. //  185  }
  493. ADD.B #0x1, R8
  494. JMP ??PROGRAM_256_BYTE_1
  495. //  186 
  496. //  187  COMMAND_VAL=0X10; //10H INITIATES PROGRAM
  497. ??PROGRAM_256_BYTE_3:
  498. MOV.B #0x10, &COMMAND_VAL
  499. //  188  COMMAND_LATCH_INTO();
  500. CALL #COMMAND_LATCH_INTO
  501. //  189 
  502. //  190  READ_STATUS();
  503. CALL #READ_STATUS
  504. //  191  ucFlashSttsOverflowCnt=0;
  505. MOV.B #0x0, R11
  506. //  192  if(FLASH_STATUS==1&&(ucFlashSttsOverflowCnt++)<2)
  507. CMP.B #0x1, &FLASH_STATUS
  508. JNE ??PROGRAM_256_BYTE_4
  509. ADD.B #0x1, R11
  510. //  193  {
  511. //  194  ;// Dec. 02,2006
  512. //  195  //ERASE_ONE_BLOCK();
  513. //  196  //PROGRAM_ONE_PAGE();
  514. //  197  }
  515. //  198 }
  516. ??PROGRAM_256_BYTE_4:
  517. POP.W R8
  518.         CFI R8 SameValue
  519.         CFI CFA SP+6
  520. POP.W R11
  521.         CFI R11 SameValue
  522.         CFI CFA SP+4
  523. POP.W R10
  524.         CFI R10 SameValue
  525.         CFI CFA SP+2
  526. RET
  527.         CFI EndBlock cfiBlock3
  528. //  199 //***********************************************************************************
  530.         RSEG CODE:CODE:NOROOT(1)
  531. //  200 void READ_256_BYTE(void)
  532. READ_256_BYTE:
  533.         CFI Block cfiBlock4 Using cfiCommon0
  534.         CFI Function READ_256_BYTE
  535. //  201 {
  536.         FUNCALL READ_256_BYTE, Flash_Reset
  537.         LOCFRAME CSTACK, 6, STACK
  538.         FUNCALL READ_256_BYTE, COMMAND_LATCH_INTO
  539.         LOCFRAME CSTACK, 6, STACK
  540.         FUNCALL READ_256_BYTE, ADDRESS_LATCH_INTO
  541.         LOCFRAME CSTACK, 6, STACK
  542.         FUNCALL READ_256_BYTE, ADDRESS_LATCH_INTO
  543.         LOCFRAME CSTACK, 6, STACK
  544.         FUNCALL READ_256_BYTE, ADDRESS_LATCH_INTO
  545.         LOCFRAME CSTACK, 6, STACK
  546.         FUNCALL READ_256_BYTE, ADDRESS_LATCH_INTO
  547.         LOCFRAME CSTACK, 6, STACK
  548.         FUNCALL READ_256_BYTE, COMMAND_LATCH_INTO
  549.         LOCFRAME CSTACK, 6, STACK
  550.         FUNCALL READ_256_BYTE, ATcmdDelay
  551.         LOCFRAME CSTACK, 6, STACK
  552. PUSH.W R10
  553.         CFI R10 Frame(CFA, -4)
  554.         CFI CFA SP+4
  555. PUSH.W R11
  556.         CFI R11 Frame(CFA, -6)
  557.         CFI CFA SP+6
  558. //  202                 int wByteCnt=0;
  559. MOV.W #0x0, R10
  560. //  203  unsigned char ucRxCnt=0;
  561. MOV.B #0x0, R11
  562. //  204 //COMMAND
  563. //  205  Flash_Reset();
  564. CALL #Flash_Reset
  565. //  206  COMMAND_VAL=0x00; //#0X00 //00H READ1 0-527BYTE
  566. MOV.B #0x0, &COMMAND_VAL
  567. //  207  COMMAND_LATCH_INTO();
  568. CALL #COMMAND_LATCH_INTO
  569. //  208 //ADDRESS
  570. //  209  ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  571. MOV.B &COLUMN_ADDRESS_LOW, &ADDRESS_VALUE
  572. //  210  ADDRESS_LATCH_INTO();
  573. CALL #ADDRESS_LATCH_INTO
  574. //  211 
  575. //  212  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  576. MOV.B &COLUMN_ADDRESS_HIGH, &ADDRESS_VALUE
  577. //  213  ADDRESS_LATCH_INTO();
  578. CALL #ADDRESS_LATCH_INTO
  579. //  214 
  580. //  215  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  581. MOV.B &ROW_ADDRESS_LOW, &ADDRESS_VALUE
  582. //  216  ADDRESS_LATCH_INTO();
  583. CALL #ADDRESS_LATCH_INTO
  584. //  217 
  585. //  218  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  586. MOV.B &ROW_ADDRESS_HIGH, &ADDRESS_VALUE
  587. //  219  ADDRESS_LATCH_INTO();
  588. CALL #ADDRESS_LATCH_INTO
  589. //  220  FLASH_CON_PORT_OUT &=~ ALE;
  590. BIC.B #0x2, &0x29
  591. //  221 
  592. //  222  COMMAND_VAL=0X30;
  593. MOV.B #0x30, &COMMAND_VAL
  594. //  223  COMMAND_LATCH_INTO();
  595. CALL #COMMAND_LATCH_INTO
  596. //  224  ATcmdDelay();
  597. CALL #ATcmdDelay
  598. //  225  while((FLASH_CON_PORT_IN & RB)==0);
  599. ??READ_256_BYTE_0:
  600. BIT.B #0x20, &0x28
  601. JNC ??READ_256_BYTE_0
  602. //  226 
  603. //  227  DATA_PORT_IN_INITIAL;
  604. MOV.B #0x0, &0x32
  605. //  228  for(wByteCnt=0,ucRxCnt=0;wByteCnt<256;wByteCnt++)
  606. MOV.W #0x0, R10
  607. MOV.B #0x0, R11
  608. ??READ_256_BYTE_1:
  609. CMP.W #0x100, R10
  610. JGE ??READ_256_BYTE_2
  611. //  229  {
  612. //  230              FLASH_CON_PORT_OUT &=~ RE; //RE IS LOW,ENABLE READ DATA
  613. BIC.B #0x10, &0x29
  614. //  231      aucUartRxBuf[ucRxCnt++]=DATA_PORT_IN;
  615. MOV.B R11, R14
  616. AND.W #0xff, R14
  617. MOV.B &0x30, aucUartRxBuf(R14)
  618. ADD.B #0x1, R11
  619. //  232      FLASH_CON_PORT_OUT |= RE;
  620. BIS.B #0x10, &0x29
  621. //  233  }
  622. ADD.W #0x1, R10
  623. JMP ??READ_256_BYTE_1
  624. //  234 
  625. //  235 }
  626. ??READ_256_BYTE_2:
  627. POP.W R11
  628.         CFI R11 SameValue
  629.         CFI CFA SP+4
  630. POP.W R10
  631.         CFI R10 SameValue
  632.         CFI CFA SP+2
  633. RET
  634.         CFI EndBlock cfiBlock4
  635. //  236 //***********************************************************************************
  636. //  237 
  637. //  238 /***********************************************************************************
  638. //  239 void READ_ONE_PAGE(void)
  639. //  240 {
  640. //  241                 int wByteCnt=0;
  641. //  242  unsigned char ucRxCnt=0;
  642. //  243 //COMMAND
  643. //  244  COMMAND_VAL=0x00; //#0X00 //00H READ1 0-527BYTE
  644. //  245  COMMAND_LATCH_INTO();
  645. //  246 //ADDRESS
  646. //  247  ADDRESS_VALUE=COLUMN_ADDRESS_LOW; //#0X00
  647. //  248  ADDRESS_LATCH_INTO();
  648. //  249 
  649. //  250  ADDRESS_VALUE=COLUMN_ADDRESS_HIGH; //#0X00
  650. //  251  ADDRESS_LATCH_INTO();
  651. //  252 
  652. //  253  ADDRESS_VALUE=ROW_ADDRESS_LOW; //#0X00
  653. //  254  ADDRESS_LATCH_INTO();
  654. //  255 
  655. //  256  ADDRESS_VALUE=ROW_ADDRESS_HIGH; //#0X00
  656. //  257  ADDRESS_LATCH_INTO();
  657. //  258  FLASH_CON_PORT_OUT &=~ ALE;
  658. //  259 
  659. //  260  COMMAND_VAL=0X30;
  660. //  261  COMMAND_LATCH_INTO();
  661. //  262  ATcmdDelay();
  662. //  263  while((FLASH_CON_PORT_IN & RB)==0);
  663. //  264  for(wByteCnt=0,ucRxCnt=0;wByteCnt<2048;wByteCnt++)
  664. //  265  {
  665. //  266              READ_ONE_DATA();
  666. //  267              aucUartRxBuf[ucRxCnt++]=FLASH_READ_DATA;
  667. //  268  }
  668. //  269 }
  669. //  270 ***********************************************************************************/
  670. //  271 
  671. //  272 //***********************************************************************************
  673.         RSEG CODE:CODE:NOROOT(1)
  674. //  273 void READ_STATUS(void)
  675. READ_STATUS:
  676. ??READ_STATUS_0:
  677.         CFI Block cfiBlock5 Using cfiCommon0
  678.         CFI Function READ_STATUS
  679. //  274 {
  680. //  275  //CALL DELAY_50US
  681. //  276  while((FLASH_CON_PORT_IN & RB)==0); //FLASH_CON_PORT,RB,$ //CHECK BUSY
  682.         FUNCALL READ_STATUS, COMMAND_LATCH_INTO
  683.         LOCFRAME CSTACK, 2, STACK
  684.         FUNCALL READ_STATUS, READ_ONE_DATA
  685.         LOCFRAME CSTACK, 2, STACK
  686. BIT.B #0x20, &0x28
  687. JNC ??READ_STATUS_0
  688. //  277 
  689. //  278  COMMAND_VAL=0X70;
  690. MOV.B #0x70, &COMMAND_VAL
  691. //  279 
  692. //  280  COMMAND_LATCH_INTO();
  693. CALL #COMMAND_LATCH_INTO
  694. //  281 
  695. //  282  DATA_PORT_IN_INITIAL;
  696. MOV.B #0x0, &0x32
  697. //  283  READ_ONE_DATA(); //WHEN READY,READ STATUS
  698. CALL #READ_ONE_DATA
  699. //  284  FLASH_STATUS=FLASH_READ_DATA & 0x01; //0 OK 1 error
  700. MOV.B &FLASH_READ_DATA, R14
  701. AND.B #0x1, R14
  702. MOV.B R14, &FLASH_STATUS
  703. //  285  //if((READ_DATA_VALUE&0x01)==0)
  704. //  286  // FLASH_STATUS=0; //0 OK 1 error
  705. //  287 }
  706. RET
  707.         CFI EndBlock cfiBlock5
  708. //  288 
  709. //  289 //***********************************************************************************/
  710. //  290 
  712.         RSEG CODE:CODE:NOROOT(1)
  713. //  291 void FLASH_READ_ID(void)
  714. FLASH_READ_ID:
  715.         CFI Block cfiBlock6 Using cfiCommon0
  716.         CFI Function FLASH_READ_ID
  717. //  292 {
  718. //  293  COMMAND_VAL=0X90;
  719.         FUNCALL FLASH_READ_ID, COMMAND_LATCH_INTO
  720.         LOCFRAME CSTACK, 2, STACK
  721.         FUNCALL FLASH_READ_ID, ADDRESS_LATCH_INTO
  722.         LOCFRAME CSTACK, 2, STACK
  723.         FUNCALL FLASH_READ_ID, READ_ONE_DATA
  724.         LOCFRAME CSTACK, 2, STACK
  725.         FUNCALL FLASH_READ_ID, READ_ONE_DATA
  726.         LOCFRAME CSTACK, 2, STACK
  727.         FUNCALL FLASH_READ_ID, READ_ONE_DATA
  728.         LOCFRAME CSTACK, 2, STACK
  729.         FUNCALL FLASH_READ_ID, READ_ONE_DATA
  730.         LOCFRAME CSTACK, 2, STACK
  731. MOV.B #0x90, &COMMAND_VAL
  732. //  294  COMMAND_LATCH_INTO();
  733. CALL #COMMAND_LATCH_INTO
  734. //  295 
  735. //  296  ADDRESS_VALUE=0X00;
  736. MOV.B #0x0, &ADDRESS_VALUE
  737. //  297  ADDRESS_LATCH_INTO();
  738. CALL #ADDRESS_LATCH_INTO
  739. //  298  FLASH_CON_PORT_OUT &=~ ALE;
  740. BIC.B #0x2, &0x29
  741. //  299 
  742. //  300  DATA_PORT_IN_INITIAL;
  743. MOV.B #0x0, &0x32
  744. //  301  READ_ONE_DATA();
  745. CALL #READ_ONE_DATA
  746. //  302  while (!(FLASH_READ_DATA==0xad));
  747. ??FLASH_READ_ID_0:
  748. CMP.B #0xad, &FLASH_READ_DATA
  749. JNE ??FLASH_READ_ID_0
  750. //  303 
  751. //  304  READ_ONE_DATA();
  752. CALL #READ_ONE_DATA
  753. //  305  while (!(FLASH_READ_DATA==0xf1));
  754. ??FLASH_READ_ID_1:
  755. CMP.B #0xf1, &FLASH_READ_DATA
  756. JNE ??FLASH_READ_ID_1
  757. //  306  READ_ONE_DATA();
  758. CALL #READ_ONE_DATA
  759. //  307  READ_ONE_DATA();
  760. BR #READ_ONE_DATA
  761.         CFI EndBlock cfiBlock6
  762. //  308 }
  763. //  309 //***********************************************************************************
  764. //  310 
  766.         RSEG CODE:CODE:NOROOT(1)
  767. //  311 void Flash_Reset(void) //flash reset
  768. Flash_Reset:
  769.         CFI Block cfiBlock7 Using cfiCommon0
  770.         CFI Function Flash_Reset
  771. //  312 { 
  772.         FUNCALL Flash_Reset, COMMAND_LATCH_INTO
  773.         LOCFRAME CSTACK, 4, STACK
  774. PUSH.W R10
  775.         CFI R10 Frame(CFA, -4)
  776.         CFI CFA SP+4
  777. //  313  int i;
  778. //  314  COMMAND_VAL=0XFF; //reset command
  779. MOV.B #0xff, &COMMAND_VAL
  780. //  315  COMMAND_LATCH_INTO();
  781. CALL #COMMAND_LATCH_INTO
  782. //  316  for (i=0;i<3000;i++); //delay 
  783. MOV.W #0x0, R10
  784. ??Flash_Reset_0:
  785. CMP.W #0xbb8, R10
  786. JGE ??Flash_Reset_1
  787. ADD.W #0x1, R10
  788. JMP ??Flash_Reset_0
  789. //  317 }
  790. ??Flash_Reset_1:
  791. POP.W R10
  792.         CFI R10 SameValue
  793.         CFI CFA SP+2
  794. RET
  795.         CFI EndBlock cfiBlock7
  796. //  318 
  797. //  319 //***********************************************************************************
  799.         RSEG CODE:CODE:SORT:NOROOT(1)
  800. //  320 void COMMAND_LATCH_INTO(void) //FLASH CONTROL PORT
  801. COMMAND_LATCH_INTO:
  802.         CFI Block cfiBlock8 Using cfiCommon0
  803.         CFI Function COMMAND_LATCH_INTO
  804. //  321 {
  805. //  322 
  806. //  323  FLASH_CON_PORT_OUT |= CLE; //COMMAND LATCH ENABLE
  807. BIS.B #0x4, &0x29
  808. //  324  FLASH_CON_PORT_OUT &= ~(CE|WE); //CHIP ENABLE WRITE ENABLE
  809. AND.B #0xf6, &0x29
  810. //  325 
  811. //  326  DATA_PORT_OUT_INITIAL; //MCU OUTPUT,FLASH READ COMMAND
  812. MOV.B #0xff, &0x32
  813. //  327 
  814. //  328  DATA_PORT_OUT=COMMAND_VAL; //DATA SETUP
  815. MOV.B &COMMAND_VAL, &0x31
  816. //  329 
  817. //  330  FLASH_CON_PORT_OUT |= WE; //LATCH INTO THE COMMAND
  818. BIS.B #0x1, &0x29
  819. //  331                 FLASH_CON_PORT_OUT&= ~CLE;
  820. BIC.B #0x4, &0x29
  821. //  332 }
  822. RET
  823.         CFI EndBlock cfiBlock8
  824. //  333 //********************************************************
  825. //  334 
  827.         RSEG CODE:CODE:SORT:NOROOT(1)
  828. //  335 void ADDRESS_LATCH_INTO(void)
  829. ADDRESS_LATCH_INTO:
  830.         CFI Block cfiBlock9 Using cfiCommon0
  831.         CFI Function ADDRESS_LATCH_INTO
  832. //  336 {
  833. //  337  FLASH_CON_PORT_OUT |= ALE;
  834. BIS.B #0x2, &0x29
  835. //  338  FLASH_CON_PORT_OUT &=~ (CLE|WE);
  836. AND.B #0xfa, &0x29
  837. //  339  DATA_PORT_OUT_INITIAL; //MCU OUTPUT,FLASH READ ADDRESS
  838. MOV.B #0xff, &0x32
  839. //  340  DATA_PORT_OUT=ADDRESS_VALUE;
  840. MOV.B &ADDRESS_VALUE, &0x31
  841. //  341 
  842. //  342  FLASH_CON_PORT_OUT |= WE; //LATCH INTO THE ADDRESS
  843. BIS.B #0x1, &0x29
  844. //  343  //FLASH_CON_PORT_OUT &=~ ALE;
  845. //  344 
  846. //  345 }
  847. RET
  848.         CFI EndBlock cfiBlock9
  849. //  346 /********************************************************
  850. //  347 void WRITE_ONE_DATA(void)
  851. //  348 {
  852. //  349  FLASH_CON_PORT_OUT&=~WE;
  853. //  350  //DATA_PORT_OUT_INITIAL; //MCU OUTPUT,MCU WRITE A DATA TO FLASH
  854. //  351  DATA_PORT_OUT=FLASH_WRITE_DATA;
  855. //  352  FLASH_CON_PORT_OUT |= WE; //LATCH INTO ONE DATA
  856. //  353 
  857. //  354 }
  858. //  355 
  859. //  356 ********************************************************/
  861.         RSEG CODE:CODE:SORT:NOROOT(1)
  862. //  357 void READ_ONE_DATA(void)
  863. READ_ONE_DATA:
  864.         CFI Block cfiBlock10 Using cfiCommon0
  865.         CFI Function READ_ONE_DATA
  866. //  358 {
  867. //  359  FLASH_CON_PORT_OUT &=~ RE; //RE IS LOW,ENABLE READ DATA
  868. BIC.B #0x10, &0x29
  869. //  360 
  870. //  361  //DATA_PORT_IN_INITIAL; //MCU INPUT,MCU READ A DATA
  871. //  362  FLASH_READ_DATA=DATA_PORT_IN;
  872. MOV.B &0x30, &FLASH_READ_DATA
  873. //  363  FLASH_CON_PORT_OUT |= RE;
  874. BIS.B #0x10, &0x29
  875. //  364 }
  876. RET
  877.         CFI EndBlock cfiBlock10
  879.         RSEG CODE:CODE:NOROOT(1)
  880. ?setjmp_save_r4:
  881. REQUIRE ?setjmp_r4
  882. REQUIRE ?longjmp_r4
  884.         RSEG CODE:CODE:NOROOT(1)
  885. ?setjmp_save_r5:
  886. REQUIRE ?setjmp_r5
  887. REQUIRE ?longjmp_r5
  889.         END
  890. // 
  891. // 692 bytes in segment CODE
  892. //   5 bytes in segment DATA16_AN
  893. // 
  894. // 692 bytes of CODE memory
  895. //   0 bytes of DATA memory (+ 5 bytes shared)
  896. //
  897. //Errors: none
  898. //Warnings: none