
                            Az EMS memria kezelse       MEG NEM KESZ!
                            

 Az EMM az Expanded Memory Manager, a bvtett memria kezelje. Az EMM-t
alapveten a 67h-es megszaktssal lehet elrni, a regiszterekbe kell a
megfelel rtkeket tlteni, majd INT 76h. A visszaadott rtkek is a
regiszterekben lesznek. Az EMM llapotkd mutatja meg, hogy volt-e valami
hiba. Ha 0, akkor minden rendben ment.

 De mg mieltt rtrnnk a funkcik rszletezsre, nzznk meg 1-2 dolgot.
Ha lefoglalunk egy EMS memriarszt, akkor kapunk egy szmot, amivel majd
hivatkozhatunk r. Ez a szm a handle, a kezelszm. Egy handle-hez tartozik
annyi darab lap (16K) amennyit foglalsnl krtnk. A mapping (nlunk lapozs)
az, ami megadja, hogy a fizikai lapok melyikben mi -- azaz melyik handle
melyik lapja -- legyen.

1 lap = 16 Kbyte memria.

 EMS keret,
 norml memriban
 Ŀ          Ŀ         Ŀ
  3.lap  16Kb            E xpanded                                    
 Ĵ           M emory             Expanded Memory          
  2.lap  16Kb <ĳ M anager >ĳ  logikai lapok            
 Ĵ                                Ŀ   
  1.lap  16Kb                                 handle > lap 0       
 Ĵ                                            lap 1       
  0.lap  16Kb                                               ...       
                                             lap (n-1)   
   ^^^^^- Ezek a fizikai                                       .
   lapok az EMS keretben                       .


Ŀ
 Az EMS/EMM jelenltnek vizsglata  Az EMS memrit egy eszkzmeghajt
 vezrli, aminek az eszkzneve
 "EMMXXXX0" s ez az EMM. Az egyszerbb megolds annyi, hogy megnzzk, hogy
 a 67h-s megszaktsvektor hova mutat, s ennek a szegmensnek a cmhez
 10-et adunk, s megnzzk, hogy "EMMXXXX0" van-e itt. Ha nem, akkor nincs
 jelen EMM.

Az EMM alap funkcii:

 AX    Megjegyzs
  
 4000H EMM llapotnak lekrdezse
 4100H A keret szegmenscmnek lekrdezse
 4200H Az sszes/szabad memriamret lekrdezse
 4300H Memriafoglals -- handle megnyitsa/lapok alloklsa
 4400H EMS memria belapozsa fizikai cmre (az EMS keretbe) /Map memory/
 4500H Memria felszabadtsa -- handle bezrsa/lapok felszabadtsa
 4600H Az EMM verziszmnak lekrdezse

Ŀ
AH=40H EMM llapotnak lekrdezse. Azutn hasznland, miutn meggyzdtnk
 az EMM jelenltrl.
        Visszaad: AH= EMM llapotkd --  0=minden rendben
Ŀ
AH=41H Az EMS keret fizikai cm szegmensnek lekrdezse (64K, ngy 16K-s
 egysgben)
        Visszaad: BX= cm szegmense (ha AH = 0)
                  AH= EMM llapotkd
Ŀ
AH=42H sszes/szabad EMS memria lekrdezse
 Visszaad: DX= sszesen ennyi EMS lap van a rendszerben (1 lap = 16K)
                  BX= jelenleg szabad EMS lapok szma
                  AH= EMM llapotkd
Ŀ
AH=43H Memriafoglals -- handle megnyitsa/lapok alloklsa
 Bemenet:  BX= a krt lapok szma
        Visszaad: DX= EMM handle (a tbbi funkcinl ez fog kelleni)
                  AH= EMM llapotkd
