Programm für PC ohne Betriebssystem

zu IBM-kompatiblen Zeiten gabs die Interrupt-Steuerung der Hardware 
durch den Prozessor. Einfach mal unter 80x86-Assembler schaun.

Im Real Mode heißt das Zauberwort "BIOS Interrupts".

Ich hab schon eine Firmware für einen ARM9 geschrieben, die ohne 
Bootloader o.ä. läuft und deshalb alles initialisieren muss, also auch 
die MMU, Cache, SDRAM Controller und so weiter. Das ist schon ziemlich 
kompliziert. Beim PC ist das nicht einfacher. Wenn du zumindest einen 
Bootloader wie U-Boot verwendest, dann ist es machbar. Die Tastatur und 
die rudimentären Funktionen der Grafikkarte usw. kannst du über das Bios 
ansprechen. Wenn ich mich richtig erinnere, geht das über einen 
Softwareinterrupt:

http://www.tu-chemnitz.de/informatik/RA/news/stack/kompendium/vortraege_96/BIOS/appendix.html

GRUB sollte doch eigentlich Open-Source sein, d.h. du könntest da mal 
einen Blick riskieren.
Immerhin bietet der Bootloader fast alle möglichen Funktionen, sogar mit 
Zugriff auf die Festplatte.

Alternative: Es gibt von Asus (?) einige Boards, die ein kleines Linux 
inkl. Firefox direkt im BIOS haben.
Evtl. lässt sich das anpassen, oder hat sogar alle gewünschten 
Funktionen.
Vielleicht lässt sich auch die Startseite vom Firefox fest setzen, dann 
könntest du deine Funktionen über ein Webinterface umsetzen.
Ich weiß nicht, ob und was man in diesem Linux überhaupt 
speichern/ändern kann.

Sogar gefunden: http://expressgate.asus.com/

Hallo Alle,

vielen Dank für eure Antworten.
Was mich im ersten Schritt interessieren würde, ist ein Hallo Welt mit 
zusätzlicher Funktion, dass man die Tastatureingaben sieht. Das Bios des 
Rechners darf ruhig verwendet werden, ich das Bios zu umgehen ist 
sowieso nicht möglich. Die Frage wäre auch welche "Developement Chain" 
und deren Setup man braucht und wie man das Ganze in ein Image 
verwandelt.

Gruß,
Markus

Soll das aus einem Flashspeicher laufen oder von Diskette?

Generell empfiehlt sich ein 8086-Assembler. So etwas gibt es meist als 
DOS-Programm. Die davon erzeugte .COM-Datei sollte eigentlich ohne 
Betriebssystem geladen werden können - ob man sie allerdings direkt in 
den Bootsektor einer Diskette oder einen EEPROM auf einer entsprechenden 
Karte schreiben kann, kann ich nicht versprechen.

Allerdings muß es nicht zwangsläufig Assembler sein. Es sind schon 
Bootmanager in Pascal geschrieben worden, und die laufen auch ohne 
aktives Betriebssystem. Natürlich darf man dann keine Unit DOS 
verwenden...

Übrigens: Die Tastatur kann auch über einen Portzugriff abgefragt 
werden, und man kann auch ohne BIOS in den Bildschirmspeicher schreiben. 
Schon mal "PC Intern" gelesen?

Markus schrieb:
> Was mich im ersten Schritt interessieren würde, ist ein Hallo Welt mit
> zusätzlicher Funktion, dass man die Tastatureingaben sieht.

Vielleicht solltest du erstmal erklären, was das eigentliche Ziel ist. 
Also warum muß es unbedingt ohne Betriebssystem sein? Was soll der 
Rechner nachher alles können (im Bezug auf Hardwarezugriff)?

> Die Frage wäre auch welche "Developement Chain" und deren Setup man
> braucht und wie man das Ganze in ein Image verwandelt.

Da bieten sich doch Bootloader wie grub hervorragend als Vorlage an, 
weil im Quellcode vorhanden und mit Beschreibung, wie man es übersetzt.

Sebastian schrieb:
> Übrigens: Die Tastatur kann auch über einen Portzugriff abgefragt
> werden,

Wobei da der Aufwand im Fall der heute üblichen USB-Tastaturen recht 
groß sein dürfte.

Hallo,

habe hier ein Tutorial gefunden:
http://www.cybton.com/tutorials_show,Ein+eigenes+Betriebssystem+programmieren+_+Theorie%2BBootloader,0,tut,738.html

Gruß Roland

>habe hier ein Tutorial gefunden:
>http://www.cybton.com/tutorials_show,Ein+eigenes+B...

Nicht schlecht, nur die Demo-Files lassen sich nicht mehr herunterladen.

