module sys1;

segment C_sys1(F_CODE,28H); group G_sys1(C_sys1); select C_sys1;

(* ce fichier contient un certain nombre de routines asembleur utilis‚es par
   le kernel. Elles sont les suivantes:

        phys_copy       : copie des donn‚es d'un endroit quelconque … un autre
                          endroit quelconque en m‚moire.
        cp_mess         : copie un message de SOURCE … DESTINATION.
        port_out        : sort une donn‚e sur PORT.
        port_in         : entre une donn‚e sur PORT.
        lock            : bloque les interruptions.
        unlock          : d‚bloque les interruptions.
        restore         : restaure les interruptions comme elles ‚taient avant
                          lock().
        build_sig       : construit une structure compos‚e de 4 mots m‚moire
                          pour les signaux.
        csv             : d‚but de proc‚dure de sauvegarde des registres.
        cret            : fin de proc‚dure pour restaurer les registres.
        get_chrome      : retourne 0 si carte couleur, 1 si monochrome.
        vid_copy        : copie des donn‚es sur l'‚cran (m‚moire vid‚o);
        reboot          : reboot pour CTRL-ALT-DEL.
        wreboot         : attente de la frappe d'un caractŠre avant le reboot.

   Toutes ces proc‚dures sont appel‚es par d'autres modules.

   Une proc‚dure externe est appel‚e  : panic

   Celui-ci utilise les structures suivantes:

                                        color
                                        cur_proc
                                        proc_ptr
                                        splimit
                                        vec_table

*)

(*==============================================================================
                              phys_copy
  ==============================================================================
   Cette routine a la syntaxe suivante :
    phys_copy ( source , destination : ADRESS ;bytecount : CARDINAL);
*)

public sys1$phys_copy:

        pushf                           (* sauve les flags *)
        cli                             (* interdit les interruptions *)
        push       bp                   (* sauve les registres *)
        push       ax                   (* sauve ax *)
        push       bx                   (* sauve bx *)
        push       cx                   (* sauve cx *)
        push       dx                   (* sauve dx *)
        push       si                   (* sauve si *)
	push       di			(* sauve di *)		
        push       ds                   (* sauve ds *)
        push       es                   (* sauve es *)
        mov        bp,sp                (* initialise bp … l'adresse de es sauv‚ *)

 l0:    mov        ax,[bp][30]          (* ax est l'adresse haute de destination(32 bits) *)
        mov        di,[bp][28]          (* di en est l'adresse basse *)
        mov        cx,4               (* d‚bute l'extraction du nombre de clicks de destination *)
 l1:    rcr        ax,1                 (* le nombre de clicks est
                                           l'adesse de destination/16*)
        rcr        di,1                 (* est utilis‚ dans le registre de segment
                                           pour la copie *)
        loop       l1                   (* 4 bits de l'adresse haute sont
                                           utilis‚s *)
        mov        es,di                (* es = click de destination *)
        mov        ax,[bp][34]          (* ax est l'adresse haute de source *)
        mov        si,[bp][32]          (* si est l'adresse basse de source *)
        mov        cx,4               (* d‚bute l'extraction du nombre de clicks de source  *)

 l2:    rcr        ax,1                 (* le nombre de click = adresse de source/16*)
        rcr        si,1                 (* est utilis‚ dans les registres de segment pour la copie *)
        loop       l2                   (* 4 bits de l'adresse haute sont utilis‚s *)
        mov        ds,si                (* ds = click de la source *)
        mov        di,[bp][28]          (* di = adresse basse de destination *)
        and        di,0FH               (* di = offset du paragraphe # dans es *)
        mov        si,[bp][32]          (* si = partie basse de l'adresse source *)
        and        si,0FH               (* si = offset du paragraphe # dans ds *)
        mov        dx,[bp][26]          (* dx = partie haute du nombre d'octets *)
        mov        cx,[bp][24]          (* cx = partie basse du nombre d'octets *)
        test       cx,08000H            (* on compare cx avec 32768 : s > alors on ne
                                           fait que 32768 *)
        jnz        l3                   (* par it‚ration *)
        test       dx,0FFFFH            (* teste les 17 bits hauts pour voir si *)
        jnz        l3                   (* Si bytes > 32768 alors go l3 *)
        jmp        l4                   (* sinon go l4)*)

 l3:    mov        cx,08000H            (* 32768 *)

 l4:    mov        ax,cx                (* sauve le nombre actuel de count *)
        test       cx,00001H            (* on copie un mot ou un octet ?? *)
        jz         l5                   (* saut … l5 si copie par mot *)
        rep                             (* copie un octet … la fois *)
        movsb                            (* la copie en fait *)
        jmp        l6                   (* test si plus d'octets *)

 l5:    shr        cx,1                 (* copie par mot *)
        rep                             (* copie un mot … la fois *)
        movsw                            (* la copie en fait *)

 l6:    mov        dx,[bp][26]          (* decr count,incr src & dst ,r‚pŠte si n‚c‚ssaire *)
        mov        cx,[bp][24]          (* dx || cx = compteur 32 bits *)
        xor        bx,bx                (* bx || ax = nombre d‚j… utilis‚ *)
        sub        cx,ax                (* calcule bytes - nombre d‚j… fait *)
        sbb        dx,bx                (* dx || ax = nombre non faits *)
        or         cx,cx                (* test si = 0 *)
        jnz        l7                   (* si encore go l7 *)
        or         dx,dx                (* retest *)
        jnz        l7                   (* si la boucle est finie alors passage outre *)
        pop        es                   (* on restaure tout dans l'ordre *)
        pop        ds
        pop        di
        pop        si
        pop        dx
        pop        cx
        pop        bx
        pop        ax
        pop        bp
        popf
        sti
        ret        far 12

 l7:    mov     [bp][26],dx             (* stocke le nombre d‚crement‚ en m‚moire *)
        mov     [bp][24],cx             (* stocke la partie basse du compteur *)
        add     [bp][28],ax             (* incremente la destination *)
        adc     [bp][30],bx             (* partie basse avec retenue*)
        add     [bp][32],ax             (* incremente la source *)
        adc     [bp][34],bx             (* partie basse avec retenue*)
        jmp	l0


end