Ŀ
AH=44H EMS memria belapozsa fizikai cmre (az EMS keretbe)

        Bemenet:  AL= fizikai lap szma (0 - 3, az EMS keret ngy lapja kzl)
                  BX= logikai lap (0-tl (n-1)-ig, ahol n a handle-hez foglalt
                      lapok szma). 4.0-s EMS-nl, FFFFh rtk a keret mind a
                      ngy lapjt 'visszalapozza', gy senki sem fog tudni
                      rni/olvasni az EMS keretbe. Ezekutn jra be kell
                      lapozni valamit, hogy megint hozz lehessen frni.
                  DX= EMM handle
        Visszaad: AH= EMM llapotkd
Ŀ
AH=45H Memria felszabadtsa -- handle bezrsa/lapok felszabadtsa
 Bemenet:  DX= EMM handle
        Visszaad: AH= EMM llapotkd
Ŀ
AH=46H Az EMM verziszmnak lekrdezse
 Visszaad: AL= EMM verziszm, BCD(Binary Coded Decimal)-ben kdolt
                      (pl. AL=32H az EMM 3.2-es verzit jelenti)
                  AH= EMM llapotkd


                           Az EMM tovbbi funkcii
                           


 These EMS functions are used by applications which intend to:
   run as a TSR and must save/restore the EMM state
   use "named" EMM handles for inter-process communication
   execute code in expanded memory
   move blocks of data around

 AX    Megjegyzs
  
 4700H Lapozsi kontextus (belltsok) elmentse
 4800H Lapozsi kontextus visszatltse
 4b00H A handle lapjai szmnak a lekrdezse
 4c00H Az aktv handle-k szmnak lekrdezse
 4d00H Az sszes handle lapszmnak lekrdezse.
 4e--H Get/Set entire page map
 4f--H Get/Set partial page map              EMS 4.0
 5000H Map/Unmap multiple pages              EMS 4.0
 5100H Reallocate (resize) EMS Handle        EMS 4.0
 52--H Get/Set handle attribute              EMS 4.0
 53--H Get/Set handle name                   EMS 4.0
 54--H Find Named Handle                     EMS 4.0
 5500H Alter Page Map and Jump               EMS 4.0
 5600H Alter Page Map and Call               EMS 4.0
 57--H Move/Exchange Memory                  EMS 4.0
 58--H Get Mappable Physical Address Array   EMS 4.0

Ŀ
AH=47H Lapozsi kontextus (belltsok) elmentse. Az EMM el fogja menteni
 a jelenlegi lapozsi belltsokat, gyhogy egy TSR vagy device driver
        belapozhatja a sajt EMS memrijt, majd mieltt visszatrne,
        meg kell hvnia a visszatltst.
        Bemenet:  DX= EMM handle-je a krvnyez process-nek
        Visszaad: AH= EMM llapotkd
Ŀ
AH=48H  Lapozsi kontextus visszatltse, ugyanavval a handle-val hvand,
 mint a ments.
        Bemenet:  DX= EMM handle-je a krvnyez process-nek
        Visszaad: AH= EMM llapotkd

Ŀ
AH=4bH A handle lapjai szmnak a lekrdezse. Visszaadja, hogy az adott
 handle szmra mennyi lap van lefoglalva.
        Bemenet:  DX= EMM handle (egy process-nek tbb is lehet)
        Visszaad: BX= a hozz tartoz logikai (16K-s) lapok szma (1-255)
                  AH= EMM llapotkd
Ŀ
AH=4cH Az aktv handle-k szmnak lekrdezse. (A 4dH-s funkci hvsa
 eltt lehet hasznos)
        Visszaad: BX= az aktv handle-k szma
                  AH= EMM llapotkd
Ŀ
AH=4dH Az sszes handle lapszmnak lekrdezse. Egy tmbt ad vissza, ami
 tartalmazza, hogy melyik handle-hez mennyi lap tartozik.
        Bemenet:  ES:DI= tmb cme
        Visszaad: BX= az aktv EMM handle-k szma
                  ES:DI tmb, mely BX darab 2-word-el lesz tele. Az els
                        word a handle szma, a msodik a hozz tartoz lapok
                        szma
                  AH= EMM llapotkd
