checkPS2:
int 11h                 ; get equipment list
test    al, 3
jz  noPS2               ; jump if PS/2-Mouse not indicated
mov     bh,3
mov     ax, 0C205h
int 15h                 ; initialize mouse, bh=datasize
jc noPS2
mov     bh,3
mov     ax, 0C203h
int 15h                 ; set mouse resolution bh
jc noPS2
mov     ax, cs
mov     es, ax
mov     bx, OFFSET PS2dummy
mov     ax, 0C207h
int 15h                 ; mouse, es:bx=ptr to handler
jc noPS2
xor     bx, bx
mov     es, bx          ; mouse, es:bx=ptr to handler
mov     ax, 0C207h
int 15h
ret

noPS2:
stc
ret

PS2dummy:
retf
;---------------------------------------------------------
enablePS2:
call disablePS2
mov    ax, cs
mov    es, ax
mov    bx, OFFSET IRQhandler
mov    ax, 0C207h       ; es:bx=ptr to handler
int 15h
mov     bh,1            ; set mouse on
mov     ax, 0C200h
int 15h
ret
;-------------------------------
disablePS2:
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
;---------------------------------------------------------------------------
IRQhandler:
                assume  ds:nothing,es:nothing
cld
push    ds
push    es
pusha
mov     ax, cs
mov     ds, ax
mov     bp,sp
mov     al,[bp+24+6]    ; buttons
mov     bl,al
shl     al,3            ; CF=Y sign bit
sbb     ch,ch           ; signed extension 9->16 bit
cbw                     ; extend X sign bit
mov     al,[bp+24+4]    ; AX=X movement
mov     cl,[bp+24+2]    ; CX=Y movement
xchg    bx,ax
neg     cx              ; reverse Y movement

; + inserting some mov-commands to store the bytes to a known location in the data segment of our application.

popa
pop     es
pop     ds
retf
    

IRQ12-Handler installieren

   13     mov [es:74h*4+2],cs         ;und dann an den Eintrag für den Int74h/IRQ12 das Segment
   14     mov [es:74h*4],word irq12   ;und den Offset des Int-Handlers speichern

Maus im Stream-Modus aktivieren

   18     mov al,0a8h         ;schiebe auf al den Befehl zur Aktivierung der Maus
   19     out 64h,al          ;schicke den Befehl an den Keyboard-Controller
   20     call kb.checkcmd    ;und warte bis der Befehl angenommen und verarbeitet wurde
   21     
   22     mov al,0f4h         ;danach an die Maus den Befehl zum Eintritt in den Streaming-Mode auf al kopieren
   23     call kb.write.mouse ;um diesen an die Maus über den Input-Buffer-Port zu senden
   24     
   25     cli                 ;alle Interrupts auschalten, damit nicht unser Keyboard-Int das gesendete Byte erhält xD
   26     mov al,20h          ;Befehl zum auslesen des Kommando-Bytes auf al schieben
   27     out 64h,al          ;um es an den Keyboard-Controller zu senden
   28     call kb.checkcmd    ;nun noch warten, bis dieser angenommen wurde
   29     call kb.read        ;und wir können das command-Byte abholen
   30     sti                 ;nun da wir das Byte entgegengenommen haben, können wir die IRQs wieder aktivieren
   31         push ax         ;speichere al, da dies für out gebraucht wird
   32             lea si,[got_command_byte_str]   ;zum debuggen->gibt erhaltenes commandbyte aus
   33             call write                      ;   ~
   34             xchg ah,al                      ;   ~
   35             mov ebx,16                      ;   ~
   36             call zahlausgabe                ;   ~
   37     mov al,60h          ;und kopiere auf al den Befehl zum einlesen eines neuen Command-Bytes
   38     out 64h,al          ;und schicke diesen nun an den Keyboard-Controller
   39     call kb.checkcmd    ;warte auf Annahme dessen -> nun wartet der KC auf das Command-Byte am Port 60h(Datenport des 64h)
   40         pop ax          ;stelle nun das mit 20h erhaltene Byte wieder her um es zu modifizieren und neu zu setzen
   41     or al,00000011b     ;setze Bit1, bei dessem Setzen der IRQ12 immer angesprungen wird, sobald Bit5 im 64h-Status-Byte =1 ist
   42     and al,11101111b    ;lösche das Bit, das wenn es gesetzt ist die Tastatur deaktiviert.
   43     out 60h,al          ;und schicke das Command-Byte an den Daten-Port 60h, durch den Befehl 60h wird dieses neu eingelesen
   44     call kb.checkcmd    ;und warte, bis das Byte vollständig angenommen wurde

