Subversion Repositories or1k

;******************************************************************************
;* Copyright 1991 Advanced Micro Devices, Inc.
;*
;* This software is the property of Advanced Micro Devices, Inc  (AMD)  which
;* specifically  grants the user the right to modify, use and distribute this
;* software provided this notice is not removed or altered.  All other rights
;* are reserved by AMD.
;*
;* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
;* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
;* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
;* USE OF THIS SOFTWARE.
;*
;* Comments about this software should be directed to udi@amd.com. If access
;* to electronic mail isn't available, send mail to:
;*
;* Advanced Micro Devices, Inc.
;* 29K Support Products
;* Mail Stop 573
;* 5900 E. Ben White Blvd.
;* Austin, TX 78741
;* 800-292-9263
;*****************************************************************************
;*       $Id: dostip.asm,v 1.1.1.1 2001-05-18 11:27:55 markom Exp $
;*       $Id: @(#)dostip.asm    2.7, AMD
;******************************************************************************
;*/

IFNDEF DOS386
        DOSSEG
        .MODEL  LARGE
        PUBLIC  _UDIASMConnect
        PUBLIC  _UDIASMDisconnect
        EXTRN   _UDICDisconnect:FAR
        EXTRN   _UDICConnect:FAR
        .CODE
ELSE
;
; Segment ordering and attributes for DOS386.  We make sure the
; real mode code and data comes first.  The real and
; prot mode data are together so they can be grouped.
;

rmcode  segment byte public use16
; We need to mark the first byte in rmcode to figure the real segment value
        public   rmcode_firstbyte
rmcode_firstbyte        label byte

rmcode  ends
rmdata  segment dword public use16
rmdata  ends
pmdata  segment dword public use32
pmdata  ends
pmcode  segment byte public use32
pmcode  ends
dgroup  group   rmdata,pmdata



rmcode segment          ; _UDIASMDisconnect will be in rmcode segment

ENDIF


        INCLUDE udidos.ah               ; TermStruct Definitions from DFE

_UDIASMDisconnect    LABEL   FAR
;
; Save off important stuff in structure whose address
; is given as third parameter to this function.
        mov     bx, sp
        les     bx, ss:8[bx]
        mov     es:[bx].sss, ss
        mov     es:[bx].ssp, sp
        mov     es:[bx].ssi, si
        mov     es:[bx].sdi, di
        mov     es:[bx].sbp, bp
        mov     es:[bx].sds, ds

IFNDEF DOS386
        jmp     _UDICDisconnect         ; real mode, just jump to the C routine
ELSE
        jmp     rm_UDIDisconnect        ; DOS386, jump to the real mode stub
ENDIF

_UDIASMConnect    LABEL   FAR
;
; Save off important stuff in structure whose address
; is given as third parameter to this function.
        mov     bx, sp
        les     bx, ss:12[bx]
        mov     es:[bx].sss, ss
        mov     es:[bx].ssp, sp
        mov     es:[bx].ssi, si
        mov     es:[bx].sdi, di
        mov     es:[bx].sbp, bp
        mov     es:[bx].sds, ds
IFNDEF DOS386
        jmp     _UDICConnect            ; real mode, just jump to the C routine
ELSE
        jmp     rm_UDIConnect           ; DOS386, jump to the real mode stub
ENDIF

IFDEF DOS386
        ; Note: the rest of this file is just DOS386 support

rmcode ends

;
; Data that needs to be accessed in both real
; mode and protected mode
;
rmdata  segment

        public code_selector, data_selector, call_prot
        public  segregblock
        ; these get filled in by protected mode startup code
code_selector  DW ?
data_selector  DW ?
call_prot       DD ?
segregblock     DW ?    ; ds value      ; seg reg block filled in at startup time
                DW ?    ; es value
                DW ?    ; fs value
                DW ?    ; gs value

        public TIPName
TIPName         DB  256 DUP(?)

        public TIPVecRec
TIPVecRec       DB  0,0,0,0     ; will get filled in by main
                DD  0           ; next ptr
                DD  0           ; prev ptr
                DD  TIPName     ; exeName
                                ; the other entries get added by the udi_table macro below
TIPVecRecEnd    LABEL BYTE

rmdata  ends




;
; Data that is only accessed in prot mode
;
        extrn  conventional_memory:DWORD        ; set up by dx_map_physical
        extrn  stack_table: DWORD               ; set up by C-level code.

pmdata   segment
dos386glue_table LABEL DWORD    ; so we can reference it later in the udi_table macro
                                ; the entries get added by the udi_table macro below
pmdata   ends



;; The udi_table macro does three things
;;      1) generates real mode entry point for each UDI function
;;         This code just sets an index in bl and jumps to rm_common
;;      2) adds an entry into the TIPVecRec to point to the above real mode entry point
;;      3) adds an entry into the dos386glue_table table which is used by the prot.mode stub
;;         to call the actual C glue routine.
 