>Das BIOS sucht nach einem Bootfähigen Laufwerk...
>womit willst du booten?

Am besten wäre, vom USB-Stick. Da es  mir aber in erster Linie um 
Einfachheit geht, nehme ich an dass es von einer 3.5Zoll Diskette oder 
der Festplatte einfacher ist. Vielleicht ist ja ein CD-Rom ebenfalls 
noch einfach zu handhaben.

>Welche Arten von Laufwerken unterstützt dein BIOS ?
Egal, das Programm sollte auf jedem Rechner laufen. Ich nehme mal an, 
dass es ein Bios Standard Subset gibt.
>Welche Anschlüsse sind vorhanden ?
Leider sind ja serielle Schnittstellen heute nicht mehr all zu weit 
verbreitet. Vielleicht sind diese aus Bios Sicht noch am einfachsten 
anzusprechen.

Stellen wir uns folgendes Szenario vor: Ein altes Motherboard soll als 
Visuallisierungsinterface für eine Mikrocontrollerboard dienen, dass 
z.B. als Datenlogger verwendet wird.

>Zum Programmieren gibts so einiges - ich habe für 16bit-DOS damals
>Watcom C/C++ benutzt, das gibts heute als Open Source.
>http://www.openwatcom.org/index.php/Main_Page

Heute gibt es den GCC. Ganz umsonst. Ideal wäre eine Lösung, bei der man 
einfach alles mit dem GCC ohne Assembler umsetzen könnte.

>Richtig.
>Nur ist dort die Runtime Lib von einem mitfühlenden Zeitgenossen schon
>angepasst worden :-)

Allerdings ist die Runtime Lib auch für den PC von führenden 
Zeitgenossen schon angepasst worden:

ftp://alpha.gnu.org/gnu/grub/grub-0.92.tar.gz

Es gibt das spiel "grub invaders", das ist ein game welches direkt aus 
grub ohne bs gestartet wird. Ist open source. Könnte man ja mal einen 
blick riskieren

>Es gibt das spiel "grub invaders"

http://www.erikyyy.de/invaders/

Hey, das sieht nicht schlecht aus. Da sind schon einige Funktionen für 
Graphik drinnen, die man vielleicht für ein eigenes Projekt benutzen 
kann.

Grub invaders scheint wirklich eine gute Grundlage für eine 
Betriebssystem lose Anwendung. Als kleinen Nachteil könnte man anführen, 
dass zum Start des Programms noch GRUB notwendig ist.

Einen GCC kann man als "bare metal crosscompiler" einrichten... da gibts 
einige schwerverdauliche Doku zu im Netz.

Wenn es hier um brutale Echtzeit geht: vergiss nicht dass ein modernes 
BIOS unsichtbar via SMM herumwerkelt um Emulationen (zB USB/SATA legacy 
support) und anderes bereitzustellen.

>Sieh dir das hier mal an:
>http://rayer.ic.cz/romos/romose.htm

Hmm, diese Ebene ist arg systemnah. Das BIOS eines PC-Boards 
umzuprogrammieren ist schon etwas hart.
Lieber wäre es mir, das BIOS unverändert zu lassen.

Aber trotzdem vielen Dank für den Link.

@ Reiner
Der Link ist sehr gut und hat mich auf eine Idee gebracht - Bootloader 
ins Bios einbauen anstelle des Dos.

@ Markus
Darf man nach dem Zweck fragen?

> Bootloader ins Bios einbauen anstelle des Dos.
Wobei das bei genauerer Überlegung nicht funktionieren wird, wenn man 
von einer Festplatte als Medium ausgeht.

Smoerre schrieb:
> Der Link ist sehr gut und hat mich auf eine Idee gebracht - Bootloader
> ins Bios einbauen anstelle des Dos.

Da ist doch schon einer, sonst würde der PC nie starten. Allerdings lädt 
der BIOS-Bootloader heute meistens einen weiteren, komplexeren 
Bootloader nach.

Gruss Reinhard

Häng dich in das BIOS der Grafikkarte oder noch besser und einfacher 
suche dir eine Netzwerkkarte mit BIOS Sockel.

Markus schrieb:
> wie einfach ist es ein Programm für einen PC zu schreiben, das ohne
> Betriebssystem läuft?
>
> Welche Standardausgabe und welche Tastatur hat jeder PC?

> Wenn man sich bei Linux Bootloader wie z.B. "Grub" anschaut, sind die ja
> ziemlich klein und rasend schnell sichtbar. Es muss also eine
> Minimalmöglichkeit geben, Tastatur und Bildschirm ohne besondere Treiber
> ansteuern zu können.
>
> Kennt sich von euch jemand aus?