Rad und/oder 5 Tasten-Modus aktivieren

   46             lea si,[three_button_mode]      ;zum debuggen, gibt nachricht aus, dass maus sich
   47             call write                      ;im 3-tasten-modus befindet
   48     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   49     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   50     mov al,0C8h         ;dann das zweite Byte des Befehls, die Sample-Rate (200 reports/s) auf al kopieren
   51     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   52     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   53     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   54     mov al,64h          ;dann das zweite Byte des Befehls, die Sample-Rate (100 reports/s) auf al kopieren
   55     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   56     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   57     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   58     mov al,50h          ;dann das zweite Byte des Befehls, die Sample-Rate (80 reports/s) auf al kopieren
   59     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   60     cli                 ;alle Interrupts auschalten, damit nicht unser Keyboard-Int das gesendete Byte erhält xD
   61     mov al,0F2h         ;sende Befehl F2h für GetDeviceID an Maus, sodass wenn die Maus ein Mausrad besitzt mit 03h antwortet,
   62     call kb.write.mouse ;ansonsten erwidert sie 00h -> Dies wird durch die Sequenz SetSampleRate 200,100,80 aktiviert.
   63     call kb.read        ;die ID der Maus auslesen. (kb.write.mouse liest nur die Bestätigung FAh aus)
   64     sti                 ;nun da wir das Byte entgegengenommen haben, können wir die IRQs wieder aktivieren
   65             cmp al,03h                      ;testen ob id 3h gesendet hat
   66             jne .no_wheel_mode              ;wenn nicht, wurde nicht in den wheelmode geswitched
   67                 lea si,[wheel_mode]         ;zum debuggen->gibt aus, ob Maus-mode geändert wurde
   68                 call write                  ;   ~
   69             .no_wheel_mode
   70 
   71     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   72     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   73     mov al,0C8h         ;dann das zweite Byte des Befehls, die Sample-Rate (200 reports/s) auf al kopieren
   74     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   75     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   76     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   77     mov al,0C8h         ;dann das zweite Byte des Befehls, die Sample-Rate (200 reports/s) auf al kopieren
   78     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   79     mov al,0F3h         ;Befehl zum senden und neu setzen der SampleRate auf al schieben
   80     call kb.write.mouse ;und per vordefinierter Prozedur an die Maus senden
   81     mov al,50h          ;dann das zweite Byte des Befehls, die Sample-Rate (80 reports/s) auf al kopieren
   82     call kb.write.mouse ;und auch dies per vordefinierter Prozedur an die Maus senden
   83     cli                 ;alle Interrupts auschalten, damit nicht unser Keyboard-Int das gesendete Byte erhält xD
   84     mov al,0F2h         ;sende Befehl F2h für GetDeviceID an Maus, sodass wenn die Maus ein Mausrad besitzt mit 04h antwortet,
   85     call kb.write.mouse ;ansonsten erwidert sie 00h -> Dies wird durch die Sequenz SetSampleRate 200,100,80 aktiviert.
   86     call kb.read        ;die ID der Maus auslesen. kb.write.mouse liest nur die Bestätigung FAh aus
   87     sti                 ;nun da wir das Byte entgegengenommen haben, können wir die IRQs wieder aktivieren
   88     mov [mouseid],al    ;speichere die erhaltene MausID in einer Variable, damit der IRQ12-Handler weiß, ob die Maus ein Rad hat
   89             cmp al,03h                      ;testen ob id 4h gesendet hat
   90             jne .no_5_button_mode           ;wenn nicht, wurde nicht in den wheelmode geswitched
   91                 lea si,[five_button_mode]   ;zum debuggen->gibt aus, ob Maus-mode geändert wurde
   92                 call write                  ;   ~
   93             .no_5_button_mode

