Thema: findet einer von euch den fehler????? klappt einfach nicht

[bsunisol]

hallo leute,
ich habe ein problem beim berechnen von LBA -> CHS.
die rechnung funktioniert nur bei bestimmten werden für LBA. wenn ich in einer Schleife von 0x0B3F (2879) runterzähle, und einzeln alle CHS's berechnen will, bleibt BOCHS einfach stehen. und wenn ich den rechner damit boote auch, nur mit dem unterschied, dass er auch keine text schreibt, nur die werte in den variablen.

weiß einer von euch woran das liegen könnte?

danke im voraus
Uni_Sol

hier der quelltext zum berechnen:

Code: [Auswählen]

CODE_SECTION:

; Interrups verbieten
         cli

; Stack setzen
         mov ax, 0x9000
         mov ss, ax
         xor sp, sp

;Kernel suchen und laden
        ;xor ax, ax ; diskreset
         ;xor dx, dx
         ;int 13h

         mov cx, 0x0B3F
         main_loop:
         mov ax, cx
         xor dx, dx ; CHS berechnen
         mov bx, 0x24
         div bx
         mov [Cylinder], dl

         mov ax, dx
         mov bx, 0x12
         xor dx, dx
         div bx
         mov [Head], dl

         mov ax, dx
         inc al
         mov [Sector], al

         call _dump

         xor ax, ax
         int 16h
         loop main_loop

push MsgBootError
         call _print
         inc sp
         inc sp

         ; Reboot nach tastendruck
xor ax, ax
         int 0x16
         db 0xEA
         dw 0x0000
         dw 0xFFFF

hier der dump:

Code: [Auswählen]

_dump:
          pusha

                 push Cyl
                 call _print
                 inc sp
                 inc sp
          mov ax, [Cylinder]
                 mov cx, 0x08
                 mov bx, 0x02
                 lp1:
                 div bx
                 push ax
                 mov al, dl
                 add ax, 0x0E30
                 int 10h
                 pop ax
                 loop lp1
                 mov ax, 0x0E0D
                 int 10h
                 mov ax, 0x0E0A
                 int 10h

push Hea
                 call _print
                 inc sp
                 inc sp
mov ax, [Head]
                 mov cx, 0x08
                 lp2:
                 div bx
                 push ax
                 mov ax, dx
                 add ax, 0x0E30
                 int 10h
                 pop ax
                 loop lp2
mov ax, 0x0E0D
                 int 10h
                 mov ax, 0x0E0A
                 int 10h

push Sec
                 call _print
                 inc sp
                 inc sp
mov ax, [Sector]
                 mov cx, 0x08
                 lp3:
                 div bx
                 push ax
                 mov ax, dx
                 add ax, 0x0E30
                 int 10h
                 pop ax
                 loop lp3

                 mov cx, 2
                 lp4:
mov ax, 0x0E0D
                 int 10h
                 mov ax, 0x0E0A
                 int 10h
                 loop lp4

                 popa
          ret

print:

Code: [Auswählen]

_print:
          push bp
                 mov bp, sp
                 pusha

                 mov si, [Param0]
                 mov ah, 0x0E
                 xor bx, bx
                 __print_1:
                  lodsb
                         or al, al
                           jz __print_2
                         int 10h
                         jmp __print_1
                 __print_2
popa
                         mov sp, bp
                 pop bp
          ret

hier noch die variablen:

Code: [Auswählen]

DATA_SECTION:
Cylinder db 0x00
         Head db 0x00
         Sector db 0x00

[Jidder]

Ich glaube deine Formel ist falsch (oder zumindest zu kompliziert). Ich nutze die hier, und hatte nie Probleme damit (evtl. weil ich nicht ausgiebig getestet hab):

(cylinder = track)

sector = (lba % sectors_per_track) + 1
head = (lba / sectors_per_track) % heads
track = (lba / sectors_per_track) / heads

in assembler:

Code: [Auswählen]

; dx:ax = LBA
div word [SECTORS_PER_TRACK]
inc dx
; dx = sector (jetzt irgendwo sichern)
xor dx, dx
div word [NUM_HEADS]
; ax = track
; dx = head

SECTORS_PER_TRACK und NUM_HEADS werden bei mir offensichtlich aus dem RAM gelesen. Du müsstet sie vermutlich nach bx laden, und durch bx dividieren.

[bsunisol]

mach ich das nicht genau so?
nur in einer anderen reihenfolge?

ich blicke bei dir nicht so recht durch:
wieso ist DX:AX der LBA wert? für div muss er doch in (E)AX stehen??

aber danke.

[Jidder]

nein, wenn du durch ein word dividierst, ist dx:ax der dividend. genau so machst du das ja auch in deinem code. wenn du durch ein dword dividierst, ist edx:eax der dividend. nur wenn du durch ein byte dividierst ist ax der dividend. der dividend ist immer doppelt so groß wie der divisor.

[bsunisol]

ahh ok ich gebe mich geschlagen.
habs in der nasm-doc verplant.
thx

d.h. ich muss

Code: [Auswählen]

xor ax, ax
mov bx, LBA ; OHNE [] da adr
div [SPT]
mov [Sector], dx

hab ich das richtig verstanden?

[bsunisol]

sry, aber geht immer noch nicht.....
egal ob ich "[]" benutze oder nicht. er rechnet nur müll aus

Code: [Auswählen]

xor dx, dx
         mov ax, LBA
div WORD [SecPerTrack]
         inc dl
         mov [Sector], dl
         mov [LBA], ax
         xor dx, dx
         mov ax, LBA
         div WORD [NumHeads]
         mov [Cylinder], al
         mov [Head], dl

         call _dump

er macht nur müll, hier ein bochs ausschnitt:

Cylinder : 01
Head ... : 00000000
Sektor . : 10001000

OSLDR fehlt
Neustart mit beliebiger Taste

das gibt er mir bei LBA = 0x0000 aus.
DENKT DARAN DASS DIE BINÄRZAHLEN SPIEGELBILDLICH SIND:
11000001 <=> 10000011

[Jidder]

Bin ich eben erst drauf gestroßen: [SecPerTrack] ist kein word sondern ein byte. Zumindest im FAT Header, welchen ich als Quelle nutze.

[maumo]

laut microsoft dokument ist s ein word xD

BPB_SecPerTrk Offset:24 Size:2

Sectors per track for interrupt 0x13. This field is only relevant for
media that have a geometry (volume is broken down into tracks by
multiple heads and cylinders) and are visible on interrupt 0x13.
This field contains the “sectors per track” geometry value.

[Jidder]

Du hast natürlich recht. Ich habe eben echt die ganze Zeit gedacht Cluster und Track wären das gleiche ...

Ok, dann denke ich, dass ich für heute gleich wieder Schluss mache mit Versuchen irgendwas zu reparieren und mich was einfachem wie Fernsehen widme