Du willst lernen, wie man das macht.
Grub macht es schon.
Grub ist Open Source.
Also lerne, Grub zu verstehen.
Das ist Schritt 1.

Danach kannst Du aus Grub alles rauswerfen, was Du nicht brauchst, und 
durch Deinen eigenen Code ersetzen.
Das wäre Schritt 2.

Geht es einfacher? Nur, wenn Du ein anderes Programm als Basis nimmst, 
das auch Open Source ist und direkt mit dem Start läuft.
Die Auswahl dafür scheint begrenzt zu sein.
Klar, fragen darf man natürlich. Aber ab einem ungewissen Punkt ist das 
Fragen und Diskutieren umständlicher und zeitintensiver als das, was ich 
oben als Schritt 1 + 2 beschrieb.

Als weitere Möglichkeiten fallen mir noch ein: ReactOS und MenuetOS. 
Freie BIOSe wäre vielleicht auch was. Bzw. deren APIs. Es gibt freie 
BIOSe, bei denen man eigene Applikationen mit reinladen kann.

A. K. schrieb:
> Erstens enthält das normale BIOS sowieso schon einen Bootloader, der
> beliebige Anwendungen von Massenspeicher läd.

Naja, es lädt den 512 Byte großen Bootsektor. Wenn die "beliebige" 
Anwendung da reinpaßt, ok. Ansonsten muß man sich dafür einen eigenen 
Loader basteln, der dann das eigentliche Programm lädt (oder eben einen 
existerenden nehmen).

Hi,

ließ dir das (und falls nötig die weiteren Kapitel) durch und du 
solltest in der Lage sein, das zu machen, was du vor hast:
http://www.henkessoft.de/OS_Dev/OS_Dev1.htm

Links zu den Notwendigen Tools sind auch enthalten, sogar ein Emulator, 
der das ständige neu starten des PCs unnötig macht.

A. K. schrieb:
> Rolf Magnus schrieb:
>
>> Naja, es lädt den 512 Byte großen Bootsektor. Wenn die "beliebige"
>> Anwendung da reinpaßt, ok. Ansonsten muß man sich dafür einen eigenen
>> Loader basteln, der dann das eigentliche Programm lädt (oder eben
>> einen existerenden nehmen).
> Ja, und welch ein immenser Aufwand das Programmieren dieses Loaders
> ist!

Hab ich nie behauptet, aber du hast behauptet, daß das BIOS schon von 
sich aus "beliebige Anwendungen" laden könne.

> Ein paar Register laden, BIOS aufrufen, geladenes Programm anspringen.

Sofern das Programm nicht in einem Dateisystem liegt, das nebenbei noch 
mit implementiert werden muß.

Da ist doch schon einer, sonst würde der PC nie starten.
> richtig, deshalb auch der Name.

> Allerdings lädt der BIOS-Bootloader heute meistens einen weiteren,
> komplexeren Bootloader nach.
Exakt und den wollte ich ins Bios integrieren - geht natürlich nicht, 
weil dieser Bootloader mit den Betriebssystemauswahlmenü im MBR der 
Festplatte stehen muß.

> Und selbst wenn man keinen Massenspeicher investieren will, dann muss
> man die Anwendung dennoch nicht hochriskant in Mainboard-BIOS
> integrieren
Na ja, so hochriskant ist es nun auch wieder nicht - bei jedem 
Flashvorgang des Bios hast Du mehr oder weniger dasselbe Risiko.
Schlimmstenfalls ist ein neu programmiertes Bios fällig - ca. 12 Euro je 
nach Mainboard.
Bei anderen Geräten (Satreceiver, etc.) wäre ich schon vorsichtiger.

> Das BIOS sucht nach einem Bootfähigen Laufwerk... womit willst du
> booten ?

Offenbar von nirgends.

> Der Link ist sehr gut und hat mich auf eine Idee gebracht - Bootloader
> ins Bios einbauen anstelle des Dos.

sondern aus dem BIOS-Code selbst.

> Häng dich in das BIOS der Grafikkarte oder noch besser und einfacher
> suche dir eine Netzwerkkarte mit BIOS Sockel.

Ja, und warum funktionieren diese ?
Weil das BIOS noch eine Funktion beinhaltet, die BIOS-Extensions.

Ein IBM BIOS sucht nach BIOS-Erweiterungen an bestimmten Stellen im 
Hauptspeicher, eine bestimmte Signatur, und springt die der Reihe nach 
an, noch bevor es etwas Bootloadertypisschen probiert.

Ist dort ein passendes Image, kommt man also rein.

Dazu muss nicht extra ein zusätzlicher ROM-Chip mit Adressdecoder 
eingebaut werden, wie bei Graphikarte und Netzwerkkarte, sondern es gibt 
auch Stellen, die im heutigen Flash selber liegen.