PIC - IRQ12 aktivieren

   95     in al,0A1h          ;hole von dem PIC2 das IMR
   96     and al,11101111b    ;um darin den IRQ12 zu maskieren, damit er aktiviert wird
   97     out 0A1h,al         ;und sende das modifizierte IMR an den Slave

Schleife, in der Mauseingaben möglich sind

   99     wait_esc:
  100         mov ah,1        ;Funktion 1 des Int16h wählen, um abzufragen, ob ein Tastendruck vorhanden ist
  101         int 16h         ;diese Funktion ausführen, zeroflag gesetzt, wenn nichts vorhanden ist
  102         or ah,ah        ;teste ob ein Scancode <> 0 erhalten wurde und somit eine Taste gedrückt wurde...
  103             jz wait_esc ;wenn keine Taste gedrückt wurde, führe die Prozedur so lange aus, bis die geschieht
  104         xor ax,ax       ;lösche ax für funktion 00h
  105         int 16h         ;und hole die Taste ab, die bei ah=1 int 16 den Tastendruck ausgelöst hat, da diese ja nicht abgeholt wird
  106         cmp ah,1        ;vergleicht den asciicode mit dem von ESC
  107     jne wait_esc        ;wenn ESC nicht gedrückt wurde, warte auf näcshten Tastendruck

Maus deaktivieren, Programm beenden 

  109     cli                 ;alle Interrupts auschalten, damit nicht unser Keyboard-Int das gesendete Byte erhält xD
  110     mov al,20h          ;Befehl zum auslesen des Kommando-Bytes auf al schieben
  111     out 64h,al          ;um es an den Keyboard-Controller zu senden
  112     call kb.checkcmd    ;nun noch warten, bis dieser angenommen wurde
  113     call kb.read        ;und wir können das command-Byte abholen
  114     sti                 ;nun da wir das Byte entgegengenommen haben, können wir die IRQs wieder aktivieren
  115         push ax         ;spiechere al, da dies für out gebraucht wird
  116     mov al,60h          ;und kopiere auf al den Befehl zum einlesen eines neuen Command-Bytes
  117     out 64h,al          ;und schicke diesen nun an den Keyboard-Controller
  118     call kb.checkcmd    ;warte auf Annahme dessen -> nun wartet der KC auf das Command-Byte am Port 60h(Datenport des 64h)
  119         pop ax          ;stelle nun das mit 20h erhaltene Byte wieder her um es zu modifizieren und neu zu setzen
  120     and al,11101101b    ;lösche Bit1, bei dessem Setzen der IRQ12 immer angesprungen wird, sobald Bit5 im 64h-Status-Byte =1 ist
  121                         ;lösche auch noch Bit 5, da bei manchen PCs anscheined ein falsches command-byte geliefert wird.. und
  122                         ;wenn bit 5 gesetzt ist, wird der Keyboard-streaming-mode sozusagen beendet.. (hat sich erledigt, lag
  123                         ;daran, dass mein keyboard-treiber das commandbyte abgefangen hatte, kann aber nicht schades das Bit5 
  124                         ;zu löschen, wer will soll und kann es wegmachen)
  125     out 60h,al          ;und schicke das Command-Byte an den Daten-Port 60h, durch den Befehl 60h wird dieses neu eingelesen
  126     call kb.checkcmd    ;und warte, bis das Byte vollständig angenommen wurde

  128     mov al,0F5h         ;auf al den Befehl zum deaktivieren der Maus selbst schieben
  129     call kb.write.mouse ;und an die Maus senden
  130     
  131     mov al,0a7h         ;schiebe auf al den Befehl zur Deaktivierung der Maus und 
  132     out 64h,al          ;schicke dies dem Keyboard-Controller, sodass die Maus auch auf diesem deaktiviert ist
  133     call kb.checkcmd    ;warte bis der Befehl angenommen wurde
  134 
  135     in al,0A1h          ;hole von dem PIC2 das IMR
  136     or al,00010000b     ;um darin den IRQ12 zu maskieren, damit er deaktiviert wird
  137     out 0A1h,al         ;und sende das modifizierte IMR an den Slave
  138 
  139     retf                ;springe zum Kernel zurück

