|
; Run in dos (not under windows) and it will take us to 32 bit protected mode
[ORG 0x100] ; Reserve 256 bytes for dos
; 8253 timer - generating interrupts at 100hz
[BITS 16] ; Dos is 16 bits
; assemble using 'nasm' assemblaer
; C:>nasm asm_1.asm -o test.exe
jmp entry ; Jump to the start of our code
msg1 db 'Where good to go..$';
jumpOffset:
dd go_pm
dw 0x08
entry:
; Display a message showing where alive!
mov dx, msg1 ; register dx=msg1
mov ah, 9 ; register ah=9 -- the print string function
int 21h ; dos service interrupt .. looks at register ah to figure out what to do
; Thanks from Brendan, as we have to make sure our GDTR points to the actual
; memory address, add code location and dos 0x100 onto our loaded offset
mov eax,0
mov ax,cs
shl eax,4
add [gdtr+2],eax
add [idtr+2],eax ; set idtr and gdtr so it points to the 'real' address in memory
add [jumpOffset],eax ; do the same for our 32 pm addr
add [int_start], eax ; Set the value of int_start (our simple interrupt function) so
; it has the "physical" address
; we have 4 different interrupt functions at the bottom of the code:
;isr_00, irq0, int_test, exc
;Our main one will be exc, and its address is saved in memory location int_start
mov eax, [int_start]
mov word [idt_start], ax
shr eax,16
mov word [idt_start+6], ax
;---------------------------------------------------------------------------
; Whats all this about?...
;---------------------------------------------------------------------------
; We loop through all 46 of the interrupt function addresses in our IDT and
; set them all to point to the same interupt function, which we need to
; correct because dos loads our code at some unknown address in memory and
; our IDT address values need to be the real memory address, not the offsets.
;mov ecx, 46 ; Number of IDT Interupt Functions
mov ecx, 32
mov ebx, 0 ; Start value for our loop counter
zloop:
mov eax, [int_start]
add ebx, 8
mov word [idt_start + ebx], ax
shr eax,16
mov word [idt_start+6 + ebx], ax
dec ecx
jne zloop ; if ecx is 0, end of loop
;---------------------------------------------------------------------------
cli ; Clear or disable interrupts
mov al, 0x70
mov dx, 0x80
out dx, al ; outb(0x80, 0x70) - disable NMI
lgdt[gdtr] ; Load GDT
lidt[idtr] ; Load IDT
mov eax,cr0 ; The lsb of cr0 is the protected mode bit
or al,0x01 ; Set protected mode bit
mov cr0,eax ; Mov modified word to the control register
jmp far dword [jumpOffset] ;can't just use "jmp go_pm" as where in dos!
nop ; ignore - no operation opcodes :)
nop
;---------------------------------------------------------------------------
; 32 BIT
;---------------------------------------------------------------------------
; Once we reach here where in protected mode! 32 Bit! Where not in
; the real world (mode) anymore :)
[BITS 32]
go_pm :
mov ax, 0x10 ; use our datasel selector ( alternatively mov ax, datasel )
mov ds, ax,
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov esp, 0afffh ; we need a simple stack if where calling functions!
; Such as interupt functions etc, as the return address is
; put on the stack remember!
mov word [es: 0xb8000],0x740 ; put a char to the screen!...yeahh!
; '@' in the top left of the screen if we made it
; here okay.
; Force a call to interrupt 4!
; Int 0x4 ; We call our interrupt 4 subroutine
;-------------------------------------------------------------------------
; Divide by Zero Warning
;-------------------------------------------------------------------------
; Just remember, when we do a divide by zero, and the interupt is called,
; the return address passed to the interrupt, is in fact the address of the
; line that caused the interrupt! So if we just return from the interrupt
; it would just keep causing the interrupt over and over again.
;-------------------------------------------------------------------------
; Do a divide by 0 error, so we force a call to our interrupt 0
; mov eax, 0
; mov ebx, 0
; div ebx ; eax divided by ebx, and stored back in eax
mov byte [es: 0xb8008], "B" ; poke a character onto our screen buffer
nop
nop
;-------------------------------------------------------------------------
; Where not in basics anymore!
;-------------------------------------------------------------------------
; This is the line where we go from simple settups, to using the computers
; interal hardward, fiddling around with the irqs and pic (Programmable
; Interupt Controller) etc.
;-------------------------------------------------------------------------
; Disable all IRQs.
;-------------------------------------------------------------------------
disable_irqs:
mov al, 0xFF
mov dx, 0x21
out dx, al ; outb(0x21, 0xFF)
mov al, 0xFF
mov dx, 0xA1
out dx, al ; outb(0x21, 0xFF)
;-------------------------------------------------------------------------
mov byte [es: 0xb8020], "Q" ; poke a char onto screen (debug)
mov cl, 0x20 ; PIC 1.
mov ch, 0x28 ; PIC 2.
;-------------------------------------------------------------------------
; Remap PICs to: CL = pic1 CH = pic2
;-------------------------------------------------------------------------
remap_pics:
; IWC1
;------
mov al, 0x11
mov dx, 0x20
out dx, al ; outb(0x20, 0x11)
mov al, 0x11
mov dx, 0xA0
out dx, al ; outb(0xA0, 0x11)
; IWC2
;------
mov al, cl
mov dx, 0x21
out dx, al ; outb(0x21, pic1)
mov al, ch
mov dx, 0xA1
out dx, al ; outb(0xA1, pic2)
; IWC3
;------
mov al, 0x04
mov dx, 0x21
out dx, al ; outb(0x21, 4)
mov al, 0x02
mov dx, 0xA1
out dx, al ; outb(0xA1, 2)
; IWC4
;------
mov al, 0x01
mov dx, 0x21
out dx, al ; outb(0x21, 0x01)
mov al, 0x01
mov dx, 0xA1
out dx, al ; outb(0xA1, 0x01)
;-------------------------------------------------------------------------
mov byte [es: 0xb8022], "R" ; poke a char onto screen (debug)
;-------------------------------------------------------------------------
; Enable IRQ0 (timer) at the 8259 PIC chips, disable others:
;(Port 0x21 bit 0 is timer)
mov al, 0xFE
mov dx, 0x21
out dx, al ; outb(0x21, ~0x01)
mov al, 0xFF
mov dx, 0xA1
out dx, al ; outb(0xA1, ~0x00)
mov byte [es: 0xb8024], "S" ; poke a char onto screen (debug)
;-------------------------------------------------------------------------
; Every time an irq interupt occurs, we must clear it before another irq
; is sent. Else another interupt wont' be sent till its been cleared.
; We usually call this at the end of our interupt routine.
;EOI for IRQ 0-7
mov al, 0x20
mov dx, 0x20
out dx, al ; outb(0x20, 0x20)
;-------------------------------------------------------------------------
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;16bit value - Valid range is (0-65535)
;zero (0) indicates the maximum value of 65535
;Counts down to 0 at 1.19318Mhz
;Now there are 3 counters, but where only interested in Counter 0,
;the other 2 are for ram refresh and audio etc.
;The clock freq, with which the counter is decremented is 1.19318MHz
;So to refresh all the people out there, 1/freq is the time. So
; 1.19318MHz/65535 ~ 18.1 times a second or (55ms between etc interupt)
;Bascially this is as slow as we can make our clock go, but we could
;put a counter in our timer interrupt to keep track of how many times
;its been called. For example, every 1000 times the interupt is called
;this is about 1000x0.055 or 55 seconds.
;Remember this!
;Counter 0 is the time of day interrupt and is generated
;approximately 18.2 times per sec. The value 18.2 is derived from
;the frequency 1.19318/65536 (the normal default count).
; countdown equ 8000h ; approx 36 interrupts per second
; ; e.g. 1.19318/8000h = 1.10318/32768 ~ 36
;
; mov al,00110110b ; bit 7,6 = (00) timer counter 0 \
; ; bit 5,4 = (11) write LSB then MSB |
; ; bit 3-1 = (011) generate square wave |- outb(0x43, 0x36)
; ; bit 0 = (0) binary counter |
; out 43h,al ; prep PIT, counter 0, square wave&init count /
;
; mov cx,countdown ; default is 0x0000 (65536) (18.2 per sec) \
; ; interrupts when counter decrements to 0 |
; mov al,cl ; send LSB of timer count |- out(0x40,countdown_lsb)
; out 40h,al ; |
; ; /
; mov al,ch ; send MSB of timer count \
; out 40h,al ; |- out(0x40 countdown_msb)
; ; /
;So for example, seting the counter to a value of 1234, and
;haveing it countdown, is done like this:
; outportb(0x43, 0x36);
; outportb(0x40, 0x12);
; outportb(0x40, 0x34);
;------------------------------------------------------------------------
;0x2E95 gives an interrupt rate of 100Hz.
mov al,36 ; outb(0x43, 0x36)
out 43h,al
mov al,0x2e ; default is 0x0000 (65536) (18.2 per sec)
out 40h,al ; out(0x40,countdown_lsb)
mov al,0x95 ; msb
out 40h,al ; out(0x40 countdown_msb)
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
mov word[tick_count], 0
;-------------------------------------------------------------------------
sti ; Interrupts back..
mov byte [es: 0xb8026], "T" ; poke a char onto screen (debug)
;int 0
lp: jmp lp ; loops here forever and ever...
; loops here forever and ever...
; We use 16 bits here - as you'll notice we use dw and dd only,
; and out data will be packed together nice and tight.
[BITS 16]
align 4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Our GDTR register value
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
gdtr :
dw gdt_end-gdt-1 ; Length of the gdt
dd gdt ; physical address of gdt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; This is the start of our gdt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
gdt:
gdt0
dd 0
dd 0
codesel:
dw 0x0ffff
dw 0x0000
db 0x00
db 0x09a
db 0x0cf
db 0x00
datasel:
dw 0x0ffff
dw 0x0000
db 0x00
db 0x092
db 0x0cf
db 0x00
gdt_end:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Our IDTR register value
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
idtr :
dw idt_end - idt_start - 1 ; Length of the idt
dd idt_start ; physical address of idt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; This is the start of our idt - its actual value
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Nothing special, just a very basic interrupt function so we know something
; has happened
;-------------------------------------------------------------------------
[BITS 16]
;-------------------------------------------------------------------------
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
idt_start:
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0 ; 5
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0 ; 10
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw exc, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0 ; 15
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0 ; 20
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0 ; 25
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0 ; 29
dw unexp, 8, 08e00h, 0
dw unexp, 8, 08e00h, 0
dw irq, 8, 08e00h, 0 ; 32
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0
dw irq, 8, 08e00h, 0 ; 47
idt_end:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
[bits 32]
int_start :
dd exc
dw 0x08
align 4
;-------------------
vval:
dd 0
tick_count:
dd 0
exc:
unexp:
irq:
pushad
push es
;We use a variable 'tick_count' which is incremented each time our interupt
;is called. Since in this demo only our timer is calling it, at 100 times
;a second, when the tick_count variable is 100, this is 1 seconds.
inc word [tick_count] ; increment our tick_count variable
cmp word [tick_count], 100 ; is it 100?
jl eend ; if less than 100 goto eend
mov word [tick_count], 0 ; if its more than 100 where here, and hence reset our counter
; value to 0
nop
mov ax,0x10
mov es,ax
cmp word [vval], 1
jz bbb
abb:
inc word [vval]
mov byte [es: 0xb8002], "X" ; poke a character into the graphics output screen
jmp eend
bbb:
mov dword [vval], 0
mov byte [es: 0xb8002], "Y" ; poke a character into the graphics output screen
eend:
;EOI for IRQ 0-7
mov al, 0x20
mov dx, 0x20
out dx, al ; outb(0x20, 0x20)
;To end interupts of both chips 0-15, you can use.
;For IRQ 8-15, both 8259 chips must get EOI:
;mov al, 0x20
; mov dx, 0xA0
; out dx, al ; outb(0xA0, 0x20)
;
;mov al, 0x20
; mov dx, 0x20
; out dx, al ; outb(0x20, 0x20)
pop es
popad
iret
; Small delay loop
; on a p4 2ghz its about 2 seconds :)
;-------------------------------------------------------------------
delay_loop:
mov eax, 700
xdloop:
mov ebx, 100
ydloop:
mov ecx, 100
zdloop:
dec ecx
jne zdloop
dec ebx
jne ydloop
dec eax
jne xdloop
;------------------------------------------------------------------
;-------------------------------------------------------------------------
TIMES 0x500-($-$$) DB 0x90 ; And of course, this will make our file size
; equal to 0x500 a nice round number -
; 0x500 ... so if you assemble the file
; you should find its that size exactly.
;-------------------------------------------------------------------------
|