Sprich: Ein modernes BIOS ist so groß, daß es selbst schon aus 
Extensions besteht, z.B. dem BIOS-Setup.

Man kann also Teile vom BIOS aus dem Flash rauswerfen, und ein neues 
BIOS brennen, welches die Grundfunktionen noch enthält 
(Bildschirmzugriff, Tastatur) aber eine eigene BIOS Extension, z.B. sein 
Spiel.

Leider sind moderne BIOSse noch grösser: Sie sind gepackt, sozusagen 
gezippt. Das macht das auffinden der Stellen, die man ersetzen kann, 
etwas schwieriger.

Aber vielleicht will er ja alte Rechner umbauen.

>ließ dir das (und falls nötig die weiteren Kapitel) durch und du
>solltest in der Lage sein, das zu machen, was du vor hast:
>http://www.henkessoft.de/OS_Dev/OS_Dev1.htm

Nicht schecht, was der Herr Henkes da zusammengetragen hat. Damit lässt 
sich auf jeden Fall was anfangen.
Ich habe mal nach einem Screenshot vom aktuellen "pretty os" gesucht, 
aber auf die Scnnelle nicht gefunden.
Die ideale Grundlage für das Programm ohne Betriebssystem Projekt wäre 
ein genügend großer Speicher ( als keine Beschränkung auf ein paar 
Blöcke auf der Platte ), Tastatur und Bildschirmzugriff mit der 
Möglichkeit, Pixel zu zeichnen.
Wenn das Booten von MemoryStick klappen würde, könnte man alte 
Mainboards nehmen und ganz auf sonstige Peripherie verzichten.

http://blog.ksplice.com/2010/03/libc-free-world/ sei zu lesen 
empfohlen.... ist etwas am Thema vorbei aber nicht ganz :)

Der Hintergrund meines Unterfangens ein Programm ohne Betriebssytem zu 
starten ist der Versuch, den PC als eine Art großen Mikrocontroller zu 
gebrauchen. Die meisten Mikrocontrollerschaltungen werden in Anwendungen 
eingesetzt, die nur eine Tätigkeit ausführen, also nicht wie ein PC, der 
für alles taugt, aber für nichts wirklich.
Da die meisten Leute noch alte Motherboards haben, wäre es ja nützlich, 
dies z.B. als intelligente Steuerung verwenden zu können.

Was könnte man damit machen?
- Bootzeiten kleiner 1 Sekunde realisieren
- Timerinterrupts mit hoher Frequenz für schnelle Echtzeianwendungen ( 
beim PrettyOS mit Dr. Henkes lief die ersten Version mit 1000 Hz)

Jetzt überlege ich gerade, ob als Grundlage vielleicht auch das 
TTY-Linux geeignet sein könnte:
http://minimalinux.org/ttylinux/index.html

Vielleicht ist ja auch das hier was für dich:
http://de.wikipedia.org/wiki/RTAI

Klaus schrieb:
> Der Hintergrund meines Unterfangens ein Programm ohne Betriebssytem zu
> starten ist der Versuch, den PC als eine Art großen Mikrocontroller zu
> gebrauchen. Die meisten Mikrocontrollerschaltungen werden in Anwendungen
> eingesetzt, die nur eine Tätigkeit ausführen, also nicht wie ein PC, der
> für alles taugt, aber für nichts wirklich.
> Da die meisten Leute noch alte Motherboards haben, wäre es ja nützlich,
> dies z.B. als intelligente Steuerung verwenden zu können.
>
> Was könnte man damit machen?
> - Bootzeiten kleiner 1 Sekunde realisieren

Da ist das BIOS das größte Problem. Man kann ein Linux-System so 
hintrimmen, daß es in diesen Bereich vorstoßen kann, aber das BIOS 
braucht  davor schon wesentlich mehr Zeit.

> - Timerinterrupts mit hoher Frequenz für schnelle Echtzeianwendungen (
> beim PrettyOS mit Dr. Henkes lief die ersten Version mit 1000 Hz)

1000 Hz sind kein wirkliches Problem, auch mit Betriebssystem. Wenn du 
z.B. xenomai nimmst, hast du dann auch harte Echtzeit, kannst aber 
gleichzeitig auch nicht-Echtzeit-Sachen ausführen.

Der Nachteil ohne Betriebssystem ist der sehr eingeschränkte Zugriff auf 
Hardware, weil man praktisch alles selber machen muß.

> Jetzt überlege ich gerade, ob als Grundlage vielleicht auch das
> TTY-Linux geeignet sein könnte:
> http://minimalinux.org/ttylinux/index.html