Handler-Code

  141 ;***************************************************************************************************************
  142 ;dies ist der IRQ12, der immer angesprungen wird, wenn sich die Daten der Maus verändert habe (sofern der Stream-Mode benutzt wird)
  143 ;da der IRQ12 immer nur aufgerufen wird, wenn ein Byte im Mouse-Buffer liegt, holen wie auch immer nur ein Byte ab, zählen jedoch mit,
  144 ;welches Byte des Mouse-data-packets das ist. Unter VirtualBox ging es zwar auch, wenn man alle 3 Byte hintereinander beim Aufrufen
  145 ;abgeholt hat, doch bei meinem alten PC kam es dabei zu disinformation, sodass ich das so ändern musste.
  146 ;***************************************************************************************************************
  147 irq12:
  148     pusha       ;Register sichern
  149     push ds     ;Datensegment sichern
  150     push es     ;es-Segment sichern
  151     mov ax,cs   ;dann auf ax das codesegment, also das segment, wo das Programm ist, holen
  152     mov ds,ax   ;um dies auf ds zu kopieren
  153     mov es,ax   ;und um auch es zu updaten
  154 
  155 .start:
  156 call kb.read.mouse      ;Byte #1,#2,#3 oder #4 nach al holen
  157     jnz .end            ;wenn dabei was schief ging, beende den irq
  158 
  159 cmp byte[actualb],0     ;überprüfe, ob der Counter 0 ist (Zähler beginnt mit 0!)
  160 jne .not_first_byte     ;wenn nicht, hole schoneinmal Byte 1 nicht ab und springe somit darüber
  161 
  162     mov [status],al             ;das Byte in Status speichern, damit es die Prozeduren von int33h nutzen können
  163     jmp short .end_part_packet  ;beende den Interrupt, da beim nächsten Byte dieser IRQ sowieso nocheinmal aufgerufen wird
  164 
  165 .not_first_byte:    
  166 cmp byte[actualb],1         ;teste ob der Counter 1 ist (Zähler beginnt mit 0!)
  167 jne .not_second_byte        ;wenn nicht, dann ist es auch nicht das zweite Byte, was wir jetzt holen müssen
  168 
  169     mov [xcoord],al             ;ansonsten zwischenspeichere den x-movement
  170     test byte[status],00010000b ;dann teste ob das SignBit von x gesetzt ist, wenn ja, ist das movement negativ
  171     jnz .sign_bit_x             ;und springe zu dem Teil, der subtrahiert statt addiert
  172         add [x],ax              ;ansonsten addiere zur aktuellen Position die Bewegung -> da ah ja 0 sein muss, wenn der 
  173                                 ;Programmzeiger hierhergekommen ist, ist das möglich
  174         jmp short .sign_x       ;und überspringe das Abziehen
  175     .sign_bit_x:
  176         not al                  ;negiere x-coord, damit der overflow aufgehoben wird, der ensteht, wenn man 0-1 rechnet
  177         inc al                  ;da aber -1 = FFh was genoted 0 wäre, addiere nocheinmal 1
  178         sub [x],ax              ;und ziehe den Betrag des Movements der aktuellen Position ab -> da ah ja 0 sein muss, wenn
  179                                 ;der Programmzeiger hierhergekommen ist, ist das möglich
  180     .sign_x:
  181     jmp short .end_part_packet  ;beende den Interrupt, da beim nächsten Byte dieser IRQ sowieso nocheinmal aufgerufen wird
  182 
  183 .not_second_byte:
  184 cmp byte[actualb],2         ;teste ob der Byte-Counter 2 ist (Zähler beginnt mit 0!)
  185 jne .not_third_byte         ;wenn nicht, dann muss es das 4. Byte sein, was wir abholen müssen also springe dahin
  186 
  187     mov [ycoord],al             ;ansonsten zwischenspeichere den y-movement
  188     test byte[status],00100000b ;dann teste ob das SignBit von y gesetzt ist, wenn ja, ist das movement negativ
  189     jnz .sign_bit_y             ;und springe zu dem Teil, der subtrahiert statt addiert
  190         add [y],ax              ;ansonsten addiere zur aktuellen Position die Bewegung -> da ah ja 0 sein muss, wenn der
  191                                 ;Programmzeiger hierhergekommen ist, ist das möglich
  192         jmp short .sign_y       ;und überspringe das Abziehen
  193     .sign_bit_y:
  194         not al                  ;negiere y-coord, damit der overflow aufgehoben wird, der ensteht, wenn man 0-1 rechnet
  195         inc al                  ;da aber -1 = FFh was genoted 0 wäre, addiere nocheinmal 1
  196         sub [y],ax              ;und ziehe den Betrag des Movements der aktuellen Position ab -> da ah ja 0 sein muss, wenn
  197                                 ;der Programmzeiger hierhergekommen ist, ist das möglich
  198     .sign_y:
  199     
  200     cmp byte[mouseid],0         ;prüfe ob die MouseID 0 ist, falls nicht, werden 4 Bytes gesendet, egal ob mouseid 3 oder 4 ist
  201         jz short .end_packet    ;beende nun den Interrupt, code setzt actualb auf 0 und gibt paket aus
  202     jmp short .end_part_packet  ;beende den Interrupt, da beim nächsten Byte dieser IRQ sowieso nocheinmal aufgerufen wird
  203 
  204 .not_third_byte:
  205 
  206     mov [zbtn45],al         ;sonst speichere es für spätere Benutzung
  207     test al,00000001b       ;teste ob überhaupt ein z-movement vorliegt, da es nur 1111b und 0001b gibt und dabei bit1 immer 1 ist
  208         jz .end_packet      ;falls kein z-movment vorhanden sit, überspringe das berechnen eines diesen
  209     test al,00000010b       ;ansonsten teste, ob es 1111b ist und somit z incrementiert wird, oder es 0001b ist und z dec wird
  210     jnz .z_mov_plus_1       ;wenn 1111b, dann springe zu code, der [z] incrementiert
  211         dec byte[z]             ;ansonsten decrementiere [z]
  212         jmp short .end_packet   ;überspringe den code, der [z] inkrementieren würde
  213     .z_mov_plus_1:
  214         inc byte[z]             ;incrementiere [z]
  215 
  216 .end_packet:
  217     mov byte[actualb],-1;setze Byte-Counter auf -1(da es bei .end_.. um 1 incrementiert wird), da Paketbytes abgeholt worden
  218     call display_mouse  ;dies ist eine sehr umfangreiche Prozedur zur Veranschaulichung der Daten
  219 .end_part_packet:
  220     inc byte[actualb]   ;incrementiere den Byte counter um 1, damit beim der irq12-handler weiß, welches byte er bearbeitet
  221 
  222 .end:
  223     mov al,20h      ;schiebe das OCW1/EOI auf al
  224     out 20h,al      ;und sende den EOI an den Master
  225     out 0A0h,al     ;und den Slave, da beide ihn benötigen, da Slave am IRQ2 hängt
  226     pop es          ;es wiederherstellen
  227     pop ds          ;stelle ds wieder her
  228     popa            ;stelle auch die anderen Register wieder her
  229     iret            ;und verlasse den Interrupt
  230 
  231 ;************************* Variablen des IRQ12 *************************
  232 status  db 0    ;hier wird das Byte1 des Mouse-data-packes gespeichert
  233 xcoord  db 0    ;hier das zweite
  234 ycoord  db 0    ;und hier das 3.
  235 zbtn45  db 0    ;und hier das 4.
  236 x       dw 0    ;hier ist die aktuelle Position des Mauszeigers gespeichert, die entsprechend
  237 y       dw 0    ; ... der Movement-Bytes verändert werden
  238 z       dw 0    ;hier die aktuelle z-position des rades(nicht die bewegung)
  239 mouseid db 0    ;hier wird die MouseID gespeichert 0 für normal, 3 für Rad und 4 für Rad und 5 Buttons
  240 actualb db 0    ;hier wird gespeichert, welche bytes des Maus-Daten-Pakets schon abgeholt wurden (für jedes Byte wird der IRQ12
  241                 ;einzeln angesprungen)

  304 .write.mouse:
  305     push ax             ;al sichern, da dort der zu sendende Befehl gesichert ist
  306     mov al,0d4h         ;auf al d4h kopieren -> sagt dem KC, dass das nächste Byte an die Maus anstatt der Tastatur gesendet wird
  307     out 64h,al          ;... werden soll -> dann schicke das Byte an den KC
  308     call kb.checkcmd    ;und warte, bis es angenommen und verarbeitet wurde
  309     pop ax              ;hole den eig. zu sendenden Befehl nach al
  310     cli                 ;Interrupts deaktivieren, damit Byte nicht von einem falsch geproggten IRQ1-Int-Handler abgefangen wird
  311     out 60h,al          ;und sende ihn nun, da D4h gesendet wurde an den Maus-Controller
  312     call kb.checkcmd    ;und warte, bis auch dieser Befehl vollständig angenommen unf abgearbeitet wurde
  313     call kb.read        ;hole die response. die ist bei succes FAh. bei manch anderen gibt es special-codes, wie 00h bei GetID
  314     sti                 ;Interrupts wieder aktivieren, sonst bleibt sicher der PC hängen xD
  315     ret                 ;verlasse Prozedur und springe zumi Aufruf zurück
  316 ;******* Prozedur schickt den Befehl per D4h an die Maus und gibt error von kb.read aus (prc succesfull if ah=0 und al=FAh sein) *********

