OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [HCS12_CodeWarrior_small/] [Sources/] [datapage.c] - Blame information for rev 588

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.