home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / HDPSTACK.LZH / HDPSTACK.MSA / HDPSTACK / SOURCE / XHDI.D < prev    next >
Text File  |  1995-03-06  |  18KB  |  447 lines
  1. DEFINITION MODULE XHDI;
  2.  
  3. (*  XHDI-Bindings für Megamax-Modula2,
  4.  *  angepasst von Frank Storm @ AC2. Die Beschreibungen sind dem
  5.  *  Text XHDISPEC.TXT entnommen und leicht modifiziert.
  6.  *
  7.  *  letzte Änderung: 12.11.1994
  8.  *)
  9.  
  10. FROM  BIOS                 IMPORT  RW, BPB, DriveSet;
  11. FROM  SYSTEM               IMPORT  ADDRESS;
  12.  
  13.  
  14. CONST
  15.        (* siehe XHInqTarget *)
  16.        XHTargetStoppable =  0;
  17.        XHTargetRemovable =  1;
  18.        XHTargetLockable  =  2;
  19.        XHTargetEjectable =  3;
  20.        XHTargetLocked    = 29;
  21.        XHTargetStopped   = 30;
  22.        XHTargetReserved  = 31;
  23.  
  24.        XHMiSetKerInfo = 0;
  25.        XHMiGetKerInfo = 1;
  26.  
  27.        XHDLsecsiz = 0;
  28.        XHDLminfat = 1;
  29.        XHDLmaxfat = 2;
  30.        XHDLminspc = 3;
  31.        XHDLmaxspc = 4;
  32.        XHDLclustc = 5;
  33.        XHDLmaxsec = 6;
  34.        XHDLdrives = 7;
  35.  
  36. TYPE   DeviceFlagSet = SET OF [0..31];
  37.  
  38.  
  39. (* Diese Variable enthält den Return-Code eines XHDI-Aufrufs.
  40.  *)
  41. VAR XHDIResult: LONGINT;
  42.  
  43.  
  44. PROCEDURE XHGetVersion (): CARDINAL;
  45.  
  46. (* Liefert die Protokollversion zurück. Formatbeispiel: $0119 ist Version 
  47.  * 1.19 (identisch mit GEMDOS-Sversion(), nur sind die beiden Bytes NICHT 
  48.  * verdreht). Diese Version der XHDI-Spezifikation hat die Versionsnummer 
  49.  * $0125.
  50.  *)
  51.  
  52.  
  53. PROCEDURE XHInqTarget (major, minor: CARDINAL;
  54.                        VAR blockSize: LONGCARD;
  55.                        VAR deviceFlags: DeviceFlagSet;
  56.                        VAR productName: ARRAY OF CHAR);
  57.  
  58. (* Liefert Informationen über das durch `major' und `minor' spezifizierte 
  59.  * Gerät (in `deviceFlags': ein Attributvektor, in `productName': 
  60.  * optional die Produktbezeichnung des Geräts). Mit `XHReserve ()' 
  61.  * vorgenommene Reservierungen werden dabei berücksichtigt.
  62.  *
  63.  * blockSize:   Blockgrö₧e auf dem Gerät (für `XHReadWrite()' sehr wichtig).
  64.  *              Normalerweise 512.
  65.  * 
  66.  * deviceFlags: (Bit gesetzt -> Fähigkeit verfügbar):
  67.  *
  68.  *     Bit 0:  Gerät kann gestoppt werden (XHTargetStoppable)
  69.  *     Bit 1:  Gerät hat wechselbare Medien (XHTargetRemovable)
  70.  *     Bit 2:  Auswurf des Geräts kann verriegelt werden
  71.  *             (XHTargetLockable)
  72.  *     Bit 3:  Medium kann per Kommando ausgeworfen werden
  73.  *             (XHTargetEjectable)
  74.  *     Bit 29: Auswurf des Geräts ist vom Treiber blockiert worden 
  75.  *             (XHTargetLocked, ab XHDI 1.25).
  76.  *     Bit 30: Gerät ist vom Treiber gestoppt worden (XHTargetStopped, 
  77.  *             ab XHDI 1.25).
  78.  *     Bit 31: Gerät ist zur Zeit blockiert (XHTargetReserved).
  79.  *
  80.  *             Alle weiteren Bits sind reserviert und sollten vom Treiber
  81.  *             auf Null gesetzt werden.
  82.  * 
  83.  * productName: Produktbezeichnung des Geräts (max. 33 Zeichen inkl.
  84.  *              eine Zeichenkette der Länge Null zurückgeliefert.
  85.  *
  86.  * Anmerkung: für IDE-Geräte wird bei `productName' gegebenenfalls auf 32 
  87.  * Zeichen gekürzt. Siehe auch die neue Funktion `XHInqTarget2'.
  88.  *)
  89.  
  90.  
  91. PROCEDURE XHReserve (major, minor: CARDINAL; doReserve: BOOLEAN;
  92.                      VAR key: CARDINAL);
  93.  
  94. (* Reserviert ein Gerät bzw. gibt es wieder frei. Auf reservierte Geräte 
  95.  * kann nur bei Angabe des korrekten Schlüssels per `XHLock()', `XHStop()' 
  96.  * oder `XHEject()' zugegriffen werden.
  97.  *
  98.  * Sinn: man möchte nicht, da₧ man eine Wechselplatte per CPX-Modul 
  99.  * entriegeln kann, nachdem sie gerade von einer virtuellen 
  100.  * Speicherverwaltung verriegelt worden ist. Dies sollte nur die 
  101.  * Speicherverwaltung selbst machen können.
  102.  *
  103.  * Beim Reservieren des Geräts wird im Erfolgsfall ein 16-Bit-Schlüssel 
  104.  * zurückgeliefert. Dieser Schlüssel mu₧ bei allen weiteren Zugriffen auf 
  105.  * das Gerät angegeben sowie beim Wieder-Freigeben angegeben werden.
  106.  *
  107.  * doReserve:  TRUE Reservieren oder FALSE wieder freigeben.
  108.  * key:        (nur beim Freigeben benutzt).
  109.  *)
  110.  
  111.  
  112. PROCEDURE XHLock (major, minor: CARDINAL; doLock: BOOLEAN;
  113.                   key: CARDINAL);
  114.  
  115. (* Verriegelt bzw. entriegelt den Auswurfknopf eines Geräts. Der Treiber 
  116.  * hat sich darum zu kümmern, ob dieser Befehl an das Gerät weitergeleitet 
  117.  * wird oder nicht (falls das Medium nicht verriegelbar ist).
  118.  *
  119.  * Welchen Code man im Fehlerfall zurückerhält, ist undefiniert. Mehr 
  120.  * Informationen werden allerdings auch nicht benötigt, da man ja mit 
  121.  * `XHInqTarget()' vorher gezielt auf diese Fähigkeit abtesten kann.
  122.  * 
  123.  * doLock: TRUE Verriegeln oder FALSE Entriegeln.
  124.  * key:     Falls Gerät reserviert, sonst Null übergeben.
  125.  *)
  126.  
  127.  
  128. PROCEDURE XHStop (major, minor: CARDINAL; doStop: BOOLEAN;
  129.                   key: CARDINAL);
  130.  
  131. (* Gerät wird gestoppt (geparkt) bzw. gestartet (entparkt).
  132.  *
  133.  * Welchen Code man im Fehlerfall zurückerhält, ist undefiniert. Mehr 
  134.  * Informationen werden allerdings auch nicht benötigt, da man ja mit 
  135.  * `XHInqTarget()' vorher gezielt auf diese Fähigkeit abtesten kann.
  136.  *
  137.  * doStop: TRUE Stoppen oder FALSE Starten.
  138.  * key:    Falls Gerät reserviert, sonst Null übergeben.
  139.  *
  140.  * Anmerkung: Bei etwaigen Zugriffen auf das gestoppte Gerät sollte der 
  141.  * Treiber selbst für das Wiederhochfahren sorgen.
  142.  *)
  143.  
  144.  
  145. PROCEDURE XHEject (major, minor: CARDINAL; doEject: BOOLEAN;
  146.                    key: CARDINAL);
  147.  
  148. (* Medium wird ausgeworfen oder eingezogen.
  149.  *
  150.  * Welchen Code man im Fehlerfall zurückerhält, ist undefiniert. Mehr 
  151.  * Informationen werden allerdings auch nicht benötigt, da man ja mit 
  152.  * `XHInqTarget()' vorher gezielt auf diese Fähigkeit abtesten kann.
  153.  *
  154.  * doEject:  Medium auswerfen (TRUE) oder einziehen (FALSE).
  155.  * key:      Falls Gerät reserviert, sonst Null übergeben.
  156.  *)
  157.  
  158.  
  159. PROCEDURE XHDrvMap (): DriveSet;
  160.  
  161. (* Liefert einen Bitvektor mit den über das XHDI-Protokoll unterstützten 
  162.  * BIOS-Gerätenummern (wie etwa bei `Drvmap()').
  163.  *)
  164.  
  165.  
  166. PROCEDURE XHInqDev (dev: CARDINAL; VAR major, minor: CARDINAL;
  167.                     VAR startSector: LONGCARD; VAR bpb: BPB);
  168.  
  169. (* Liefert Major Device Number, Minor Device Number, Startsektor und BPB 
  170.  * eines BIOS-Geräts (im Gegensatz zu `Getbpb()' wird dadurch der Media-
  171.  * Change-Status des Geräts NICHT zurückgesetzt).
  172.  *
  173.  * Anmerkung: es wird ein Zeiger auf eine vom Aufrufer bereitgestellte BPB-
  174.  * Struktur übergeben, die vom XHDI-Treiber gefüllt wird.
  175.  *
  176.  * Return-Wert: OK, EDRVNR (Gerät kann zur Zeit nicht angesprochen werden, 
  177.  * zum Beispiel Medium nicht eingelegt), EDRIVE (falsche Gerätenummer) oder 
  178.  * eine andere Fehlernummer. Bei EDRVNR darf man sich darauf verlassen, da₧ 
  179.  * `major' und `minor' korrekt zurückgeliefert werden.
  180.  *
  181.  * Ein `start_sector' mit Wert $FFFFFFFF soll auf eine Partition hinweisen, 
  182.  * die zur Zeit vom Treiber nicht bedient wird (zum Beispiel, wenn ein 
  183.  * Wechselmedium mit 'zu wenig' Partitionen eingelegt ist).
  184.  *
  185.  * Der zurückgelieferte BPB ist ungültig, wenn das Element `recsiz' Null ist.
  186.  *
  187.  * Hinweis: ein Dateisystem ist durch major- und minor-Gerätenummer sowie 
  188.  * Startsektor (mit der obigen Einschränkung) exakt spezifiziert. Über die 
  189.  * Art des Dateisystems (FAT oder etwas anderes) ist damit nichts ausgesagt!
  190.  *
  191.  * Anmerkung: für `major', `minor', `start_sector' und `bpb' dürfen auch 
  192.  * Nullzeiger übergeben werden.
  193.  *)
  194.  
  195.  
  196. PROCEDURE XHInqDriver (dev: CARDINAL; VAR name, version, company: ARRAY OF CHAR;
  197.                        VAR AHDIVersion, maxIPL: CARDINAL);
  198.  
  199. (* Liefert Informationen über den Treiber, der das angegebene Gerät bedient.
  200.  *
  201.  * name:         Zeiger auf Zeichenkette mit Treibernamen (max. 17 Zeichen).
  202.  * version:      Zeiger auf Zeichenkette mit Versionsnummer (max. 7 Zeichen).
  203.  * company:      Zeiger auf Zeichenkette mit Namen des Herstellers (max. 17
  204.  *               Zeichen).
  205.  * AHDIVersion:  AHDI-Versionslevel (wie PUN_INFO-Struktur).
  206.  * maxIPL:       Höchster IPL, unter dem der Treiber für das angegebene Gerät
  207.  *               arbeitsfähig ist (Normalwert für Treiber, die ihr Timing per
  208.  *               _hz_200 erledigen: 5).
  209.  *)
  210.  
  211.  
  212. PROCEDURE XHNewCookie (newCookie: ADDRESS);
  213.  
  214. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  215.  *
  216.  * Installiert einen zusätzlichen XHDI-Handler (Vorteil: der XHDI-Cookie 
  217.  * zeigt nach wie vor auf die gleiche Adresse). Wer diese Funktion 
  218.  * unterstützt mu₧ also folgendes tun:
  219.  *
  220.  * 1. Falls dies der erste Aufruf dieser Art ist: anschlie₧end so vorgehen,
  221.  *    als hätte der XHDI-Cookie bei der Installation bereits auf `newCookie'
  222.  *    gezeigt.
  223.  *
  224.  * 2. Falls nicht: Funktion an 'nächsten' Handler weiterleiten.
  225.  *
  226.  * Wer eine Mehrfachinstallation vornehmen möchte, sollte so vorgehen:
  227.  * 
  228.  * 1. Testen, ob `XHNewCookie()' zum Erfolg führt.
  229.  *
  230.  * 2. Anderenfalls den Cookie `per Hand' versetzen.
  231.  *)
  232.  
  233.  
  234. PROCEDURE XHReadWrite (major, minor: CARDINAL; rw: RW;
  235.                        recno: LONGCARD; count: CARDINAL; buf: ADDRESS);
  236.  
  237. (* Äquivalent zur BIOS-Funktion `RWAbs()' zum Lesen bzw. Schreiben 
  238.  * physikalischer Blocknummern.
  239.  *
  240.  * rw:        Art der Lese-/Schreiboperation
  241.  * recno:     Sektornummer
  242.  * count:     Anzahl der Blöcke
  243.  * buf:       Zeiger auf Puffer.
  244.  *)
  245.  
  246.  
  247. PROCEDURE XHInqTarget2 (major, minor: CARDINAL;
  248.                         VAR blockSize: LONGCARD;
  249.                         VAR deviceFlags: DeviceFlagSet;
  250.                         VAR productName: ARRAY OF CHAR);
  251.  
  252. (* - AB XHDI-Version 1.01 -
  253.  *
  254.  * Liefert Informationen über das durch `major' und `minor' spezifizierte 
  255.  * Gerät (in `device_flags': ein Attributvektor, in `product_name': 
  256.  * optional die Produktbezeichnung des Geräts). Mit `XHReserve ()' 
  257.  * vorgenommene Reservierungen werden dabei berücksichtigt.
  258.  *
  259.  * block_size:   Blockgrö₧e auf dem Gerät (für `XHReadWrite()' sehr wichtig).
  260.  *               Normalerweise 512.
  261.  *
  262.  * device_flags: (Bit gesetzt -> Fähigkeit verfügbar):
  263.  *
  264.  *     Bit 0:  Gerät kann gestoppt werden (XHTargetStoppable)
  265.  *     Bit 1:  Gerät hat wechselbare Medien (XHTargetRemovable)
  266.  *     Bit 2:  Auswurf des Geräts kann verriegelt werden
  267.  *             (XHTargetLockable)
  268.  *     Bit 3:  Medium kann per Kommando ausgeworfen werden
  269.  *             (XHTargetEjectable)
  270.  *     Bit 29: Auswurf des Geräts ist vom Treiber blockiert worden 
  271.  *             (XHTargetLocked, ab XHDI 1.25)
  272.  *     Bit 30: Gerät ist vom Treiber gestoppt worden (XHTargetStopped, 
  273.  *             ab XHDI 1.25)
  274.  *     Bit 31: Geräte ist zur Zeit blockiert (XHTargetReserved)
  275.  *
  276.  *             Alle weiteren Bits sind reserviert und sollten vom Treiber
  277.  *             auf Null gesetzt werden.
  278.  *
  279.  * product_name: Produktbezeichnung des Geräts (max. `stringlen' Zeichen inkl.
  280.  *               Leerzeichen). Falls die Information nicht verfügbar ist, wird
  281.  *               eine Zeichenkette der Länge Null zurückgeliefert.
  282.  *
  283.  * Anmerkung: für `blocksize', `device_flags' und `product_name' dürfen 
  284.  * auch Nullzeiger übergeben werden. Produktbezeichnungen von IDE-Geräten 
  285.  * können bis zu 40 Zeichen lang sein.
  286.  *)
  287.  
  288.  
  289. PROCEDURE XHInqDev2 (dev: CARDINAL; VAR major, minor: CARDINAL;
  290.                      VAR startSector: LONGCARD; VAR bpb: BPB;
  291.                      VAR blocks: LONGCARD; VAR partid: ARRAY OF CHAR);
  292.  
  293. (* - AB XHDI-Version 1.10 -
  294.  *
  295.  * Liefert Major Device Number, Minor Device Number, Startsektor, BPB (im 
  296.  * Gegensatz zu `Getbpb()' wird dadurch der Media-Change-Status des Geräts 
  297.  * NICHT zurückgesetzt), Länge und Partitionkennung (maximal drei Zeichen 
  298.  * zzgl. terminierender Null) eines BIOS-Geräts.
  299.  *
  300.  * Anmerkung: es wird ein Zeiger auf eine vom Aufrufer bereitgestelle 
  301.  * BPB-Struktur übergeben, die vom XHDI-Treiber gefüllt wird.
  302.  *
  303.  * Return-Wert: OK, EDRVNR (Gerät kann zur Zeit nicht angesprochen werden, 
  304.  * zum Beispiel Medium nicht eingelegt), EDRIVE (falsche Gerätenummer) oder 
  305.  * eine andere Fehlernummer. Bei EDRVNR darf man sich darauf verlassen, da₧ 
  306.  * `major' und `minor' korrekt zurückgeliefert werden.
  307.  *
  308.  * Ein `start_sector' mit Wert $FFFFFFFF soll auf eine Partition hinweisen, 
  309.  * die zur Zeit vom Treiber nicht bedient wird (zum Beispiel, wenn ein 
  310.  * Wechselmedium mit 'zu wenig' Partitionen eingelegt ist).
  311.  *
  312.  * Der zurückgelieferte BPB ist ungültig, wenn das Element `recsiz' Null ist.
  313.  *
  314.  * Wenn die Partitionkennung nicht verfügbar ist (keine Atari-Partitionierung 
  315.  * oder überhaupt keine Partitionierung, beispielsweise bei normal 
  316.  * formatierten Disketten in SCSI-Diskettenlaufwerken), wird als 
  317.  * Partitionkennung eine leere Zeichenkette zurückgegeben.
  318.  *
  319.  * Bei MSDOS-kompatibel partitionierten Medien wird ab XHDI-Version 1.20 die 
  320.  * ein Byte lange Partitionkennung wie folgt in `partid' abgelegt: partid[0] 
  321.  * = '\0' (Nullbyte), partid[1] = 'D' (für DOS), partid[2] = Kennung.
  322.  *
  323.  * Hinweis: ein Dateisystem ist durch major- und minor-Gerätenummer sowie 
  324.  * Startsektor (mit der obigen Einschränkung) exakt spezifiziert. Über die 
  325.  * Art des Dateisystems (FAT oder etwas anderes) ist damit nichts ausgesagt!
  326.  *
  327.  * Anmerkung: für `major', `minor', `start_sector', `bpb', `blocks' und 
  328.  * `partid' dürfen auch Nullzeiger übergeben werden.
  329.  *)
  330.  
  331.  
  332. PROCEDURE XHDriverSpecial (key1, key2: LONGCARD; subOpcode: CARDINAL;
  333.                            data: ADDRESS);
  334.  
  335. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  336.  *
  337.  * Dieser Opcode kann für treiberspezifische Erweiterungen benutzt werden. 
  338.  * Auf welche Art und Weise die Daten in `subopcode' und `data' interpretiert 
  339.  * werden, hängt ausschlie₧lich vom betroffenen Treiber ab. `key1' und `key2' 
  340.  * dienen zur Identifikation des anzusprechenden Treibers: `key1' sollte 
  341.  * dabei aus vier druckbaren ASCII-Zeichen bestehen, `key2' aus einem 
  342.  * möglichst willkürlich gewählten Long-Wert (etwa dem Datum der 
  343.  * Definition im BCD-Format).
  344.  *)
  345.  
  346.  
  347. PROCEDURE XHGetCapacity (major, minor: CARDINAL; VAR blocks: LONGCARD;
  348.                          VAR blockSize: LONGCARD);
  349.  
  350. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  351.  *
  352.  * Diese Funktion liefert in `blocks' die Anzahl der adressierbaren Sektoren 
  353.  * auf dem Medium und in `blockSize' ihre Grö₧e zurück (Vorsicht: je nach 
  354.  * verwendeter Hardware kann die Ausführung dieser Funktion mehrere Sekunden 
  355.  * dauern!).
  356.  *)
  357.  
  358.  
  359. PROCEDURE XHMediumChanged (major, minor: CARDINAL): BOOLEAN;
  360.  
  361. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  362.  *
  363.  * Informiert den Treiber darüber, da₧ das Medium in dem angegebenen Gerät 
  364.  * gewechselt worden ist. Der Treiber sollte daraufhin so vorgehen, als habe 
  365.  * das Gerät selbst einen Medienwechsel gemeldet. OK wird nur dann 
  366.  * zurückgeliefert, wenn die Information richtig verarbeitet wurde (also alle 
  367.  * logischen Laufwerke auf dem Gerät entweder deaktiviert sind oder benutzt 
  368.  * werden können).
  369.  *)
  370.  
  371.  
  372. PROCEDURE XHMiNTInfo (opcode: CARDINAL; data: ADDRESS);
  373.  
  374. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  375.  *
  376.  * Eine Funktion zum Setzen bzw. zur Abfrage MiNT-spezifischer Informationen.
  377.  *
  378.  * Folgende Opcodes sind definiert (unbekannte Opcodes werden mit EINVFN 
  379.  * quittiert, OK wird genau dann zurückgeliefert, wenn die verlangte 
  380.  * Funktion korrekt ausgeführt werden konnte):
  381.  *
  382.  * XHMiSetKerInfo (0) 
  383.  *
  384.  * Übermittelt in `data' dem Treiber einen Zeiger auf die 
  385.  * MiNT-Kernel-Info-Struktur. Der Treiber kann diese benutzen, um 
  386.  * beispielsweise direkt Kernelfunktionen aufzurufen.
  387.  *
  388.  * XHMiGetKerInfo (1)
  389.  *
  390.  * Erfragt beim Treiber die eventuell schon bekannte Adresse der 
  391.  * MiNT-Kernel-Info-Struktur. Der Zeiger auf die Struktur wird in die in 
  392.  * `data' angegebene Adresse geschrieben (wenn kein Treiber bekannt ist, wird 
  393.  * ein Nullzeiger zurückgeliefert).
  394.  *)
  395.  
  396.  
  397. PROCEDURE XHDOSLimits (which: CARDINAL; limit: LONGCARD);
  398.  
  399. (* - OPTIONALE Funktion, darf also mit EINVFN beantwortet werden -
  400.  *
  401.  * Diese Funktion erfragt beim Treiber die interne Limits des laufenden DOS 
  402.  * bzw. setzt sie. Sie kann zum Beispiel von einem FAT-Dateisystemtreiber 
  403.  * benutzt werden, um den Harddisk-Treiber mitzuteilen, da₧ sich einige 
  404.  * Limits geändert haben. `which' gibt an, welches Limit erfragt wird, 
  405.  * `limit' gibt den neuen Wert an (Null steht für: nicht ändern). Ergebnis 
  406.  * ist der bisherige Wert für das Limit.
  407.  *
  408.  * Konstanten für `which':
  409.  *
  410.  * XHDLsecsiz (0): maximale Sektorgrö₧e auf BIOS-Ebene
  411.  * XHDLminfat (1): minimale Anzahl von FATs
  412.  * XHDLmaxfat (2): maximale Anzahl von FATs
  413.  * XHDLminspc (3): Sektoren/Cluster minimal
  414.  * XHDLmaxspc (4): Sektoren/Cluster maximal
  415.  * XHDLclustc (5): maximale Clusterzahl
  416.  * XHDLmaxsec (6): maximale Zahl von Sektoren
  417.  * XHDLdrives (7): maximale Zahl der vom DOS unterstützen BIOS-Laufwerke
  418.  *)
  419.  
  420.  
  421. PROCEDURE XHLastAccess (major, minor: CARDINAL; VAR ms: LONGCARD);
  422.  
  423. (* - AB XHDI-Version 1.25 -
  424.  *
  425.  * Liefert in `ms' zurück, wieviele Millisekunden seit dem letzten 
  426.  * erfolgreichen Lese- oder Schreibzugriff auf das Gerät vergangen sind.
  427.  *)
  428.  
  429.  
  430. PROCEDURE XHReaccess (major, minor: CARDINAL);
  431.  
  432. (* - AB XHDI-Version 1.25 -
  433.  *
  434.  * Ein Aufruf dieser Funktion veranla₧t den Treiber, das angegebene Gerät auf 
  435.  * einen Mediachange zu überprüfen und gegebenenfalls die 
  436.  * Partitioninformationen entsprechend zu aktualisieren (wie 
  437.  * `XHMediumChanged()', nur da₧ der Treiber selbst das Gerät befragt, ob ein 
  438.  * Medienwechsel stattgefunden hat).
  439.  *)
  440.  
  441.  
  442. PROCEDURE XHMakeName (major, minor: CARDINAL; startSector: LONGCARD;
  443.                       VAR name: ARRAY OF CHAR);
  444.  
  445. END XHDI.
  446.  
  447.