Interessant könnte auch coreboot als BIOS-Ersatz sein. Das kann dann 
entweder einen GRUB starten oder eine sogenannte "payload" direkt aus 
dem Flash.

Also ein Linux-Kernel ist in einer Sekunde, vielleicht auch weniger 
gestartet.

Es gibt auch Projekte die das Booten vom Einschalten bis zur grafischen 
Oberfläche (!) in 5 bis 10 Sekunden schaffen. Natürlich nur mit 
ausgesuchter Hardware. Lässt du den ganzen Kram wie GUI weg, dann 
dürftest du auch solche Zeiten hinbekommen und du hast eine erprobte 
Software auf die du aufbauen kannst.

Markus schrieb:
> Hallo Alle,
>
> vielen Dank für eure Antworten.
> Was mich im ersten Schritt interessieren würde, ist ein Hallo Welt mit
> zusätzlicher Funktion, dass man die Tastatureingaben sieht. Das Bios des
> Rechners darf ruhig verwendet werden, ich das Bios zu umgehen ist
> sowieso nicht möglich.

Die Tastatur frage ich über Port ab und mache die Bidschirmausgaben 
direkt in den Bildschirmspeicher. Für hohe Vesa-Bildmodi die keine 
Textausgabe selber unterstützen hole ich mir entweder die Chars aus dem 
Bios(siehe Vector 1Fh) und setze sie selber zum Bildschirm und wenn 
diese Chars zu klein erscheinen, dann kann man auch für jeden Punkt im 
Char gleich 4 Pixel zum Bildschirm setzen. Oder ich nehme eigene Zeichen 
die man frei gestalten kann wie es einem beliebt:

A   DB 0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 ;       **       │
    DB 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0 ;      ****      │
    DB 0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0 ;     ******     │
    DB 0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0 ;     ******     │
    DB 0,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0 ;    ***  ***    │
    DB 0,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0 ;    ***  ***    │
    DB 0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0 ;   ***    ***   │
    DB 0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0 ;   ***    ***   │
    DB 0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0 ;   ***    ***   │
    DB 0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0 ;  ***      ***  │
    DB 0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0 ;  ************  │
    DB 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 ; ************** │
    DB 0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0 ; ***        *** │
    DB 0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0 ; ***        *** │
    DB 1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1 ;***          ***│
    DB 1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1 ;***          ***│
;-------------------------------------- ────────────────┤

Hier nun eine Tastaturabfage direkt vom Port:

; Zum Anfang sperre ich IRQ 1:

       cli                          ; Software-Interrupts ausschalten
       mov      al, 2               ; IRQ 1 sperren
       out      21h, al
       sti                          ; Software-Interrupts einschalten

;----------------------------------------------------------------------- 
--
; In der Hauptschleife kommt die eigentliche Tastatur-Abfrage:

MAIN:


       in       al, 64h             ; Tastatur-Status holen
       test     al, 1
       jz  NOKEY                    ; wenn keine Taste weiter
       test     al, 20h
       jnz NOKEY                    ; wenn PS2-Mouse weiter
       in       al, 60h             ; Tasten-Code holen
       dec      al                  ;  Escape-Taste ?
       jz  HOME                     ; Escape-Taste = Programm-Ende
       inc      al
;----------------------------------------------------------------------- 
--
;                E x t r a - T a s t e n   a b f r a g e n
;----------------------------------------------------------------------- 
--
       mov      si, OFFSET SONTAB   ; Zeiger auf Extra-Tasten-Tabelle
       mov      cl, Extablen        ; länge
XSUCH: cmp      al, [si]            ; Taste suchen
       jz  XFOUND                   ;  gefunden ?
       lea      si, [si+1]
       dec      cl
       jnz XSUCH
;----------------------------------------------------------------------- 
--
;                    T a s t e n   a b f r a g e n
;----------------------------------------------------------------------- 
--
       mov      si, OFFSET TASTTAB  ; Zeiger auf Tasten-Tabelle
       mov      cx, tablen          ; länge
       mov      bx, OFFSET TEXTTAB  ; Offset auf Text
SUCH:  cmp      al, [si]            ; Taste suchen
       jz  FOUND                    ;  gefunden ?
       lea      si, [si+1]
       dec      cx
       jnz SUCH
       jmp NOKEY

FOUND:

XFOUND:

NOKEY:

       jmp MAIN


; .....................................
; Zum Ende erlaube ich IRQ 1 wieder:
; .....................................
HOME:  in       al, 60h             ; Tasten-Code holen (Puffer leeren)
       xor      cl, cl              ; kein Fehler