Ausgabe-Prozedur

  369 ;***************************************************************************************
  370 ;Display-Mouse -> eine ganz spezifische Prozedur, die die Daten des Mouse-Packets vernaschaulicht
  371 ;***************************************************************************************
  372 x_pos_mouse_pic db 30   ;obere linke x-position des mausbildes
  373 y_pos_mouse_pic db 7    ;obere linke y-position des mausbildes
  374 picw            equ 17  ;Länge einer Zeile des Bildes
  375 ;                 |-y_pos_mouse_pic
  376 ;<---x_pos_mouse_pic--->|
  377 ;                 <---------pic_width-------->
  378 mouse_pic   db  "   ___________   " ;16 Bytes per line
  379             db  "  /   |   |   \  "
  380             db  " |    |   |    | "
  381             db  " |    |   |    | "
  382             db  " |-------------| "
  383             db  " | xmov=       | "
  384             db  " | ymov=       | "
  385             db  " |  x=         | "
  386             db  " |  y=         | "
  387             db  " |  z=         | "
  388             db  "  \___________/  "
  389 
  390 display_mouse:
  391     pusha           ;Register sichern
   .
   .  aus Gründen der Größe dieses Artikels musste ich leider diesen CodeTeil aus dem Artikel entfernen.
   .  bitte schaut im Sourcecode selber nach, was hier stehen müsste. Die Zeilen-Angaben sind ja gegeben.
   .
  584     popad           ;dann stelle die Register wieder her
  585     ret             ;und kehre zum Aufrufsort zurück
    

Which is I want 100% hardware mouse driver only! Not a bullshit too big detour asms like microsoft or any other software interrupted mouse driver asm!!!.

Just4fasm, there is a reason there are "detours" and abstractions such as miniport drivers. They simplify programming, for example the USB stack driver sits below the mouse-specific code, and can be re-used for any other hardware based on USB.

freecrac Dirk, Thank you for your efforts & trying to help. Well, seems, you're the only one who understands what did I wrote here but sadly not that much correctly... Alright, your asm source is also considered as detour asm! cos' you used unusual interrupt services! That's why your application can't stay resident!. You can't fully handle the interrupts! your programs always depends on evil software corporates!!!.

CTMOUSE 2.0 is hardware-based, 1.9 and 2.1 are BIOS-based.

Note that for USB mice you need a full USB driver before you can build a mouse driver on the top.

http://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/dos/mouse/old/alpha/ (damn!!!)