udi_table       MACRO   UDIProcName,val
rmcode segment
        public  rm_&UDIProcName
rm_&UDIProcName LABEL NEAR
        mov     bl, val         ;; bl will indicate which UDI Proc was called
        jmp     short rm_common
rmcode  ends

rmdata segment
        ORG     TIPVecRec + 16 + 4*val  ;; Entry in TIPVecRec (+16 for first 4 fields)
        IF      val EQ 0
        DD      _UDIASMConnect          ;; special case for Connect
        ELSE
        IF      val EQ 1
        DD      _UDIASMDisconnect       ;; special case for Disconnect
        ELSE
        DD      rm_&UDIProcName         ;; normal entry is rm_ stub
        ENDIF
        ENDIF
rmdata ends

pmdata segment
        EXTRN   d386_&UDIProcName:NEAR
        ORG     dos386glue_table + 4*val        ;; this builds the jump table that pmstub uses
        DD      d386_&UDIProcName
pmdata ends

        ENDM

        udi_table   UDIConnect,0
        udi_table   UDIDisconnect,1
        udi_table   UDISetCurrentConnection,2
        udi_table   UDICapabilities,3
        udi_table   UDIGetErrorMsg,4
        udi_table   UDIGetTargetConfig,5
        udi_table   UDICreateProcess,6
        udi_table   UDISetCurrentProcess,7
        udi_table   UDIDestroyProcess,8
        udi_table   UDIInitializeProcess,9
        udi_table   UDIRead,10
        udi_table   UDIWrite,11
        udi_table   UDICopy,12
        udi_table   UDIExecute,13
        udi_table   UDIStep,14
        udi_table   UDIStop,15
        udi_table   UDIWait,16
        udi_table   UDISetBreakpoint,17
        udi_table   UDIQueryBreakpoint,18
        udi_table   UDIClearBreakpoint,19
        udi_table   UDIGetStdout,20
        udi_table   UDIGetStderr,21
        udi_table   UDIPutStdin,22
        udi_table   UDIStdinMode,23
        udi_table   UDIPutTrans,24
        udi_table   UDIGetTrans,25
        udi_table   UDITransMode,26


rmcode  segment
        ASSUME  nothing, CS:rmcode      ; all we know is that CS=rmcode


        ; Common real mode stub code
        ; bl is an index indicating which UDI function was called
        ; we need to switch to protected mode (ebx will be passed thru unchanged)
rm_common  PROC FAR             ; UDI always called as far (real mode)
        push    ds              ; save ds
        push    bp              ; and save bp
        push    si              ; and si, di
        push    di
                                ; note: if anything else gets pushed here, you must
                                ; change the MSCPARAMS macro in dos386c.c
        push    cs
        pop     ds              ; set ds = cs
        ASSUME ds:dgroup
        ; to switch to protected mode, we push a dword ptr to a block which
        ; contains the protected mode segment registers to use
        ; and we push the 48-bit protected address of pmstub
        ; then we call the call_prot routine which was returned by dx_rmlink_get

        push    cs              ; segment of seg reg block
        lea     ax, segregblock
        push    ax              ; offset of seg reg block
        push    code_selector
        lea     eax, pmstub
        push    eax
        call    call_prot
        add     sp, 10          ; unpop all things we pushed
                                ; ax return code from prot mode passed thru
        
        pop     di              ; unpop di,si saved earlier
        pop     si
        pop     bp              ; unpop the BP we saved earlier
        pop     ds              ; unpop the DS we saved earlier
        ret                     ; will do a FAR (real mode) ret to DFE

