git.sur5r.net Git - freertos/blob - Demo/HCS12_CodeWarrior_small/Sources/datapage.c

   1 /******************************************************************************\r
   2   FILE        : datapage.c\r
   3   PURPOSE     : paged data access runtime routines\r
   4   MACHINE     : Motorola 68HC12 (Target)\r
   5   LANGUAGE    : ANSI-C\r
   6   HISTORY     : 21.7.96 first version created\r
   7 ******************************************************************************/\r
   8 \r
   9 /*\r
  10    According to the -Cp option of the compiler the\r
  11    __DPAGE__, __PPAGE__ and __EPAGE__ macros are defined.\r
  12    If none of them is given as argument, then no page accesses should occur and\r
  13    this runtime routine should not be used !\r
  14    To be on the save side, the runtime routines are created anyway.\r
  15    If some of the -Cp options are given an adapted versions which only covers the\r
  16    needed cases is produced.\r
  17 */\r
  18 \r
  19 /* if no compiler option -Cp is given, it is assumed that all possible are given : */\r
  20 \r
  21 /* Compile with option -DHCS12 to activate this code */\r
  22 #if defined(HCS12) || defined(_HCS12) /* HCS12 family has PPAGE register only at 0x30 */\r
  23 #define PPAGE_ADDR (0x30+REGISTER_BASE)\r
  24 #ifndef __PPAGE__ /* may be set already by option -CPPPAGE */\r
  25 #define __PPAGE__\r
  26 #endif\r
  27 /* Compile with option -DDG128 to activate this code */\r
  28 #elif defined DG128 /* HC912DG128 derivative has PPAGE register only at 0xFF */\r
  29 #define PPAGE_ADDR (0xFF+REGISTER_BASE)\r
  30 #ifndef __PPAGE__ /* may be set already by option -CPPPAGE */\r
  31 #define __PPAGE__\r
  32 #endif\r
  33 #elif defined(HC812A4)\r
  34 /* all setting default to A4 already */\r
  35 #endif\r
  36 \r
  37 \r
  38 #if !defined(__EPAGE__) && !defined(__PPAGE__) && !defined(__DPAGE__)\r
  39 /* as default use all page registers */\r
  40 #define __DPAGE__\r
  41 #define __EPAGE__\r
  42 #define __PPAGE__\r
  43 #endif\r
  44 \r
  45 /* modify the following defines to your memory configuration */\r
  46 \r
  47 #define EPAGE_LOW_BOUND   0x400u\r
  48 #define EPAGE_HIGH_BOUND  0x7ffu\r
  49 \r
  50 #define DPAGE_LOW_BOUND   0x7000u\r
  51 #define DPAGE_HIGH_BOUND  0x7fffu\r
  52 \r
  53 #define PPAGE_LOW_BOUND   (DPAGE_HIGH_BOUND+1)\r
  54 #define PPAGE_HIGH_BOUND  0xBFFFu\r
  55 \r
  56 #define REGISTER_BASE      0x0u\r
  57 #ifndef DPAGE_ADDR\r
  58 #define DPAGE_ADDR        (0x34u+REGISTER_BASE)\r
  59 #endif\r
  60 #ifndef EPAGE_ADDR\r
  61 #define EPAGE_ADDR        (0x36u+REGISTER_BASE)\r
  62 #endif\r
  63 #ifndef PPAGE_ADDR\r
  64 #define PPAGE_ADDR        (0x35u+REGISTER_BASE)\r
  65 #endif\r
  66 \r
  67 /*\r
  68   The following parts about the defines are assumed in the code of _GET_PAGE_REG :\r
  69   - the memory region controlled by DPAGE is above the area controlled by the EPAGE and\r
  70     below the area controlled by the PPAGE.\r
  71   - the lower bound of the PPAGE area is equal to be the higher bound of the DPAGE area + 1\r
  72 */\r
  73 #if EPAGE_LOW_BOUND >= EPAGE_HIGH_BOUND || EPAGE_HIGH_BOUND >= DPAGE_LOW_BOUND || DPAGE_LOW_BOUND >= DPAGE_HIGH_BOUND || DPAGE_HIGH_BOUND >= PPAGE_LOW_BOUND || PPAGE_LOW_BOUND >= PPAGE_HIGH_BOUND\r
  74 #error /* please adapt _GET_PAGE_REG for this non default page configuration */\r
  75 #endif\r
  76 \r
  77 #if DPAGE_HIGH_BOUND+1 != PPAGE_LOW_BOUND\r
  78 #error /* please adapt _GET_PAGE_REG for this non default page configuration */\r
  79 #endif\r
  80 \r
  81 #include "hidef.h"\r
  82 #include "non_bank.sgm"\r
  83 #include "runtime.sgm"\r
  84 \r
  85 /* this module does either control if any access is in the bounds of the specified page or */\r
  86 /* ,if only one page is specified, just use this page. */\r
  87 /* This behavior is controlled by the define USE_SEVERAL_PAGES. */\r
  88 /* If !USE_SEVERAL_PAGES does increase the performance significantly */\r
  89 /* NOTE : When !USE_SEVERAL_PAGES, the page is also set for accesses outside of the area controlled */\r
  90 /*        by this single page. But this is usually no problem because the page is set again before any other access */\r
  91 \r
  92 #if !defined(__DPAGE__) && !defined(__EPAGE__) && !defined(__PPAGE__)\r
  93 /* no page at all is specified */\r
  94 /* only specifing the right pages will speed up these functions a lot */\r
  95 #define USE_SEVERAL_PAGES 1\r
  96 #elif defined(__DPAGE__) && defined(__EPAGE__) || defined(__DPAGE__) && defined(__PPAGE__) || defined(__EPAGE__) && defined(__PPAGE__)\r
  97 /* more than one page register is used */\r
  98 #define USE_SEVERAL_PAGES 1\r
  99 #else\r
 100 \r
 101 #define USE_SEVERAL_PAGES 0\r
 102 \r
 103 #if defined(__DPAGE__) /* check which pages are used  */\r
 104 #define PAGE_ADDR PPAGE_ADDR\r
 105 #elif defined(__EPAGE__)\r
 106 #define PAGE_ADDR EPAGE_ADDR\r
 107 #elif defined(__PPAGE__)\r
 108 #define PAGE_ADDR PPAGE_ADDR\r
 109 #else /* we dont know which page, decide it at runtime */\r
 110 #error /* must not happen */\r
 111 #endif\r
 112 \r
 113 #endif\r
 114 \r
 115 \r
 116 #if USE_SEVERAL_PAGES /* only needed for several pages support */\r
 117 /*--------------------------- _GET_PAGE_REG --------------------------------\r
 118   Runtime routine to detect the right register depending on the 16 bit offset part\r
 119   of an address.\r
 120   This function is only used by the functions below.\r
 121 \r
 122   Depending on the compiler options -Cp different versions of _GET_PAGE_REG are produced.\r
 123 \r
 124   Arguments :\r
 125   - Y : offset part of an address\r
 126 \r
 127   Result :\r
 128   if address Y is controlled by a page register :\r
 129   - X : address of page register if Y is controlled by an page register\r
 130   - Zero flag cleared\r
 131   - all other registers remain unchanged\r
 132 \r
 133   if address Y is not controlled by a page register :\r
 134   - Zero flag is set\r
 135   - all registers remain unchanged\r
 136 \r
 137   --------------------------- _GET_PAGE_REG ----------------------------------*/\r
 138 \r
 139 #if defined(__DPAGE__)\r
 140 \r
 141 #ifdef __cplusplus\r
 142 extern "C"\r
 143 #endif\r
 144 #pragma NO_ENTRY\r
 145 #pragma NO_EXIT\r
 146 #pragma NO_FRAME\r
 147 \r
 148 static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */\r
 149   asm {\r
 150 L_DPAGE:\r
 151         CPY  #DPAGE_LOW_BOUND     ; test of lower bound of DPAGE\r
 152 #if defined(__EPAGE__)\r
 153         BLO  L_EPAGE              ; EPAGE accesses are possible\r
 154 #else\r
 155         BLO  L_NOPAGE             ; no paged memory below accesses\r
 156 #endif\r
 157         CPY  #DPAGE_HIGH_BOUND    ; test of higher bound DPAGE/lower bound PPAGE\r
 158 #if defined(__PPAGE__)\r
 159         BHI  L_PPAGE              ; EPAGE accesses are possible\r
 160 #else\r
 161         BHI  L_NOPAGE             ; no paged memory above accesses\r
 162 #endif\r
 163 FOUND_DPAGE:\r
 164         LDX  #DPAGE_ADDR          ; load page register address and clear zero flag\r
 165         RTS\r
 166 \r
 167 #if defined(__PPAGE__)\r
 168 L_PPAGE:\r
 169         CPY  #PPAGE_HIGH_BOUND    ; test of higher bound of PPAGE\r
 170         BHI  L_NOPAGE\r
 171 FOUND_PPAGE:\r
 172         LDX  #PPAGE_ADDR          ; load page register address and clear zero flag\r
 173         RTS\r
 174 #endif\r
 175 \r
 176 #if defined(__EPAGE__)\r
 177 L_EPAGE:\r
 178         CPY #EPAGE_LOW_BOUND      ; test of lower bound of EPAGE\r
 179         BLO L_NOPAGE\r
 180         CPY #EPAGE_HIGH_BOUND     ; test of higher bound of EPAGE\r
 181         BHI L_NOPAGE\r
 182 \r
 183 FOUND_EPAGE:\r
 184         LDX #EPAGE_ADDR           ; load page register address and clear zero flag\r
 185         RTS\r
 186 #endif\r
 187 \r
 188 L_NOPAGE:\r
 189         ORCC #0x04                ; sets zero flag\r
 190         RTS\r
 191   }\r
 192 }\r
 193 \r
 194 #else /* !defined(__DPAGE__) */\r
 195 \r
 196 #if defined( __PPAGE__ )\r
 197 \r
 198 #ifdef __cplusplus\r
 199 extern "C"\r
 200 #endif\r
 201 #pragma NO_ENTRY\r
 202 #pragma NO_EXIT\r
 203 #pragma NO_FRAME\r
 204 \r
 205 static void NEAR _GET_PAGE_REG(void) {  /*lint -esym(528, _GET_PAGE_REG) used in asm code */\r
 206   asm {\r
 207 L_PPAGE:\r
 208         CPY  #PPAGE_LOW_BOUND     ; test of lower bound of PPAGE\r
 209 #if defined( __EPAGE__ )\r
 210         BLO  L_EPAGE\r
 211 #else\r
 212         BLO  L_NOPAGE             ; no paged memory below\r
 213 #endif\r
 214         CPY  #PPAGE_HIGH_BOUND    ; test of higher bound PPAGE\r
 215         BHI  L_NOPAGE\r
 216 FOUND_PPAGE:\r
 217         LDX  #PPAGE_ADDR          ; load page register address and clear zero flag\r
 218         RTS\r
 219 #if defined( __EPAGE__ )\r
 220 L_EPAGE:\r
 221         CPY #EPAGE_LOW_BOUND      ; test of lower bound of EPAGE\r
 222         BLO L_NOPAGE\r
 223         CPY #EPAGE_HIGH_BOUND     ; test of higher bound of EPAGE\r
 224         BHI L_NOPAGE\r
 225 FOUND_EPAGE:\r
 226         LDX #EPAGE_ADDR           ; load page register address and clear zero flag\r
 227         RTS\r
 228 #endif\r
 229 \r
 230 L_NOPAGE:                         ; not in any allowed page area\r
 231                                   ; its a far access to a non paged variable\r
 232         ORCC #0x04                ; sets zero flag\r
 233         RTS\r
 234   }\r
 235 }\r
 236 \r
 237 #else /* !defined(__DPAGE__ ) && !defined( __PPAGE__) */\r
 238 #if defined(__EPAGE__)\r
 239 \r
 240 #ifdef __cplusplus\r
 241 extern "C"\r
 242 #endif\r
 243 #pragma NO_ENTRY\r
 244 #pragma NO_EXIT\r
 245 #pragma NO_FRAME\r
 246 \r
 247 static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */\r
 248   asm {\r
 249 L_EPAGE:\r
 250         CPY #EPAGE_LOW_BOUND      ; test of lower bound of EPAGE\r
 251         BLO L_NOPAGE\r
 252         CPY #EPAGE_HIGH_BOUND     ; test of higher bound of EPAGE\r
 253         BHI L_NOPAGE\r
 254 FOUND_EPAGE:\r
 255         LDX #EPAGE_ADDR           ; load page register address and clear zero flag\r
 256         RTS\r
 257 \r
 258 L_NOPAGE:                         ; not in any allowed page area\r
 259                                   ; its a far access to a non paged variable\r
 260         ORCC #0x04                ; sets zero flag\r
 261         RTS\r
 262   }\r
 263 }\r
 264 \r
 265 #endif /*  defined(__EPAGE__) */\r
 266 #endif /*  defined(__PPAGE__) */\r
 267 #endif /*  defined(__DPAGE__) */\r
 268 \r
 269 #endif /* USE_SEVERAL_PAGES */\r
 270 \r
 271 /*--------------------------- _SET_PAGE --------------------------------\r
 272   Runtime routine to set the right page register. This routine is used if the compiler\r
 273   does not know the right page register, i.e. if the option -Cp is used for more than\r
 274   one pageregister or if the runtime option is used for one of the -Cp options.\r
 275 \r
 276   Arguments :\r
 277   - offset part of an address in the Y register\r
 278   - page part of an address in the B register\r
 279 \r
 280   Result :\r
 281   - page part written into the correct page register.\r
 282   - the old page register content is destroyed\r
 283   - all processor registers remains unchanged\r
 284   --------------------------- _SET_PAGE ----------------------------------*/\r
 285 \r
 286 #ifdef __cplusplus\r
 287 extern "C"\r
 288 #endif\r
 289 #pragma NO_ENTRY\r
 290 #pragma NO_EXIT\r
 291 #pragma NO_FRAME\r
 292 \r
 293 void NEAR _SET_PAGE(void) {\r
 294 #if USE_SEVERAL_PAGES\r
 295   asm {\r
 296           PSHX                  ; save X register\r
 297           __PIC_JSR(_GET_PAGE_REG)\r
 298           BEQ    L_NOPAGE\r
 299           STAB   0,X            ; set page register\r
 300 L_NOPAGE:\r
 301           PULX                  ; restore X register\r
 302           RTS\r
 303   }\r
 304 #else /* USE_SEVERAL_PAGES */\r
 305   asm {\r
 306           STAB   PAGE_ADDR      ; set page register\r
 307           RTS\r
 308   }\r
 309 #endif /* USE_SEVERAL_PAGES */\r
 310 }\r
 311 \r
 312 /*--------------------------- _LOAD_FAR_8 --------------------------------\r
 313   This runtime routine is used to access paged memory via a runtime function.\r
 314   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 315 \r
 316   Arguments :\r
 317   - offset part of an address in the Y register\r
 318   - page part of an address in the B register\r
 319 \r
 320   Result :\r
 321   - value to be read in the B register\r
 322   - all other registers remains unchanged\r
 323   - all page register still contain the same value\r
 324   --------------------------- _LOAD_FAR_8 ----------------------------------*/\r
 325 \r
 326 #ifdef __cplusplus\r
 327 extern "C"\r
 328 #endif\r
 329 #pragma NO_ENTRY\r
 330 #pragma NO_EXIT\r
 331 #pragma NO_FRAME\r
 332 \r
 333 void NEAR _LOAD_FAR_8(void) {\r
 334 #if USE_SEVERAL_PAGES\r
 335   asm {\r
 336           PSHX                ; save X register\r
 337           __PIC_JSR(_GET_PAGE_REG)\r
 338           BEQ    L_NOPAGE\r
 339           PSHA                ; save A register\r
 340           LDAA   0,X          ; save page register\r
 341           STAB   0,X          ; set page register\r
 342           LDAB   0,Y          ; actual load, overwrites page\r
 343           STAA   0,X          ; restore page register\r
 344           PULA                ; restore A register\r
 345           PULX                ; restore X register\r
 346           RTS\r
 347 L_NOPAGE:\r
 348           LDAB   0,Y          ; actual load, overwrites page\r
 349           PULX                ; restore X register\r
 350           RTS\r
 351   }\r
 352 #else /* USE_SEVERAL_PAGES */\r
 353   asm {\r
 354           PSHA                ; save A register\r
 355           LDAA   PAGE_ADDR    ; save page register\r
 356           STAB   PAGE_ADDR    ; set page register\r
 357           LDAB   0,Y          ; actual load, overwrites page\r
 358           STAA   PAGE_ADDR    ; restore page register\r
 359           PULA                ; restore A register\r
 360           RTS\r
 361   }\r
 362 #endif /* USE_SEVERAL_PAGES */\r
 363 }\r
 364 \r
 365 /*--------------------------- _LOAD_FAR_16 --------------------------------\r
 366   This runtime routine is used to access paged memory via a runtime function.\r
 367   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 368 \r
 369   Arguments :\r
 370   - offset part of an address in the Y register\r
 371   - page part of an address in the B register\r
 372 \r
 373   Result :\r
 374   - value to be read in the Y register\r
 375   - all other registers remains unchanged\r
 376   - all page register still contain the same value\r
 377   --------------------------- _LOAD_FAR_16 ----------------------------------*/\r
 378 \r
 379 #ifdef __cplusplus\r
 380 extern "C"\r
 381 #endif\r
 382 #pragma NO_ENTRY\r
 383 #pragma NO_EXIT\r
 384 #pragma NO_FRAME\r
 385 \r
 386 void NEAR _LOAD_FAR_16(void) {\r
 387 #if USE_SEVERAL_PAGES\r
 388   asm {\r
 389           PSHX                 ; save X register\r
 390           __PIC_JSR(_GET_PAGE_REG)\r
 391           BEQ   L_NOPAGE\r
 392           PSHA                 ; save A register\r
 393           LDAA  0,X            ; save page register\r
 394           STAB  0,X            ; set page register\r
 395           LDY   0,Y            ; actual load, overwrites address\r
 396           STAA  0,X            ; restore page register\r
 397           PULA                 ; restore A register\r
 398           PULX                 ; restore X register\r
 399           RTS\r
 400 L_NOPAGE:\r
 401           LDY   0,Y              ; actual load, overwrites address\r
 402           PULX                 ; restore X register\r
 403           RTS\r
 404   }\r
 405 #else /* USE_SEVERAL_PAGES */\r
 406   asm {\r
 407           PSHA                ; save A register\r
 408           LDAA   PAGE_ADDR    ; save page register\r
 409           STAB   PAGE_ADDR    ; set page register\r
 410           LDY    0,Y          ; actual load, overwrites address\r
 411           STAA   PAGE_ADDR    ; restore page register\r
 412           PULA                ; restore A register\r
 413           RTS\r
 414   }\r
 415 #endif /* USE_SEVERAL_PAGES */\r
 416 }\r
 417 /*--------------------------- _LOAD_FAR_24 --------------------------------\r
 418   This runtime routine is used to access paged memory via a runtime function.\r
 419   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 420 \r
 421   Arguments :\r
 422   - offset part of an address in the Y register\r
 423   - page part of an address in the B register\r
 424 \r
 425   Result :\r
 426   - value to be read in the Y:B registers\r
 427   - all other registers remains unchanged\r
 428   - all page register still contain the same value\r
 429   --------------------------- _LOAD_FAR_24 ----------------------------------*/\r
 430 \r
 431 #ifdef __cplusplus\r
 432 extern "C"\r
 433 #endif\r
 434 #pragma NO_ENTRY\r
 435 #pragma NO_EXIT\r
 436 #pragma NO_FRAME\r
 437 \r
 438 void NEAR _LOAD_FAR_24(void) {\r
 439 #if USE_SEVERAL_PAGES\r
 440   asm {\r
 441           PSHX                 ; save X register\r
 442           __PIC_JSR(_GET_PAGE_REG)\r
 443           BEQ   L_NOPAGE\r
 444           PSHA                 ; save A register\r
 445           LDAA  0,X            ; save page register\r
 446           STAB  0,X            ; set page register\r
 447           LDAB  0,Y            ; actual load, overwrites page of address\r
 448           LDY   1,Y            ; actual load, overwrites offset of address\r
 449           STAA  0,X            ; restore page register\r
 450           PULA                 ; restore A register\r
 451           PULX                 ; restore X register\r
 452           RTS\r
 453 L_NOPAGE:\r
 454           LDAB  0,Y            ; actual load, overwrites page of address\r
 455           LDY   1,Y            ; actual load, overwrites offset of address\r
 456           PULX                 ; restore X register\r
 457           RTS\r
 458   }\r
 459 #else /* USE_SEVERAL_PAGES */\r
 460   asm {\r
 461           PSHA                 ; save A register\r
 462           LDAA   PAGE_ADDR     ; save page register\r
 463           STAB   PAGE_ADDR     ; set page register\r
 464           LDAB   0,Y           ; actual load, overwrites page of address\r
 465           LDY    1,Y           ; actual load, overwrites offset of address\r
 466           STAA   PAGE_ADDR     ; restore page register\r
 467           PULA                 ; restore A register\r
 468           RTS\r
 469   }\r
 470 #endif /* USE_SEVERAL_PAGES */\r
 471 \r
 472 }\r
 473 \r
 474 /*--------------------------- _LOAD_FAR_32 --------------------------------\r
 475   This runtime routine is used to access paged memory via a runtime function.\r
 476   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 477 \r
 478   Arguments :\r
 479   - offset part of an address in the Y register\r
 480   - page part of an address in the B register\r
 481 \r
 482   Result :\r
 483   - low 16 bit of value to be read in the D registers\r
 484   - high 16 bit of value to be read in the Y registers\r
 485   - all other registers remains unchanged\r
 486   - all page register still contain the same value\r
 487   --------------------------- _LOAD_FAR_32 ----------------------------------*/\r
 488 \r
 489 #ifdef __cplusplus\r
 490 extern "C"\r
 491 #endif\r
 492 #pragma NO_ENTRY\r
 493 #pragma NO_EXIT\r
 494 #pragma NO_FRAME\r
 495 \r
 496 void NEAR _LOAD_FAR_32(void) {\r
 497 #if USE_SEVERAL_PAGES\r
 498   asm {\r
 499           PSHX                 ; save X register\r
 500           __PIC_JSR(_GET_PAGE_REG)\r
 501           BEQ   L_NOPAGE\r
 502           LDAA  0,X            ; save page register\r
 503           PSHA                 ; put it onto the stack\r
 504           STAB  0,X            ; set page register\r
 505           LDD   2,Y            ; actual load, low word\r
 506           LDY   0,Y            ; actual load, high word\r
 507           MOVB  1,SP+,0,X      ; restore page register\r
 508           PULX                 ; restore X register\r
 509           RTS\r
 510 L_NOPAGE:\r
 511           LDD   2,Y            ; actual load, low word\r
 512           LDY   0,Y            ; actual load, high word\r
 513           PULX                 ; restore X register\r
 514           RTS\r
 515   }\r
 516 #else /* USE_SEVERAL_PAGES */\r
 517   asm {\r
 518           LDAA   PAGE_ADDR     ; save page register\r
 519           PSHA                 ; put it onto the stack\r
 520           STAB   PAGE_ADDR     ; set page register\r
 521           LDD   2,Y            ; actual load, low word\r
 522           LDY   0,Y            ; actual load, high word\r
 523           MOVB  1,SP+,PAGE_ADDR; restore page register\r
 524           RTS\r
 525   }\r
 526 #endif /* USE_SEVERAL_PAGES */\r
 527 }\r
 528 \r
 529 /*--------------------------- _STORE_FAR_8 --------------------------------\r
 530   This runtime routine is used to access paged memory via a runtime function.\r
 531   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 532 \r
 533   Arguments :\r
 534   - offset part of an address in the Y register\r
 535   - page part of an address in the B register\r
 536   - value to be stored in the B register\r
 537 \r
 538   Result :\r
 539   - value stored at the address\r
 540   - all registers remains unchanged\r
 541   - all page register still contain the same value\r
 542   --------------------------- _STORE_FAR_8 ----------------------------------*/\r
 543 \r
 544 #ifdef __cplusplus\r
 545 extern "C"\r
 546 #endif\r
 547 #pragma NO_ENTRY\r
 548 #pragma NO_EXIT\r
 549 #pragma NO_FRAME\r
 550 \r
 551 void NEAR _STORE_FAR_8(void) {\r
 552 #if USE_SEVERAL_PAGES\r
 553   asm {\r
 554           PSHX                   ; save X register\r
 555           __PIC_JSR(_GET_PAGE_REG)\r
 556           BEQ   L_NOPAGE\r
 557           PSHB                   ; save B register\r
 558           LDAB  0,X              ; save page register\r
 559           MOVB  0,SP, 0,X        ; set page register\r
 560           STAA  0,Y              ; store the value passed in A\r
 561           STAB  0,X              ; restore page register\r
 562           PULB                   ; restore B register\r
 563           PULX                   ; restore X register\r
 564           RTS\r
 565 L_NOPAGE:\r
 566           STAA 0,Y               ; store the value passed in A\r
 567           PULX                   ; restore X register\r
 568           RTS\r
 569   }\r
 570 #else /* USE_SEVERAL_PAGES */\r
 571   asm {\r
 572           PSHB                 ; save A register\r
 573           LDAB   PAGE_ADDR     ; save page register\r
 574           MOVB  0,SP,PAGE_ADDR ; set page register\r
 575           STAA  0,Y            ; store the value passed in A\r
 576           STAB   PAGE_ADDR     ; restore page register\r
 577           PULB                   ; restore B register\r
 578           RTS\r
 579   }\r
 580 #endif /* USE_SEVERAL_PAGES */\r
 581 }\r
 582 \r
 583 /*--------------------------- _STORE_FAR_16 --------------------------------\r
 584   This runtime routine is used to access paged memory via a runtime function.\r
 585   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 586 \r
 587   Arguments :\r
 588   - offset part of an address in the Y register\r
 589   - page part of an address in the B register\r
 590   - value to be stored in the X register\r
 591 \r
 592   Result :\r
 593   - value stored at the address\r
 594   - all registers remains unchanged\r
 595   - all page register still contain the same value\r
 596   --------------------------- _STORE_FAR_16 ----------------------------------*/\r
 597 \r
 598 #ifdef __cplusplus\r
 599 extern "C"\r
 600 #endif\r
 601 #pragma NO_ENTRY\r
 602 #pragma NO_EXIT\r
 603 #pragma NO_FRAME\r
 604 \r
 605 void NEAR _STORE_FAR_16(void) {\r
 606 #if USE_SEVERAL_PAGES\r
 607   asm {\r
 608           PSHX                  ; save X register\r
 609           __PIC_JSR(_GET_PAGE_REG)\r
 610           BEQ    L_NOPAGE\r
 611 \r
 612           PSHA\r
 613           LDAA   0,X            ; save page register\r
 614           STAB   0,X            ; set page register\r
 615           MOVW   1,SP, 0,Y      ; store the value passed in X\r
 616           STAA   0,X            ; restore page register\r
 617           PULA                  ; restore A register\r
 618           PULX                  ; restore X register\r
 619           RTS\r
 620 \r
 621 L_NOPAGE:\r
 622           STX 0,Y               ; store the value passed in X\r
 623           PULX                  ; restore X register\r
 624           RTS\r
 625   }\r
 626 #else /* USE_SEVERAL_PAGES */\r
 627   asm {\r
 628           PSHA                 ; save A register\r
 629           LDAA   PAGE_ADDR     ; save page register\r
 630           STAB   PAGE_ADDR     ; set page register\r
 631           STX    0,Y           ; store the value passed in X\r
 632           STAA   PAGE_ADDR     ; restore page register\r
 633           PULA                 ; restore A register\r
 634           RTS\r
 635   }\r
 636 #endif /* USE_SEVERAL_PAGES */\r
 637 }\r
 638 /*--------------------------- _STORE_FAR_24 --------------------------------\r
 639   This runtime routine is used to access paged memory via a runtime function.\r
 640   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 641 \r
 642   Arguments :\r
 643   - offset part of an address in the Y register\r
 644   - page part of an address in the B register\r
 645   - value to be stored in the X:A registers (X : low 16 bit, A : high 8 bit)\r
 646 \r
 647   Result :\r
 648   - value stored at the address\r
 649   - all registers remains unchanged\r
 650   - all page register still contain the same value\r
 651   --------------------------- _STORE_FAR_24 ----------------------------------*/\r
 652 \r
 653 #ifdef __cplusplus\r
 654 extern "C"\r
 655 #endif\r
 656 #pragma NO_ENTRY\r
 657 #pragma NO_EXIT\r
 658 #pragma NO_FRAME\r
 659 \r
 660 void NEAR _STORE_FAR_24(void) {\r
 661 #if USE_SEVERAL_PAGES\r
 662   asm {\r
 663           PSHX                  ; save X register\r
 664           __PIC_JSR(_GET_PAGE_REG)\r
 665           BEQ    L_NOPAGE\r
 666 \r
 667           PSHA\r
 668           LDAA   0,X            ; save page register\r
 669           STAB   0,X            ; set page register\r
 670           MOVW   1,SP, 1,Y      ; store the value passed in X\r
 671           MOVB   0,SP, 0,Y      ; store the value passed in A\r
 672           STAA   0,X            ; restore page register\r
 673           PULA                  ; restore A register\r
 674           PULX                  ; restore X register\r
 675           RTS\r
 676 \r
 677 L_NOPAGE:\r
 678           STX    1,Y            ; store the value passed in X\r
 679           STAA   0,Y            ; store the value passed in X\r
 680           PULX                  ; restore X register\r
 681           RTS\r
 682   }\r
 683 #else /* USE_SEVERAL_PAGES */\r
 684   asm {\r
 685           PSHA                 ; save A register\r
 686           LDAA   PAGE_ADDR     ; save page register\r
 687           STAB   PAGE_ADDR     ; set page register\r
 688           MOVB   0,SP, 0,Y     ; store the value passed in A\r
 689           STX    1,Y           ; store the value passed in X\r
 690           STAA   PAGE_ADDR     ; restore page register\r
 691           PULA                 ; restore A register\r
 692           RTS\r
 693   }\r
 694 #endif /* USE_SEVERAL_PAGES */\r
 695 }\r
 696 /*--------------------------- _STORE_FAR_32 --------------------------------\r
 697   This runtime routine is used to access paged memory via a runtime function.\r
 698   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 699 \r
 700   Arguments :\r
 701   - offset part of an address in the Y register\r
 702   - page part of an address is on the stack at 3,SP (just below the return address)\r
 703   - value to be stored in the X:D registers (D : low 16 bit, X : high 16 bit)\r
 704 \r
 705   Result :\r
 706   - value stored at the address\r
 707   - all registers remains unchanged\r
 708   - the page part is removed from the stack\r
 709   - all page register still contain the same value\r
 710   --------------------------- _STORE_FAR_32 ----------------------------------*/\r
 711 \r
 712 #ifdef __cplusplus\r
 713 extern "C"\r
 714 #endif\r
 715 #pragma NO_ENTRY\r
 716 #pragma NO_EXIT\r
 717 #pragma NO_FRAME\r
 718 \r
 719 void NEAR _STORE_FAR_32(void) {\r
 720 #if USE_SEVERAL_PAGES\r
 721   asm {\r
 722           PSHX                  ; save X register\r
 723           __PIC_JSR(_GET_PAGE_REG)\r
 724           BEQ    L_NOPAGE\r
 725 \r
 726           PSHD\r
 727           LDAA   0,X            ; save page register\r
 728           MOVB   6,SP, 0,X      ; set page register\r
 729           MOVW   2,SP, 0,Y      ; store the value passed in X (high word)\r
 730           MOVW   0,SP, 2,Y      ; store the value passed in D (low word)\r
 731           STAA   0,X            ; restore page register\r
 732           PULD                  ; restore A register\r
 733           BRA done\r
 734 \r
 735 L_NOPAGE:\r
 736           MOVW   0,SP, 0,Y      ; store the value passed in X (high word)\r
 737           STD          2,Y      ; store the value passed in D (low word)\r
 738 done:\r
 739           PULX                  ; restore X register\r
 740           MOVW   0,SP, 1,+SP    ; move return address\r
 741           RTS\r
 742   }\r
 743 #else /* USE_SEVERAL_PAGES */\r
 744   asm {\r
 745           PSHD                    ; save D register\r
 746           LDAA   PAGE_ADDR        ; save page register\r
 747           LDAB   4,SP             ; load page part of address\r
 748           STAB   PAGE_ADDR        ; set page register\r
 749           STX    0,Y              ; store the value passed in X\r
 750           MOVW   0,SP, 2,Y        ; store the value passed in D (low word)\r
 751           STAA   PAGE_ADDR        ; restore page register\r
 752           PULD                    ; restore D register\r
 753           MOVW   0,SP, 1,+SP    ; move return address\r
 754           RTS\r
 755   }\r
 756 #endif /* USE_SEVERAL_PAGES */\r
 757 }\r
 758 \r
 759 /*--------------------------- _FAR_COPY --------------------------------\r
 760   This runtime routine is used to access paged memory via a runtime function.\r
 761   It may also be used if the compiler  option -Cp is not used with the runtime argument.\r
 762 \r
 763   Arguments :\r
 764   - offset part of the source int the X register\r
 765   - page part of the source in the A register\r
 766   - offset part of the dest int the Y register\r
 767   - page part of the dest in the B register\r
 768   - number of bytes to be copied at 2,SP. The number of bytes is always > 0\r
 769 \r
 770   Result :\r
 771   - memory area copied\r
 772   - no registers are saved, i.e. all registers may be destroied\r
 773   - all page register still contain the same value\r
 774 \r
 775 \r
 776   stack-structure at the loop-label:\r
 777      0,SP : destination offset\r
 778      2,SP : source page\r
 779      3,SP : destination page\r
 780      4,SP : source offset\r
 781      6,SP : return address\r
 782      8,SP : counter, > 0\r
 783   --------------------------- _FAR_COPY ----------------------------------*/\r
 784 \r
 785 #ifdef __cplusplus\r
 786 extern "C"\r
 787 #endif\r
 788 #pragma NO_ENTRY\r
 789 #pragma NO_EXIT\r
 790 #pragma NO_FRAME\r
 791 \r
 792 void NEAR _FAR_COPY(void) {\r
 793 #if USE_SEVERAL_PAGES\r
 794   asm {\r
 795         DEX                   ; source addr-=1, because loop counter ends at 1\r
 796         PSHX                  ; save source offset\r
 797         PSHD                  ; save both pages\r
 798         DEY                   ; destination addr-=1, because loop counter ends at 1\r
 799         PSHY                  ; save destination offset\r
 800         LDX     8,SP          ; load counter, assuming counter > 0\r
 801 \r
 802 loop:\r
 803         LDD     4,SP          ; load source offset\r
 804         LEAY    D,X           ; calcutate actual source address\r
 805         LDAB    2,SP          ; load source page\r
 806         __PIC_JSR (_LOAD_FAR_8); load 1 source byte\r
 807         PSHB                  ; save value\r
 808         LDD     0+1,SP        ; load destination offset\r
 809         LEAY    D,X           ; calcutate acual destination address\r
 810         PULA                  ; restore value\r
 811         LDAB    3,SP          ; load destination page\r
 812         __PIC_JSR (_STORE_FAR_8); store one byte\r
 813         DEX\r
 814         BNE     loop\r
 815         LDX     6,SP          ; load return address\r
 816         LEAS    10,SP         ; release stack\r
 817         JMP     0,X           ; return\r
 818   }\r
 819 #else\r
 820   asm {\r
 821         PSHD                   ; store page registers\r
 822         TFR   X,D\r
 823         ADDD  4,SP             ; calculate source end address\r
 824         STD   4,SP\r
 825         PULB                   ; reload source page\r
 826         LDAA  PAGE_ADDR        ; save page register\r
 827         PSHA\r
 828 loop:\r
 829         STAB  PAGE_ADDR        ; set source page\r
 830         LDAA  1,X+             ; load value\r
 831         MOVB  1,SP, PAGE_ADDR  ; set destination page\r
 832         STAA  1,Y+\r
 833         CPX   4,SP\r
 834         BNE   loop\r
 835 \r
 836         LDAA  2,SP+            ; restore old page value and release stack\r
 837         STAA  PAGE_ADDR        ; store it into page register\r
 838         LDX   4,SP+            ; release stack and load return address\r
 839         JMP   0,X              ; return\r
 840   }\r
 841 #endif\r
 842 }\r
 843 \r