1 /******************************************************************************
\r
3 PURPOSE : paged data access runtime routines
\r
4 MACHINE : Motorola 68HC12 (Target)
\r
6 HISTORY : 21.7.96 first version created
\r
7 ******************************************************************************/
\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
19 /* if no compiler option -Cp is given, it is assumed that all possible are given : */
\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
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
33 #elif defined(HC812A4)
\r
34 /* all setting default to A4 already */
\r
38 #if !defined(__EPAGE__) && !defined(__PPAGE__) && !defined(__DPAGE__)
\r
39 /* as default use all page registers */
\r
45 /* modify the following defines to your memory configuration */
\r
47 #define EPAGE_LOW_BOUND 0x400u
\r
48 #define EPAGE_HIGH_BOUND 0x7ffu
\r
50 #define DPAGE_LOW_BOUND 0x7000u
\r
51 #define DPAGE_HIGH_BOUND 0x7fffu
\r
53 #define PPAGE_LOW_BOUND (DPAGE_HIGH_BOUND+1)
\r
54 #define PPAGE_HIGH_BOUND 0xBFFFu
\r
56 #define REGISTER_BASE 0x0u
\r
58 #define DPAGE_ADDR (0x34u+REGISTER_BASE)
\r
61 #define EPAGE_ADDR (0x36u+REGISTER_BASE)
\r
64 #define PPAGE_ADDR (0x35u+REGISTER_BASE)
\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
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
77 #if DPAGE_HIGH_BOUND+1 != PPAGE_LOW_BOUND
\r
78 #error /* please adapt _GET_PAGE_REG for this non default page configuration */
\r
82 #include "non_bank.sgm"
\r
83 #include "runtime.sgm"
\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
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
101 #define USE_SEVERAL_PAGES 0
\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
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
120 This function is only used by the functions below.
\r
122 Depending on the compiler options -Cp different versions of _GET_PAGE_REG are produced.
\r
125 - Y : offset part of an address
\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
133 if address Y is not controlled by a page register :
\r
135 - all registers remain unchanged
\r
137 --------------------------- _GET_PAGE_REG ----------------------------------*/
\r
139 #if defined(__DPAGE__)
\r
148 static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */
\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
155 BLO L_NOPAGE ; no paged memory below accesses
\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
161 BHI L_NOPAGE ; no paged memory above accesses
\r
164 LDX #DPAGE_ADDR ; load page register address and clear zero flag
\r
167 #if defined(__PPAGE__)
\r
169 CPY #PPAGE_HIGH_BOUND ; test of higher bound of PPAGE
\r
172 LDX #PPAGE_ADDR ; load page register address and clear zero flag
\r
176 #if defined(__EPAGE__)
\r
178 CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE
\r
180 CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE
\r
184 LDX #EPAGE_ADDR ; load page register address and clear zero flag
\r
189 ORCC #0x04 ; sets zero flag
\r
194 #else /* !defined(__DPAGE__) */
\r
196 #if defined( __PPAGE__ )
\r
205 static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */
\r
208 CPY #PPAGE_LOW_BOUND ; test of lower bound of PPAGE
\r
209 #if defined( __EPAGE__ )
\r
212 BLO L_NOPAGE ; no paged memory below
\r
214 CPY #PPAGE_HIGH_BOUND ; test of higher bound PPAGE
\r
217 LDX #PPAGE_ADDR ; load page register address and clear zero flag
\r
219 #if defined( __EPAGE__ )
\r
221 CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE
\r
223 CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE
\r
226 LDX #EPAGE_ADDR ; load page register address and clear zero flag
\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
237 #else /* !defined(__DPAGE__ ) && !defined( __PPAGE__) */
\r
238 #if defined(__EPAGE__)
\r
247 static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */
\r
250 CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE
\r
252 CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE
\r
255 LDX #EPAGE_ADDR ; load page register address and clear zero flag
\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
265 #endif /* defined(__EPAGE__) */
\r
266 #endif /* defined(__PPAGE__) */
\r
267 #endif /* defined(__DPAGE__) */
\r
269 #endif /* USE_SEVERAL_PAGES */
\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
277 - offset part of an address in the Y register
\r
278 - page part of an address in the B register
\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
293 void NEAR _SET_PAGE(void) {
\r
294 #if USE_SEVERAL_PAGES
\r
296 PSHX ; save X register
\r
297 __PIC_JSR(_GET_PAGE_REG)
\r
299 STAB 0,X ; set page register
\r
301 PULX ; restore X register
\r
304 #else /* USE_SEVERAL_PAGES */
\r
306 STAB PAGE_ADDR ; set page register
\r
309 #endif /* USE_SEVERAL_PAGES */
\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
317 - offset part of an address in the Y register
\r
318 - page part of an address in the B register
\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
333 void NEAR _LOAD_FAR_8(void) {
\r
334 #if USE_SEVERAL_PAGES
\r
336 PSHX ; save X register
\r
337 __PIC_JSR(_GET_PAGE_REG)
\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
348 LDAB 0,Y ; actual load, overwrites page
\r
349 PULX ; restore X register
\r
352 #else /* USE_SEVERAL_PAGES */
\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
362 #endif /* USE_SEVERAL_PAGES */
\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
370 - offset part of an address in the Y register
\r
371 - page part of an address in the B register
\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
386 void NEAR _LOAD_FAR_16(void) {
\r
387 #if USE_SEVERAL_PAGES
\r
389 PSHX ; save X register
\r
390 __PIC_JSR(_GET_PAGE_REG)
\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
401 LDY 0,Y ; actual load, overwrites address
\r
402 PULX ; restore X register
\r
405 #else /* USE_SEVERAL_PAGES */
\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
415 #endif /* USE_SEVERAL_PAGES */
\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
422 - offset part of an address in the Y register
\r
423 - page part of an address in the B register
\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
438 void NEAR _LOAD_FAR_24(void) {
\r
439 #if USE_SEVERAL_PAGES
\r
441 PSHX ; save X register
\r
442 __PIC_JSR(_GET_PAGE_REG)
\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
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
459 #else /* USE_SEVERAL_PAGES */
\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
470 #endif /* USE_SEVERAL_PAGES */
\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
479 - offset part of an address in the Y register
\r
480 - page part of an address in the B register
\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
496 void NEAR _LOAD_FAR_32(void) {
\r
497 #if USE_SEVERAL_PAGES
\r
499 PSHX ; save X register
\r
500 __PIC_JSR(_GET_PAGE_REG)
\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
511 LDD 2,Y ; actual load, low word
\r
512 LDY 0,Y ; actual load, high word
\r
513 PULX ; restore X register
\r
516 #else /* USE_SEVERAL_PAGES */
\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
526 #endif /* USE_SEVERAL_PAGES */
\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
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
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
551 void NEAR _STORE_FAR_8(void) {
\r
552 #if USE_SEVERAL_PAGES
\r
554 PSHX ; save X register
\r
555 __PIC_JSR(_GET_PAGE_REG)
\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
566 STAA 0,Y ; store the value passed in A
\r
567 PULX ; restore X register
\r
570 #else /* USE_SEVERAL_PAGES */
\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
580 #endif /* USE_SEVERAL_PAGES */
\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
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
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
605 void NEAR _STORE_FAR_16(void) {
\r
606 #if USE_SEVERAL_PAGES
\r
608 PSHX ; save X register
\r
609 __PIC_JSR(_GET_PAGE_REG)
\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
622 STX 0,Y ; store the value passed in X
\r
623 PULX ; restore X register
\r
626 #else /* USE_SEVERAL_PAGES */
\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
636 #endif /* USE_SEVERAL_PAGES */
\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
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
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
660 void NEAR _STORE_FAR_24(void) {
\r
661 #if USE_SEVERAL_PAGES
\r
663 PSHX ; save X register
\r
664 __PIC_JSR(_GET_PAGE_REG)
\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
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
683 #else /* USE_SEVERAL_PAGES */
\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
694 #endif /* USE_SEVERAL_PAGES */
\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
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
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
719 void NEAR _STORE_FAR_32(void) {
\r
720 #if USE_SEVERAL_PAGES
\r
722 PSHX ; save X register
\r
723 __PIC_JSR(_GET_PAGE_REG)
\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
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
739 PULX ; restore X register
\r
740 MOVW 0,SP, 1,+SP ; move return address
\r
743 #else /* USE_SEVERAL_PAGES */
\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
756 #endif /* USE_SEVERAL_PAGES */
\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
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
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
776 stack-structure at the loop-label:
\r
777 0,SP : destination offset
\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
792 void NEAR _FAR_COPY(void) {
\r
793 #if USE_SEVERAL_PAGES
\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
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
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
815 LDX 6,SP ; load return address
\r
816 LEAS 10,SP ; release stack
\r
821 PSHD ; store page registers
\r
823 ADDD 4,SP ; calculate source end address
\r
825 PULB ; reload source page
\r
826 LDAA PAGE_ADDR ; save page register
\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
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