rm_common  ENDP

rmcode  ends

        
        

pmcode segment

pmstub proc far
        ; at this point ss:sp -> far return (DF) back to dos-extender
        ;                  sp+6  a word of 0
        ;                 sp+8   the pushed DS (of rmstub)
        ;                 sp+10  parameters
        ; we pop the far return and save it away
        ; then we call the real application procedure (the params still on stack)
        ASSUME CS:pmcode, DS:dgroup
        ; first let's switch ss:esp so that ss = ds
        ; (it will still point to the same physical memory location)
        ; (we'll save the old ss:esp on the stack in case they're needed)
        mov     dx, ss
        mov     ecx, esp
        ; at this point, ecx contains the physical 32-bit address of sp
        ; (selector 60h's offset mapped directly to 1meg physical memory)

        mov     eax, conventional_memory
        cmp     eax, 0          ; if conventional memory not mapped take other path
        je      short conv_mem_unmapped
 
                ; This is the code that is not DPMI compatible
                ; we add the ofst of beggining of conventional memory to esp
                ; to make it SS_DATA relative and then use data_selector as the SS
                ; thus no stack switch is necessary, we just remap the old stack
        add     eax, ecx        ; this adds esp to conventional_memory
        mov     ss, data_selector
        mov     esp, eax
        jmp     short got_ss_sp
                ; now ss:esp points to same place as before but using different segment


conv_mem_unmapped:
                ; This code is DPMI compatible
                ; we actually switch to a new stack that is in the TIPs DS
                ; the number and size of these stacks was allocated at startup time.
        lea     eax, stack_table
chk_stack:
        cmp     dword ptr [eax], 0
        je      short no_stack  ; stack pointer of 0 means end of table
        mov     esi, dword ptr [eax]    ; get stack pointer
        cmp     dword ptr [esi+4], 0    ; is it marked free?
        je      short take_stack
        add     eax, 4          ; to next stack entry in table
        jmp     chk_stack

no_stack:
        mov     eax, 25         ; IPC Limitation error
        ret

take_stack:
        mov     dword ptr [esi+4], 0ffffffffh   ; mark stack in use
        mov     ss, data_selector
        mov     esp, esi        ; get stack pointer from table
                                ; now we have ss = ds, so we can go to C level.

got_ss_sp:
        ; push the old ss:esp on the stack
        push    edx             ; old ss (need to push as full 32-bit for C convention)
        push    ecx             ; old esp

        ; bl still contains the UDIProcedure Index (which was set up by the rm stub)
        ; use this to get to the correct dos386glue_table routine 
        xor     bh, bh
        shl     bx,1            ; *4 for indexing into DD array
        shl     bx,1
        call    dos386glue_table[bx]
        ; on return, we just need to restore the old ss:esp
        pop     ecx
        pop     edx

        cmp     conventional_memory, 0  ; if we had switched stacks
        jne     short no_stack_clear
        mov     dword ptr [esp+4], 0    ; clear the stack in use indicator

no_stack_clear:
                                ; this code is identical whether we switched stacks or not
                                ; we just restore the old ss:sp and return
        mov     ss, dx
        mov     esp, ecx
                                ; the stack should look as it did when we entered
                                ; so we just do a far ret
        ret
pmstub endp


        public  GetCS
GetCS   PROC NEAR
        mov     ax, cs
        ret
GetCS   ENDP

        public  GetDS
GetDS   PROC NEAR
        mov     ax, ds
        ret
GetDS   ENDP


        public  _exp_return
        extrn   _top:dword

_exp_return PROC FAR
        ; set the stack pointer back to its initial state as left by dfe
        ; (leave the ss unchanged)
        ; then do a far ret which will get us back to the dfe.
        ; (which will then restore its own stack).
        mov     ebp, esp
        mov     eax, [ebp+4]    ; errcode
        mov     ecx, _top
        add     ecx, 2
        mov     esp, ecx
        ret
_exp_return ENDP

pmcode ends


rmdata   segment
;
; Symbol marking end of real mode code & data,
; used at link time to specify the real mode
; code & data size
;
        public  end_real
end_real label  byte
rmdata   ends



ENDIF   ; end of DOS386 conditional code

        END