RAUS:  cli
       xor      al, al              ; IRQ 1 freigeben (Taste)
       out      21h
       sti

       mov      ah, 1               ; Tastatur-Puffer löschen
       int    16h

       mov      al, cl              ; ERRORLEVEL holen
       mov      ah, 4Ch             ; Programm beenden
       int    21h


;----------------------------------------------------
; Unser Datenbereich:
;.....................
TASTTAB DB 02h,03h,04h,05h,06h,07h,08h,09h,0Ah,0Bh,0Ch,0Dh
        DB 10h,11h,12h,13h,14h,15h,16h,17h,18h,19h,1Ah,1Bh,1Eh,1Fh
        DB 20h,21h,22h,23h,24h,25h,26h,27h,28h,29h,2Bh,2Ch,2Dh,2Eh,2Fh
        DB 30h,31h,32h,33h,34h,35h,39h
        DB 56h
tablen =  ($-TASTTAB)

TEXTTAB DB "1234567890ß'"
        DB "qwertzuiopü+as"
        DB "dfghjklöä^#yxcv"
        DB "bnm,.- "
        DB "<"
Textablen  =  ($-TEXTTAB)
;----------------------------------------------------
; Tab,shift li.,shift re.,HOME,UP,LEFT,RIGHT,END,DOWN
;----------
SONTAB  DB 0Fh,2Ah,36h,47h,48h,4Bh,4Dh,4Fh,50h
Extablen  =  ($-SONTAB)
        DB 0,0,0
SHIFT   DW 0

Dirk

Eine PS2-Mouse kann man so abfragen wie es die Cutemouse macht.
http://cutemouse.sourceforge.net/
Das geht bei mir auch über USB(wenn im Bios USB "legacy" enable).

Die folgende Routine benutze ich für 32Bit-Truecolor-Vesamodi bei der 
ich ein freigestelltes Bild mit beliebigen Ausmassen und Inhalt verwende 
und  als Mousezeiger in den linearen Framebuffer schreibe. (Den 
eigentlichen Mousezeiger schalte ich nicht ein.) Dafür lade ich das 
freigestellte Bild in die linke obere Ecke des Bildschirms und lege vom 
Inhalt des Bildschirms eine Tabelle an. 
Tabelle(32Bit-Offset,32Bit-Color,...) Vor dem Neu-Setzen des 
Mousezeigers wird der Hintergrund der vorherigen Position des 
Mousezeigers restauriert.

Dieses Beispiel wurde für MASM 5 entwickelt. Eine CPU mit MMX wird 
benötigt. Die Befehle müssen in eine lauffähige 16Bit-Anwendung 
integriert werden. Damit der lineare Framebuffer so auch addressiert 
werden kann wie ich es hier aufzeige, muss vorher in den Unrealmode 
geschaltet werden und zusätzlich ein Vesamode angeschaltet werden, der 
den linaeren Framebuffer unterstützt. (Siehe dazu das vbe3.pdf von 
vesa.org (register and/or login).) Es fehlen auch die Datei-Routinen und 
die Routine um ein Bild zum Bildschirm zu bringen. Damit das Beispiel 
aber nicht zu umfangreich wird, darum habe ich nur die betreffenden 
Mouseroutinen hier reingestellt.


          call PIXOFF ; legt eine Offset-Tabelle der Zeilenanfänge an
                      ; benötigte Start-Werte kommen aus Vesamodeinfo

          call CHECKPS2
          jc  NOMOUSE
          call PS2ON
          jc  NOMOUSE
;----------------
; Hauptschleife
;----------------
ACTION:   call GETMPOS                 ; Mouse-Zeiger holen/setzen
          cmp      bx, 0               ; kein Mouse-click
          jz  short NOZOOM
          cmp      bx, 2               ; Mouse-click right = Zoom
          jb  short NOZOOM


NOZOOM:

;----------------
; Programm-Ende
;----------------
          call PS2OFF
          mov      ax, 0C201h          ; Reset PS2
          int 15h

NOMOUSE:


;-----------------------------------------------------------------------
; Subroutinen
;----------------
CHECKPS2: int    11h                  ; get equipment list
          test    al, 3
          jz  short NOPS2             ; jump if PS/2-Mouse not indicated
          mov     bh, 3               ; data package size (1 - 8 bytes)
          mov     ax, 0C205h
          int 15h                     ; initialize mouse, bh=datasize
          jc  short NOPS2
          mov     bh, 3               ; 03h  eight counts per mm
          mov     ax, 0C203h
          int 15h                     ; set mouse resolution bh
          jc  short NOPS2
          mov     ax, cs
          mov     es, ax
          mov     bx, OFFSET PS2TEST
          mov     ax, 0C207h
          int 15h                     ; mouse, es:bx=ptr to handler
          jc  short NOPS2
          xor     bx, bx
          mov     es, bx              ; mouse, es:bx=ptr to handler
          mov     ax, 0C207h
          int 15h
          ret

