*
* Laden und starten eines Programms aus dem Bootblock!
*
* Dies ist nur ein Beispiel für einen Bootblock-Lader!
*
* completed on 6/12/89  16:57:28  by Holger Gzella
*
* ACHTUNG: Das zu ladende Programm darf nicht länger
*          als 10240 Bytes (20 Blocks) sein. Bei
*          Bedarf sollten Sie diesen Code entsprechend
*          verändern.
*

                opt     p+

                incdir "asm:"
                include "exec/exec_lib.i"

                dc.b    "DOS",0
                dc.l    0
                dc.l    $370

                movem.l d1-d7/a1-a6,-(SP)       * Register retten

                move.l  #$8100,$DFF096

                move.l  #10240,d0               * max. 10240 Bytes
                move.l  #$2,d1                  * CHIP-Memory!

                move.l  a1,a4
                CALLEXEC AllocMem               * allokieren
                move.l  a4,a1
                tst.l   d0
                beq     Failure                 * Fehler???
                move.l  d0,a2
                move.l  d0,a5

*
* Jetzt werden die einzelnen Blöcke
* in einer Schleife eingeladen.
*

                lea     BlockMask(pc),a3        * Blockmaske holen
                move.l  (a3),d1

                move.l  #0,a3
                moveq.l #0,d2

testfinish:     bclr    d2,d1                   * Block geladen?
                                                * entsprechendes Bit
                                                * löschen
                beq.s   NextOne

                bsr     LoadBlock               * Block laden
                tst.l   d0                      * lieferte DoIO
                                                * einen Fehler zurück?
                bne.s   DasWars                 * ja!

NextOne:        add.l   #$0200,a3               * #512 (Blocklänge)
                                                * addieren
                addq.l  #1,d2                   * nächster Block ...

                tst.l   d1                      * war's der letzte?
                bne.s   testfinish              * ne!

                bra.s   StartBoot               * Programm starten

*
* Diese Routine dient dazu, einen
* einzigen Block einzuladen.
*

LoadBlock:      move.w  #2,28(a1)               * Kommando: lesen
                move.l  a3,44(a1)               * Byte-Offset
                move.l  a2,40(a1)               * Adresse
                move.l  #$200,36(a1)            * Länge: 512 Bytes

                movem.l d1-d2/a1-a3,-(SP)

                CALLEXEC DoIO                   * und 'reinladen!

                movem.l (SP)+,d1-d2/a1-a3

                add.l   #$200,a3                * Byte-Offset erhöhen
                add.l   #$200,a2                * Zieladresse erhöhen
                addq.l  #1,d2                   * Blockzähler erhöhen

                rts                             * zurück!

*
* Nun wird das eingeladende
* Programm gestartet.
*

StartBoot:      jsr     (a5)                    * Start!

*
* Der Schluß ...
*

DasWars:        move.l  a5,a1                   * Memory
                move.l  #10240,d0               * wieder
                CALLEXEC FreeMem                * freigeben

Failure:        movem.l (SP)+,d1-d7/a1-a6       * Register holen

                lea     ResName(pc),a1          * "dos.library"
                CALLEXEC FindResident           * suchen
                tst.l   d0
                beq.s   BootFault               * gefunden?
                move.l  d0,a0                   * ja!
                move.l  $16(a0),a0              * initCode holen

                moveq   #0,d0               
                rts

BootFault:      moveq   #1,d0
                rts

*
* Das ist die Lademaske ... es werden die Blocks
* 0-19 (nicht die beiden Bootblöcke) eingeladen.
* So bleiben für das Programm 20 Blocks frei
* (10240 Bytes). Wird mehr gewünscht, müssen Sie
* dieses Ladeprogramm entsprechend verändern.
*

BlockMask:      dc.l    %00000000001111111111111111111100

Memory:         dc.l    0

ResName:        dc.b    "dos.library",0
 even

*
* Nun kommen die entsprechenden Füllbytes ...
*

                ds.b    798

*
* Dies ist das zu ladende Programm ...
* der Einfachheit wegen nur ein Farbspiel ...
*

Prog:           move.w  #$ffff,d0
Blink:          move.w  d0,$dff180
                dbra    d0,Blink

                rts

                END