Ŀ
AH=4eH A lapozs belltsainak lekrse/megadsa. A mentsre val tmb
Get/Set entire page map.  This function is designed to support multi-
 tartalmazhat mindenfle hardverfgg informcit.
        tasking operating systems in order to more fully control EMS.  The
        mapping array can hold a variety of hardware-dependant information.
        Expects: AL= SubFn number
                     AL=0 Get all mapping registers into an array at ES:DI
                     AL=1 Set all mapping registers from array at DS:SI
                     AL=2 Get and set mapping regs (SubFns 0 and 1 combined)
                     AL=3 Query size of buffer needed for SubFns 0-2
        Returns: AL is size of mapping register buffer (from SubFn 3)
                 ES:DI buffer holds EMS mapping array (from SubFns 0 and 2)
                 AH= EMM Status

Ŀ
AH=4fH Get/Set partial page map (EMS 4.0).  This works like EMS Fn 4eH, but
 provides a way to save the mapping contents for selected pages, rather
        than all of them (thus saving time and memory).
        Expects: AL= SubFn number
                     AL=0 Get mapping registers identified in array at DS:SI
                          in into an array at ES:DI.
                          DS:SI => a series of 2-byte words.  The first word
                          is a count of the following words. The rest of the
                          array contains the physical segment values whose
                          mapping is to be saved.
                          ES:DI => a buffer to receive mapping info.  Use
                          SubFn 2 to obtain the required size of this buffer.
                     AL=1 Restore mapping. DS:SI => array saved via SubFn 0
                     AL=2 Query size of buffer needed for SubFn 0.
                          BX=count of physical pages (same as first word at
                          DS:SI in SubFn 0.
        Returns: AL contains size, in bytes, of mapping buffer (from SubFn 2)
                 Buffer at ES:DI holds EMS mapping array (from SubFn 0)
                 AH= EMM Status
Ŀ
AH=50H Map/Unmap multiple pages (EMS 4.0).  This lets you map or unmap (make
 inaccessible) multiple pages at once.
        Expects: AL= SubFn number
                     AL=0 map/unmap pages using page numbers.
                          DX=EMS handle, obtained via EMS Fn 43H
                          CX=count of 4-byte elements in array at DS:SI
                          DS:SI => a series of 2-word elements.  In each
                          element, the first word is a logical page number and
                          the second is a physical page number.  A logical
                          page number of ffffH unmaps the corresponding
                          physical page.
                     AL=1 Same as SubFn 0, but second word of each element is
                          a segment address (must be for a mappable segment).
        Returns: AH= EMM Status
Ŀ
AH=51H EMS handle ltal lefoglalt memriamret megvltoztatsa.  (EMS 4.0)
 Bemenet:  DX= EMS handle, amit a 43h-s funkci adott vissza (foglals)
                  BX= a krt j mret, logikai lapokban (16K)
        Visszaad: AH= EMM llapotkd
Ŀ
AH=52H Get/Set Handle attribute (EMS 4.0).  This currently lets you tag some
 pages as non-volatile, in the hope that the EMS board will be able to
        preserve the contents of that memory across a warm boot.
        Expects: AL= SubFn number
                     AL=0 Get handle attribute
                          DX=EMS handle, obtained via EMS Fn 43H
                     AL=1 Set Handle attribute
                          DX=EMS handle, obtained via EMS Fn 43H
                          BL=new attribute
                     AL=2 Query attribute capability
                          (returns AL=0 if not possible to make non-volatile)
        Returns: AL contains an attribute (for SubFn 0).  0 means board does
                 not support non-volatile attributes (all data lost upon
                 reboot).  1 means OK to tag as non-volatile.
                 AH= EMM Status
Ŀ
AH=53H Handle-hez rendelt nv lekrdezse / belltsa. Ennek a segitsgvel
 tbb program megosztva hasznlhatja az EMS lapokat, tud hivatkozni r
        a 8 karakteres nvvel.
        Bemenet: AL= alfunkci szma:
                     AL=0 Handle-hez tartoz nv lekrdezse
                          DX=EMS handle, amit a foglals (43h-s funkci) adott
                          ES:DI => 8 byte-os tmb ahova a nv fog msoldni
                     AL=1 Handle-hez tartoz nv belltsa
                          DX=EMS handle, amit a foglals (43h-s funkci) adott
                          DS:SI => 8 byte-os tmb ami a nevet tartalmazza
        Visszaad: AH= EMM llapotkd
Ŀ
AH=54H Find Named Handle (EMS 4.0).  This lets applications work together,
 sharing EMS pages, as long as each app knows an 8-character name.
        Expects: AL= SubFn number
                     AL=0 Get handle directory
                          ES:DI => buffer to hold an array of 10-byte
                          elements.  The first word of each element will
                          receive an EMS handle and the next 8 bytes will
                          receive a handle name.
                     AL=1 Search for named handle
                          DS:SI => 8-byte array containing name to find.
                     AL=2 Count all open handles

        Returns: (AL=0) ES:DI buffer will contain data; AL=count of entries
                 (AL=1) DX will contain the handle (only if AH==0)
                 (AL=2) BX will contain the count of handles.  Buffer size
                        (AL=0) is BX * 10.
                 AH= EMM Status
Ŀ
AH=55H Lapozs megvltoztatsa s ugrs (EMS 4.0). Evvel be lehet lapozni
 nhny lapnyi kdot a memriba, s utna vgre lehet hajtani.
        Bemenet: AL= Alfunkci szma
                     AL=0 Use page numbers in physical page array
                          DX=EMS handle, obtained via EMS Fn 43H
                          DS:SI => a 9-byte mapAndJump structure. The first 4
                          bytes are the offset and segment to jump to.  The
                          next byte is the count of mapping elements.  The
                          final 4 bytes are the FAR address of an array of
                          4-byte mapping information elements:  In that array,
                          the first word of each element contains a logical
                          page number and the second word contain a physical
                          page number.
                     AL=1 Same as SubFn 0, but use segment values (instead of
                          physical page numbers) in the mapping info array
        Returns: AH= EMM Status (0 means control has been transferred)
Ŀ
AH=56H Alter Page Map and Call (EMS 4.0). This lets you swap some pages of
 executable code into memory, then execute that code via a FAR CALL.
        You also specify the mapping to restore when the call returns
        Expects: AL= SubFn number
                     AL=0 Use page numbers in physical page array
                          DX=EMS handle, obtained via EMS Fn 43H
                          DS:SI => a 22-byte mapAndCall structure. The first 9
                          bytes are as described in EMS Fn 55H.  These are
                          followed by another length byte and the address of
                          another logical-to-physical mapping array.  Fill
                          this array with the mapping you want upon return
                          from the call.  Finally, the structure contains 8
                          bytes of reserved space.
                     AL=1 Same as SubFn 0, but use segment values (instead of
                          physical page numbers) in both of the mapping info
                          arrays
                     AL=2 Get stack requirements for this Fn.
        Returns: (AL=2) BX=stack space required by SubFn 0 or 1. Use this to
                          adjust your stack frame upon return.
                 AH= EMM Status
Ŀ
AH=57H Move/Exchange Memory (EMS 4.0). Use this to transfer blocks of memory
 into, out of, or within EMS memory or conventional memory.  Segment
        overflow and overlapping moves are allowed; blocks as large as 1M are
        allowed.
        Expects: AL= SubFn number
                     AL=0 Move memory region
                          DS:SI => an 18-byte moveInfo structure:
                          Offset Size Description
                            0     4   Region length (size, in bytes of block)
                            4     1   Source RAM type: 0=conventional, 1=EMS
                            5     2   Source handle if source in EMS; else 0
                            7     2   Source offset (within seg or page)
                            9     2   Source segment or page
                            11    1   Destination RAM type: 0=convent., 1=EMS
                            12    2   Destination handle if in EMS; else 0
                            14    2   Destination offset (within seg or page)
                            16    2   Destination segment or page
                     AL=1 Exchange memory regions
                          DS:SI => an 18-byte moveInfo structure as above.
                 AH= EMM Status (note: 92H is not an error).
Ŀ
AH=58H Get Mappable Physical Address Array (EMS 4.0).  This obtains a cross-
 reference between all EMS page numbers and the segments at which they
        are physically located.
        Expects: AL= SubFn number
                     AL=0 Get segment-to-page map array
                          ES:DI => buffer to hold an array of 4-byte elements.
                          The first word of each element will receive a
                          segment value and the next word will receive an EMS
                          physical page number.
                     AL=1 Count segment-to-page array entries
        Returns: CX=number of elements in the page-to-segment array.  The
                    size of the buffer needed in SubFn 0 is CX * 4.
                 AH= EMM Status


                     EMM opercis rendszer szint funkcii
                     

 Ezeket a funkcikat csak opercis rendszerek vagy multitaszkerek hasznljk,
 ezrt nem rszletezem ket. Ha mgis rdekel, akkor tbb helyen utna lehet
 nzni, pl. a Tech Help-ben.




                                  EMM llapotkd
                                  

 Az INT 67h utn AH regiszter fogja tartalmazni a sttusz/hiba kdjt.

        Status  Jelents
          
           0    nincs hiba, minden rendben
          80H   EMM szoftver hiba
          81H   EMS hardver hiba
          82H   EMM ppen foglalt (busy)
          83H   Az EMM nem tart nyilvn ilyen kezelszmot
          84H   Nincs ilyen EMM funkci
          85H   Minden EMM kezelszm foglalt
          86H   Mentsi/visszatltsi hiba
          87H   Nincs elg EMS lap -- a maximlisnl is tbbet akart foglalni
          88H   Nincs elg szabad EMS lap
          89H   0 lapot nem lehet alloklni
          8aH   A handle-hez nem tartozik ennyi lap
          8bH   Illeglis belapozs.  Csak 0-3-ig lehet a fizikai lap szma
          8cH   Hardver mentsi terlet betelt
          8dH   Hardver mentsi terlet foglalt -- handle-nknt csak egyszer
                lehet ilyet menteni
          8eH   Elments nlkl nem lehet visszatlteni a hardver kontextust
          8fH   Nincs ilyen EMM alfunkci (AL rossz)

                (EMS 4.0-tl az j hibakdok)
          90H   attribute type undefined
          91H   non-volatility not supported
          92H   source and dest overlap in EMS RAM (warning, not error)
          93H   destination area in handle too small
          94H   conventional memory overlaps EMS RAM
          95H   offset too large in block move
          96H   block size too large; ie, > 1M
          97H   source and dest are in same handle and overlap
          98H   source or dest memory type invalid (in offset 4 of packet)
          9aH   alternate map register set in not supported
          9bH   all alternate map/DMA register sets are all allocated
          9cH   all alternate map/DMA register sets are not supported
          9dH   specified alternate map/DMA register set invalid or in use
          9eH   dedicated DMA channels are not supported
          9fH   specified DMA channel is not supported
          a0H   no handle matches specified name
          a1H   the specified name already exists
          a2H   source offset+region length > 1M (attempted to wrap)
          a3H   contents of specified data packet are corrupted or invalid
          a4H   access to this function has been denied (bad access key)



 Forrs: Tech Help 4.0
 Translation by John Zer -- sorry for the quality (& quantity)...
 Ja, bocs, hogy flig van csak lefordtva, de most mr nagyon ks van (04h) 
s kedvem iz shit ;)
