Apple-2-SW/contiki
1
0
Fork 0
mirror of https://github.com/oliverschmidt/contiki.git synced 2024-11-19 18:40:17 +00:00
Code Issues Projects Releases Wiki Activity
21d6abe30b
contiki/cpu/6502/sys/mtarch-asm.S

243 lines
5.7 KiB
ArmAsm
Raw Normal View History

Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
;
; Copyright (c) 2004, Adam Dunkels.
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; 1. Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; 2. Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
; 3. Neither the name of the Institute nor the names of its contributors
; may be used to endorse or promote products derived from this software
; without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
; ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
; LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
; OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
; SUCH DAMAGE.
;
; This file is part of the Contiki operating system.
;
; Author: Adam Dunkels <adam@sics.se>
;
;---------------------------------------------------------------------
.import __ZP_START__
.import _mtarch_asm_threadspreg
.import _mtarch_asm_threadzp
.import _mtarch_asm_threadstack
.export _mtarch_asm_start
.export _mtarch_asm_yield
.export _mtarch_asm_exec
;---------------------------------------------------------------------
.bss
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
kernelspreg: .res 1
zpsave: .res 2
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
zpspace = 26 ; see <cc65 source>/asminc/zeropage.inc
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
;---------------------------------------------------------------------
.code
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Switch to thread defined by threadzp, threadstack and threadspreg.
; The kernel CPU stack is swapped onto the threadstack, and the
; CPU stack pointer is saved to the local variable "kernelspreg".
; Also, the zeropage variables are saved.
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
_mtarch_asm_exec:
sei
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Save kernel CPU stack pointer
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
tsx
stx kernelspreg
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Save zp locations FE/FF
lda $FE
sta zpsave
lda $FF
sta zpsave+1
; Get zero page buffer addr
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FE
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp+1
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Swap zero page content with buffer content
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
ldy #0
: lda <__ZP_START__,y
tax
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
lda ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
sta <__ZP_START__,y
txa
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
iny
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
cpy #zpspace
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
bne :-
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Get CPU stack buffer addr
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadstack
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FE
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadstack+1
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Get CPU stack size
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
ldy kernelspreg ; Determine the smallest of the two stack pointers,
cpy _mtarch_asm_threadspreg ; as we only need to swap the used part of the stack.
bcc :+
ldy _mtarch_asm_threadspreg
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Swap CPU stack content with buffer content
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
: lda $0100,y
tax
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
lda ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
sta $0100,y
txa
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
iny
bne :-
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Restore zp locations FE/FF
lda zpsave
sta $FE
lda zpsave+1
sta $FF
; Set thread CPU stack pointer
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
ldx _mtarch_asm_threadspreg
txs
pla
tay
pla
tax
pla
rti
;---------------------------------------------------------------------
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Switch from thread defined by threadzp, threadstack and threadspreg.
; The kernel CPU stack is swapped back from the threadstack, and the
; CPU stack pointer is restored from the local variable "kernelspreg".
; Also, the zeropage variables are restored.
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
_mtarch_asm_yield:
php
pha
txa
pha
tya
pha
sei
tsx ; The rts adds 1 to the PC
; saved on the stack. We want
lda $0105,x ; the stack to look like is would
clc ; do inside of an interrupt
adc #1 ; (this is what the 'rts' does,
sta $0105,x ; but not the 'rti').
lda $0106,x
adc #0
sta $0106,x
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Save thread CPU stack pointer
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
tsx
stx _mtarch_asm_threadspreg
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Save zp locations FE/FF
lda $FE
sta zpsave
lda $FF
sta zpsave+1
; Get zero page buffer addr
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FE
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp+1
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Swap zero page content with buffer content
ldy #0
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
: lda <__ZP_START__,y
tax
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
lda ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
sta <__ZP_START__,y
txa
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
iny
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
cpy #zpspace
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
bne :-
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Get CPU stack buffer addr
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadstack
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FE
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadstack+1
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Get CPU stack size
ldy kernelspreg ; Determine the smallest of the two stack pointers,
cpy _mtarch_asm_threadspreg ; as we only need to swap the used part of the stack.
bcc :+
ldy _mtarch_asm_threadspreg
; Swap CPU stack content with buffer content
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
: lda $0100,y
tax
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
lda ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
sta $0100,y
txa
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
iny
bne :-
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Restore zp locations FE/FF
lda zpsave
sta $FE
lda zpsave+1
sta $FF
; Set kernel CPU stack pointer
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
ldx kernelspreg
txs
cli
rts
;---------------------------------------------------------------------
_mtarch_asm_start:
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Save zp locations FE/FF
lda $FE
sta zpsave
lda $FF
sta zpsave+1
; Get zero page buffer addr
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FE
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
lda _mtarch_asm_threadzp+1
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Copy zero page content to buffer
ldy #$00
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
: lda <__ZP_START__,y
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
sta ($FE),y
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
iny
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
cpy #zpspace
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
bne :-
- The cc65 assembler variable 'ptr1' (a general zero page pointer) is actually part of the cc65 zero page area so it's a bad idea (tm) to use it in swapping that very area. - The cc65 assembler variable 'sp' (the pointer to the C stack) is actually part of the cc65 zero page area so there's no need to manage it explicitly. Furthermore it is known to reside at the very start of the area so it can be initialized there for new threads.
2007-08-10 10:45:35 +00:00
; Restore zp locations FE/FF
lda zpsave
sta $FE
lda zpsave+1
sta $FF
Added Multithreading support to the cc65 targets based on the Contiki 1.x C64 implementation with the following changes: - Added support for the function parameter. - Removed support for preemption because: - No other current implementation does so. - Preemption support would make the code at least target-dependent or it wouldn't work at all (as on plain Apple2 machines without timer interrupt).
2007-04-21 22:15:45 +00:00
rts
;---------------------------------------------------------------------
Reference in New Issue Copy Permalink