NOPS2:    stc
          ret
;-------------------------------------
PS2ON:    call PS2OFF
          mov    ax, cs
          mov    es, ax
          mov    bx, OFFSET PS2IRQ
          mov    ax, 0C207h           ; es:bx=ptr to handler
          int 15h
          jc  short NOPS2
          mov     bh, 1               ; set mouse on
          mov     ax, 0C200h
          int 15h
          ret
;-------------------------------------
PS2OFF:   xor     bx, bx              ; set mouse off
          mov     ax, 0C200h
          int 15h
          xor     bx, bx
          mov     es, bx
          mov     ax, 0C207h          ; es:bx=ptr to handler
          int 15h
          ret
;-------------------------------------
PS2IRQ:   push    ds                  ; unser PS2-Mousehandler
          pusha
          mov     ax, DATEN
          mov     ds, ax
          mov     bp, sp
          mov     bx, [bp+22+6]   ; status byte(buttons,Sign,Overflow)
          mov     cx, [bp+22+4]   ; X movement
          mov     dx, [bp+22+2]   ; Y movement
          mov     ax, [XACK]
          test    bx, 10h         ; Sign X  Mouse goes right
          jz short MOGOR
          neg     cl
          sub     ax, cx
          cmp     ax, [BHMIN]     ; (Hmin) Mouse-Zeiger zu weit links ?
          jb  short IY0
;          test   bx, 40h          ; Overflow X
;          jz  short IY0
IX1:      jmp short IX2           ; X schreiben
;---------
MOGOR:    add     ax, cx
          cmp     ax, [BHMAX]     ; (Hmax) Mouse-Zeiger zu weit rechts ?
          ja  short IY0
;          test   bx, 40h          ; Overflow X
;          jz  short IY0
IX2:      mov     [XACK], ax
;---------------------------------
IY0:      mov     ax, [YACK]
          test    bx, 20h         ; Sign Y Mouse goes down
          jnz short MOGOU
          sub     ax, dx
          cmp     ax, [BVMIN]     ; (Vmin) Mouse-Zeiger zu hoch ?
          jb  short IIZ
;          test    bx, 80h         ; Overflow Y
;          jz  short IIZ
IY1:      jmp short IY2           ; Y schreiben
;---------
MOGOU:    neg     dl
          add     ax, dx
          cmp     ax, [BVMAX]     ; (Vmax)  Mouse-Zeiger zu tief ?
          ja  short IIZ
;          test     bx, 80h        ; Overflow Y
;          jz  short IIZ
IY2:      mov     [YACK], ax
;---------------------------------
IIZ:      and     bx, 3           ; only buttons, remove Sign + Overflow
          mov     [TACK], bx
;---------
          popa
          pop     ds
PS2TEST:  retf
;─────────────────────────────────────────────────────────────────────── 
─
;      M o u s e - Z e i g e r   z u m   B i l d s c h i r m
;─────────────────────────────────────────────────────────────────────── 
─
GETMPOS:  cli
          xor      ecx, ecx
          xor      edx, edx
          mov      cx, [XACK]          ; cx = X-Positon   holen
          mov      dx, [YACK]          ; dx = Y-Position  holen
          mov      bx, [TACK]          ; bx = Mouse-Taste holen
          lea      ecx, [ecx*4]
          lea      edx, [edx*4]
          mov      [RETCLIC], bx
          cmp      ecx, DWORD PTR[MX]
          jnz short MSOI
          cmp      edx, DWORD PTR[MY]
          jz  NOMOUT                   ; wenn dieselbe Pos., dann nicht 
setzen

MSOI:     mov     DWORD PTR[MY], edx
          mov      dx, Rast_Port
          mov      bl, 8
          mov     DWORD PTR[MX], ecx   ; Mouse-Zeiger setzen

RAST:     in       al, dx              ; Bewegung mit Raster-Strahl
          and      al, bl              ; synchronisieren
          jnz RAST
RASTER:   in       al, dx
          and      al, bl
          jz  RASTER

          call RESTAU                     ; Mouse-Hintergrund 
restaurieren

M1ST:     mov      ebx, DWORD PTR[MY]     ; erster Mouse-Ansprung
          mov      ebx, [ebx]             ; Zeilen-Offset holen
          mov      esi, DWORD PTR[MAUHI1] ; Zeiger auf 
Rett-Sprite-Tabelle
          add      ebx, DWORD PTR[MX]     ; plus X
          mov     DWORD PTR[RETTPOS], ebx ; neue Bild-Position retten

OBJECT2:  mov      edi, [esi]             ; Offset aus Tabelle holen
          mov      eax, [edi+ebx]         ; Farbe vom Bildschirm holen

          mov      ecx, [esi+8]
  DB 67h, 0Fh, 6Eh, 1Ch, 19h        ; movd mm3, [ecx+ebx]

          mov      [esi+4], eax           ; Farbe in  Tabelle retten

  DB 67h, 0Fh, 7Eh, 5Eh, 0Ch        ; movd [esi+0Ch], mm3
          lea      esi, [esi+10h]
          cmp      esi, ebp               ;  Ende erreicht ?
          jb  OBJECT2

          mov      esi, DWORD PTR[MAUKA1] ; Zeiger auf Sprite-Tabelle
          mov      ebp, DWORD PTR[MAUHI1] ; Tabellen-Ende

OBJECT3:  mov      edi, [esi]             ; Adresse aus Tabelle holen
          mov      eax, [esi+4]           ; Farbe  aus Tabelle holen

          mov      ecx, [esi+8]
  DB 67h, 0Fh, 6Eh, 5Eh, 0Ch        ; movd mm3, [esi+0Ch]
          lea      esi, [esi+10h]
          mov      [edi+ebx], eax         ; Farbe zum Bildschirm

  DB 67h, 0Fh, 7Eh, 1Ch, 19h        ; movd [ecx+ebx], mm3

          cmp      esi, ebp               ;  Ende erreicht ?
          jb  OBJECT3
          mov      bx, [RETCLIC]
          mov      ecx, DWORD PTR[MX]
          mov      edx, DWORD PTR[MY]
NOMOUT:   sti
          ret
;─────────────────────────────────────────────────────────────────────── 
──
;      M o u s e - H i n t e r g r u n d   r e s t a u r i e r e n
;─────────────────────────────────────────────────────────────────────── 
──
RESTAU:   mov      esi, DWORD PTR[MAUHI1]    ; Zeiger auf 
Rett-Sprite-Tabelle
          mov      ebx, DWORD PTR[RETTPOS]   ; alte Bild-Position holen
          mov      ebp, DWORD PTR[MAUEND]    ; Tabellen-Ende

RESTAU2:  mov      edi, [esi]                ; Offset aus Tabelle holen
          mov      eax, [esi+4]              ; Farbe  aus Tabelle holen

          mov      ecx, [esi+8]
  DB 67h, 0Fh, 6Eh, 5Eh, 0Ch           ; movd mm3, [esi+0Ch]
          lea      esi, [esi+10h]
          mov      [edi+ebx], eax            ; Tabellen-Farbe zum 
Bild-Bereich

  DB 67h, 0Fh, 7Eh, 1Ch, 19h           ; movd [ecx+ebx], mm3

          cmp      esi, ebp                  ;  Ende erreicht ?
          jb  RESTAU2
          ret


;──────────────────────────────────────────────────────────────────────
;legt eine Offset-Tabelle der Zeilen-Anfänge des aktuellen Vesa-Modes an
;──────────────────────────────────────────────────────────────────────
PIXOFF:   mov      cx, [YMAX]
          xor      di, di              ; Tabelle am Anfang des 
Daten-Segments
          xor      eax, eax
          mov      edx, DWORD PTR[XMAX] ; Zeilen-Länge holen 
(Xmax*BytejePixel)
          shl      cx, 2               ; Max_Y * 4

AGAIN:    mov      [di], eax           ; Zeilen-Offset in Tabelle
          lea      di, [di+4]
          lea      eax, [eax+edx]      ; plus (Max_X)
          cmp      di, cx              ;  schon Tabellen-Ende(Max_Y*4) ?
          jb  AGAIN
          ret


;----------------------------------------------------------------------- 
-
; Unser Datenbereich
;-------------------
PIXTAB DD MaxY+16 dup (0FFFFFFFFh)  ; Tabelle der Zeilen-Anfänge

MX      DW MXpos * 4, 0 ; Mousezeiger-X-Position
MY      DW MYpos * 4, 0 ; Mousezeiger-Y-Position

XACK    DW MXpos  ; Mouse X
YACK    DW MYpos  ; Mouse Y
TACK    DW 0      ; Button,Sign,Overflow

BHMAX   DW Hmax   ; Mousebegrenzung
BHMIN   DW Hmin
BVMAX   DW Vmax
BVMIN   DW Vmin

RETTPOS DD 0      ; alte Mousezeiger-Position
RETCLIC DW 0, 0   ; Mouse-Click
;-------------------

Mail me to: freecrac at web dot de

Dirk

http://lowlevel.eu Die beschäftigen sich auch mit OS-Dev