OSDev.org

Code: Select all

//Our delayed loop value. The greater this 32-bit value,
//the less our test loop will last alive:
//     ECX == 0x00000000 will last the most  (too much time)
//     ECX == 0x00000001 will last the least (finishes too fast)
//
 ecx=0xFFF00000;


while(1)
{
 ecx++;   //Increase original ECX value from 0 to 0xFFFFFFFF
          //and back to 0 when overflow takes place to control
          //the limit of this loop.



 //Test the MASTER BUS to see if the
 //Status Register (7 + 1F0h) has the
 //floating value 0xFF or 0x7F or 0x00:
 //
   al=inportb(0x1F7);
   if( al==0xFF || al==0x00 || al==0x7F )
   {
                        ;//If yes, indicate that it's FLOATING
   }



 //Test the SLAVE BUS to see if the
 //Status Register (7 + 170h) has the
 //floating value 0xFF or 0x7F or 0x00:
 //
   al=inportb(0x177);
   if( al==0xFF || al==0x00 || al==0x7F )
   {
                        ;//If yes, indicate that it's FLOATING
   }

 if(ecx==0)break;
}

Code: Select all

 _____________________________
|  M  |  S  |  Status (M-S)   |
|-----+-----+-----------------|
| No  |  No | Ma=0x00,Sl=0x51 |
| Yes |  No | Ma=0x50,Sl=0x50 |
|_____|_____|_________________|

Code: Select all

 _____________________________
|  M  |  S  |  Status (M-S)   |
|-----+-----+-----------------|
| No  | No  | Ma=0x00,Sl=0x00 |
| No  | Yes | Ma=0x00,Sl=0x50 |
| Yes | No  | Ma=0x50,Sl=0x00 |
| Yes | Yes | Ma=0x50,Sl=0x50 |
|_____|_____|_________________|

Code: Select all

 _____________________________
|  M  |  S  |  Status (M-S)   |
|-----+-----+-----------------|
| No  | No  | Ma=0x20,Sl=0x20 |
| No  | Yes | Ma=0x20,Sl=0x50 |
| Yes | No  | Ma=0x50,Sl=0x20 |
| Yes | Yes | Ma=0x50,Sl=0x50 |
|_____|_____|_________________|

Code: Select all

 _____________________________
|  M  |  S  |  Status (M-S)   |
|-----+-----+-----------------|
| No  | No  | Ma=0x2A,Sl=0x2A |
| No  | Yes | Ma=0x2A,Sl=0x50 |
| Yes | No  | Ma=0x50,Sl=0x2A |
| Yes | Yes | Ma=0x50,Sl=0x50 |
|_____|_____|_________________|

Code: Select all

org 100h
bits 16


START:

xor edi,edi
push word 0x7FE0
pop es

mov ax,0xB800
mov ds,ax
mov gs,ax




call clearscreen
mov byte[ds:0],"1"
 mov dx,0x1F0     ;Primary
 mov al,00000000b ;Master
 call identify_device_ec
   call showregs
   call printdev
     call kbwait



call clearscreen
mov byte[ds:0],"2"
 mov dx,0x1F0     ;Primary
 mov al,00010000b ;Slave
 call identify_device_ec
   call showregs
   call printdev
     call kbwait



call clearscreen
mov byte[ds:0],"3"
 mov dx,0x170     ;Secondary
 mov al,00000000b ;Master
 call identify_device_ec
   call showregs
   call printdev
     call kbwait



call clearscreen
mov byte[ds:0],"4"
 mov dx,0x170     ;Secondary
 mov al,00010000b ;Slave
 call identify_device_ec
   call showregs
   call printdev
     call kbwait





int 20h























;//AL==DEV bit value
;//DX,ES:EDI must be properly set by some other functions
;;;
identify_device_ec:
 pushad


 push edi
 push ax
  mov cx,128
  mov eax,0x01020304
  rep stosd
 pop ax
 pop edi




  add dx,6;
   out dx,al
  sub dx,6;




  add dx,7
    mov al,0xEC
    out dx,al
  sub dx,7



  ;//Wait enough time for the
  ;//IDENTIFY DEVICE
  ;//command to complete:
  ;;;
    mov cx,11  ;Wait up to 2-3 seconds
     mov bl,0xFF    ;An invalid BCD value is needed here
                    ;for the "wait_2_sec_cmos__decCX" function
                    ;which is called by the stub "atawait" routine
    .__identifydevice_ECh__waitloop:


     call atawait   ;This call alters the BL and CX registers
                    ;to keep track how many changes have
                    ;there been
     add dx,7
     in al,dx
     sub dx,7
     test al,10000000b  ;Check the BSY bit after setting the command
     jz .checkresults
                        ;If it's clear, the command has completed
                        ;and we need to check the results


    jcxz .__identifydevice_ECh__waitloop__endl
    jmp .__identifydevice_ECh__waitloop
    .__identifydevice_ECh__waitloop__endl:

     mov ax,0xB800
     mov ds,ax
     mov byte[ds:0],"\"
     int 20h




 .checkresults:

    add dx,7
     in al,dx
    sub dx,7
   test al,00001000b   ;Watch DRQ bit to see if we have data
   jnz .goget


 jmp .endall


 

 .goget:
 mov ecx,256
 rep insw


 .endall:
 popad
ret




































atawait:
 call wait_cmos__decCX
ret




























wait_cmos__decCX:
 push ax
    mov AL,0;    ;//CMOS RAM byte offset 0 (seconds)
    out 0x70,al  ;//Send the offset to the CMOS addressing port
    in al,0x71   ;//Read the BCD seconds value from CMOS data port



   ;//Change BL and CX as soon as the
   ;//seconds value changes for the times
   ;//specified in CX:
   ;;
    mov al,0
    out 0x70,al
    in al,0x71


   cmp al,bl
   je .noe
     mov BL,AL  ;//Update BL for next comparison
     dec cx     ;//Decrease CX






   .noe:


 pop ax
ret

































;Take in AL 1 value between 0 & 255 (0-FF)
;and puts the hex ASCII hex in EAX

bin2hex:
 push ebx
  and eax,11111111b

  mov ah,al

  shr al,4
  cmp al,0x09
  ja noner1
   add al,0x30
   jmp noner1_1

  noner1:
   add al,0x37

  noner1_1:



  and ah,00001111b
  cmp ah,0x09
  ja noner2
   add ah,0x30
   jmp noner2_2

  noner2:
   add ah,0x37

  noner2_2:


  mov bl,00111111b

  shl ebx,8
  mov bl,ah

  shl ebx,8
  mov bl,00111111b

  shl ebx,8
  mov bl,al


  mov eax,ebx


 pop ebx
ret












printdev:
pushad
push ds
push es

push word 0x7FE0
pop ds     ;DS==0x7FE00


mov ax,0xB840
mov es,ax  ;ES==0xB8400





mov cx,512  ;512 bytes

xor di,di
xor si,si



.loo:
 mov al,[si]
 mov byte[es:di],al
  inc si
  inc di
  inc di

dec cx
jcxz .endloo
jmp .loo
.endloo:



pop es
pop ds
popad
ret


















clearscreen:
 pusha
  ;//Try to clear the screen:
  ;;;
    mov ah,6       ;//VIDEO - SCROLL UP WINDOW
    mov al,0       ;//number of lines by which to scroll up
                   ;//(00h = clear entire window)
    mov bh,0x7     ;//attribute used to write blank lines
                   ;//at bottom of window
    xor cx,cx      ;//row,column of window's upper left corner
    mov dx,0x1950  ;//80x25 ;DH,DL row,column of window's
                   ;//lower right corner
     int 10h

  ;//Set position of cursor at top of screen:
  ;;;
    mov ah,2   ;//VIDEO - SET CURSOR POSITION
    mov bh,0   ;//page number
               ;//   0-3 in modes 2&3
               ;//   0-7 in modes 0&1
               ;//   0 in graphics modes
    xor dx,dx  ;//DH,DL row (00h is top), column (00h is left)
      int 10h
 popa
ret




















kbwait:
 xor ah,ah
 int 16h
ret

























showregs:
pushad
push ds
push es
push fs
push gs








 mov edi,0x7000
 mov ax,0
 mov ds,ax
 mov es,ax
 mov gs,ax



 mov ax,0xB800
 mov fs,ax







 ;//Now we shall read the signature:
 ;//
  ;//Try to read the master status
  ;;;

   ;Save original device register
    add dx,6
     in al,dx
    sub dx,6
    mov bl,al


    mov al,00000000b
    add dx,6
    out dx,al
    sub dx,6



   xor ax,ax ;counter
   .__signatureloopmaster:
    inc dx    ;point to 0x1F1 or 0x171
    inc al   ;count one more signature byte read

    a32 insb   ;Read 0x1F1-0x1F6 or 0x171-0x176


   cmp al,6
   jne .__signatureloopmaster
   sub dx,ax





  ;//Try to read the slave status
  ;;;
    mov al,00010000b
    add dx,6
    out dx,al
    sub dx,6



    xor ax,ax  ;counter
   .__signatureloopslave:
    inc dx    ;point to 0x1F1 or 0x171
    inc al   ;count one more signature byte read

    a32 insb   ;Read 0x1F1-0x1F6 or 0x171-0x176


   cmp al,6
   jne .__signatureloopslave
   sub dx,ax








   ;Restore original device register
    mov al,bl
    add dx,6
     out dx,al
    sub dx,6









 mov edi,0x7000
 mov ax,0
 mov ds,ax
 mov gs,ax



 mov ax,0xB800
 mov fs,ax





mov al,[gs:di]
call bin2hex
mov dword[fs:20],eax

mov al,[gs:di+1]
call bin2hex
mov dword[fs:24],eax

mov al,[gs:di+2]
call bin2hex
mov dword[fs:28],eax

mov al,[gs:di+3]
call bin2hex
mov dword[fs:32],eax

mov al,[gs:di+4]
call bin2hex
mov dword[fs:36],eax

mov al,[gs:di+5]
call bin2hex
mov dword[fs:40],eax



;;slave
mov al,[gs:di+6]
call bin2hex
mov dword[fs:48],eax

mov al,[gs:di+7]
call bin2hex
mov dword[fs:52],eax

mov al,[gs:di+8]
call bin2hex
mov dword[fs:56],eax

mov al,[gs:di+9]
call bin2hex
mov dword[fs:60],eax

mov al,[gs:di+10]
call bin2hex
mov dword[fs:64],eax

mov al,[gs:di+11]
call bin2hex
mov dword[fs:68],eax


pop gs
pop fs
pop es
pop ds
popad
ret

Code: Select all

/*****************************************************************************
ATA (IDE) hard drive detection code
Chris Giese <[email protected]>	http://my.execpc.com/~geezer
Release date: May 13, 2003
This code is public domain (no copyright).
You can do whatever you want with it.

This code based on Phoenix document
"Autotyping ATA Disk Drives", version 0.9 (July 26, 1995)

This code builds with Turbo C, DJGPP, or 16- or 32-bit Watcom C
It will NOT work inside a Windows DOS box
Not tested with ATAPI drives (e.g. IDE CD-ROMs)
*****************************************************************************/
#include <stdio.h> /* printf() */
#include <dos.h> /* inportb(), delay() */

#if defined(__WATCOMC__)
#include <conio.h>
#define	inportb(P)	inp(P)
#define	outportb(P,V)	outp(P,V)
#endif
/*****************************************************************************
*****************************************************************************/
static void msleep(unsigned milliseconds)
{
	delay(milliseconds);
}
/*****************************************************************************
*****************************************************************************/
static void nsleep(unsigned nanoseconds)
{
}
/*****************************************************************************
*****************************************************************************/
static void detect_drives(unsigned io_adr)
{
	static /*const*/ char *msg[] =
	{
		"Unknown error", "OK", "Formatter device error",
		"Sector buffer error", "ECC circuitry error",
		"Controller microprocessor errror"
	};
/**/
	unsigned timeout, byte0, byte1;

printf("Interface 0x%03X:\n", io_adr);
/* check for 0xFF; the value of a floating bus
"debounce" this value for a period of 20 ms */
	for(timeout = 20; timeout != 0; timeout--)
	{
		if(inportb(io_adr + 7) != 0xFF)
			break;
		msleep(1);
	}
/* probe cylinder registers to make absolutely sure there's no drive */
	if(timeout == 0)
	{
printf("floating bus; probing cylinder registers...\n");
		outportb(io_adr + 4, 0x55);
		outportb(io_adr + 5, 0xAA);
		byte0 = inportb(io_adr + 4);
/* if drive is present, next inportb() will read 0xAA. May read 0xAA
even if no drive (because of bus capacitance), so force 0x55 onto bus */
		outportb(0x80, 0x55);
		byte1 = inportb(io_adr + 5);
		if(byte0 != 0x55 || byte1 != 0xAA)
		{
printf("floating bus; no drive(s) present\n");
			return;
		}
	}
/* wait (xxx - how long?) until BSY=0 */
	for(timeout = 5000; timeout != 0; timeout--)
	{
		if((inportb(io_adr + 7) & 0x80) == 0)
			break;
		msleep(1);
	}
	if(timeout == 0)
	{
printf("BSY != 0; no drive(s) present\n");
		return;
	}
/* Execute Drive Diagnostics */
	outportb(io_adr + 7, 0x90);
	nsleep(400);
/* ...can take up to 5 seconds
I think you can use interrupts here, if you want */
	for(timeout = 5000; timeout != 0; timeout--)
	{
		if((inportb(io_adr + 7) & 0x80) == 0)
			break;
		msleep(1);
	}
	if(timeout == 0)
	{
printf("Execute Drive Diagnostics did not complete; no drive(s) present\n");
		return;
	}
	byte0 = inportb(io_adr + 1);	/* b0-b6=master diagnostic code */
	byte1 = byte0 & 0x7F;		/* b7=1 if slave error */
	if(byte1 >= sizeof(msg) / sizeof(msg[0]))
		byte1 = 0;
printf("  master drive: %s\n", msg[byte1]);
printf("  slave  drive: ");
	if(byte0 < 0x80)
printf("NONE\n");
	else
	{
		outportb(io_adr + 6, 0xB0); /* select slave */
		nsleep(400);
		byte0 = inportb(io_adr + 1); /* read slave diagnostic */
		byte1 = byte0 & 0x7F;
		if(byte1 >= sizeof(msg) / sizeof(msg[0]))
			byte1 = 0;
printf("%s\n", msg[byte1]);
	}
/* at this point, according to the Phoenix docs, you should
use the ATA "Identify Device" command to get the following info:
- Maximum sector count for Read Multiple and Write Multiple commands
- LBA capability	- CHS geometry
- Fastest PIO mode	- Fastest DMA mode

I would soft-reset the drive(s), then test the registers to see
if we've got ATA or ATAPI drives, and use the appropriate version
of "Identify Device" */
}
/*****************************************************************************
*****************************************************************************/
int main(void)
{
	detect_drives(0x1F0);
	detect_drives(0x170);
	return 0;
}

Code: Select all

ata_atapi_floating_test1:
pushad


;//0015 -- Write AAh to "Cylinder Low" Register (as for ATA-3)
;//also known as "LBA Mid" Register (as for ATA-6, ATA-7)
;;;
 .gotoStep0015:
   add dx,4     ;Point to the register
    mov al,0xAA
    out dx,al
   sub dx,4


;//0016 -- Write 55h to "Cylinder High" Register (as for ATA-3)
;//also known as "LBA High" Register (as for ATA-6, ATA-7)
;;;
 .gotoStep0016:
   add dx,5    ;Point to the register
    mov al,0x55
    out dx,al
   sub dx,5


;//0017 -- Write FFh to "Sector Count" Register:
;;;
 .gotoStep0017:
   add dx,2      ;Point to the register
    mov al,0xFF
    out dx,al
   sub dx,2


;//0018 -- Read "Cylinder Low" Register (as for ATA-3)
;//also known as "LBA Mid" Register (as for ATA-6, ATA-7)
;;;
 .gotoStep0018:
   add dx,4        ;Point to the register
    in al,dx
   sub dx,4


;//0019 -- Value==AAh?
;;;
 .gotoStep0019:
  cmp al,0xAA
  je .gotoStep0005  ;If yes, indicate there's something



;//0020 -- Value==FFh?
;;;
 .gotoStep0020:
  cmp al,0xFF        ;This is why this test is more specific for 0xFF
  je .gotoStep0006   ;If yes, the channel seems to be empty


 ;If not, let's .gotoStep0021



;//0021 -- Read Cylinder High Register
;;;
 .gotoStep0021:
  add dx,5
  in al,dx
  sub dx,5


;//0022 -- Value==55h?
;;;
 .gotoStep0022:
  cmp al,0x55
  je  .gotoStep0005  ;If yes, indicate there's something




  jmp .gotoStep0006  ;If not, goto "Yes, bus is floating"



.end:

popad
ret


.gotoStep0005
clc       ;INDICATE THERE IS SOMETHING
jmp .end


.gotoStep0006
stc       ;INDICATE THAT THE BUS IS FLOATING
jmp .end

Code: Select all

ata_atapi__determine_active_contacts:
 pushad


 ;Select MASTER side and read the 8 registers
 ;to decide the state of the slot
 ;;;
 call ata_atapi__master
 call ata_atapi__readregs
     or byte[read_pri_sec_master_slave],00000000b  ;clear results



   ;See if the Test 1 finds something
   ;;;
    call contacts_2
    jc .nocountmaster2     ;If CF is set, it means there's nothing here
     or byte[read_pri_sec_master_slave],00000001b   ;flag MASTER PRESENT
     jmp .mastercounted   ;If Test 1 found something, stop searching
   .nocountmaster2:



   ;If Test 1 didn't find anything, try to find something through
   ;Test 2:
   ;;;
   call check_valid_ata_regs
   jc .nocountmaster                ;If carry set, the contents are stalled

     or byte[read_pri_sec_master_slave],00000001b     ;flag MASTER PRESENT
     jmp .mastercounted   ;If Test 2 found something, ;stop searching and go
   .nocountmaster:                                    ;look for a possible slave



   .mastercounted:




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




 ;Select SLAVE side and read the 8 registers
 ;to decide the state of the slot
 ;;;
 call ata_atapi__slave
 call ata_atapi__readregs

   ;See if the Test 1 finds something
   ;;;
    call contacts_2
    jc .nocountslave2
     or byte[read_pri_sec_master_slave],00000010b  ;Flag SLAVE PRESENT
     jmp .slavecounted   ;If Test 1 found something, stop searching
   .nocountslave2:



   ;If Test 1 didn't find anything, try to find something through
   ;Test 2:
   ;;;
   call check_valid_ata_regs
   jc .nocountslave                ;If carry set, the contents are stalled

     or byte[read_pri_sec_master_slave],00000010b  ;flag SLAVE PRESENT
     jmp .slavecounted   ;If Test 2 found something, stop searching

   .nocountslave:

   .slavecounted:


  ;Debug information. Output the registers to the screen:
  ;;;
   call ata_atapi__readregs
   call ata_atapi_showregs

 popad
ret

Code: Select all

EXECUTE_DEVICE_DIAGNOSTIC_signatures:
                                     times 8 db 0   ;For Master
                                     times 8 db 0   ;For Slave




;//This routine sets the CF to 1 if there was
;//an error (nothing found) and clears it if
;//it was successful.
;//
;//The BH register will contain the command that
;//was executed so that external functions can
;//know immediately if the device was ATA or ATAPI
;//
;//If the CARRY FLAG (CF) is set to 1, the value
;//in BH is not valid for determinining a device type,
;//neither ATA nor ATAPI.
;;;
scan_for_identify_ata_atapi_command:
 push eax
 push ecx
 pushad


 ;Zero-out our special-case variables:
 ;;;
   mov ax,0x0000
   mov cx,ax

 ;Zero-out the relevant ATA registers to leave
 ;no chance of malfunction by spurious values:
 ;;;
   add dx,2
   out dx,al   ;Write sector count
   inc dx
   out dx,al   ;Write LBA Low
   inc dx
   out dx,al   ;Write LBA Mid
   inc dx
   out dx,al   ;Write LBA High
   sub dx,5


 mov bh,0xEC  ;IDENTIFY DEVICE command
 call identify_ata_atapi_device
 jnc .allok__ATAonly


  call ata_atapi__readregs
  mov eax,[EXECUTE_DEVICE_DIAGNOSTIC_signatures+1]
  mov ecx,0xEB140000
  and eax,ecx
  cmp eax,ecx
  jne .deviceisnotatapi
    mov cl,0x32   ;flag this as "special ATAPI"
    jmp .tryatapi
  .deviceisnotatapi:

 
  xor cx,cx


 .tryatapi:
  cmp cl,0x32
  jne .nospecialatapi
    mov ch,0x64  ;flag a "special ATAPI" to not discard it by error

  .nospecialatapi:


 ;//If the CARRY FLAG in the EFLAGS register is set,
 ;//we will need to execute the IDENTIFY PACKET DEVICE command
 ;;;
  mov bh,0xA1  ;IDENTIFY PACKET DEVICE command
  call identify_ata_atapi_device
  jnc .allok__specials_ATAPI

  .errors:
 ;//If the CARRY FLAG (CF) was set after that, then there is
 ;//no valid ATA-ATAPI drive for this bus and master/slave socket:
 ;;;
  stc  ;ERROR
  jmp .end


 .allok__specials_ATAPI:
;  cmp ch,0x64
;  jne .errors

;  cmp cl,0x32
;  jne .errors

  .wasspecialatapi__not_an_error:
  .allok__ATAonly:
  clc   ;All OK


 .end:
  call ata_atapi_showregs

 popad
 pop ecx
 pop eax
ret









;//BH==ECh for IDENTIFY DEVICE command
;//    A1h for IDENTIFY PACKET DEVICE command
;//EDX,ES:EDI must be properly set by some other functions
;;;
identify_ata_atapi_device:
 push eax
 push ecx
 push esi
 push edi
  mov esi,[EXECUTE_DEVICE_DIAGNOSTIC_signatures_ptr]  ;get value in the pointer


  ;//Send the requested command:
  ;;;
   add dx,7
     mov al,bh  ;Take the command that was put in BH
     out dx,al
   sub dx,7


   mov ecx,0xFFFF  ;It still might timeout some time but has been "calibrated"
   .waitdrq:       ;for the slowest device in the fastest machine I have at hand
     call ata_atapi__readregs
      mov al,[esi+7]
      test al,00001000b    ;wait for DRQ==1
      jnz .waitdrq_end

   loop .waitdrq
   .waitdrq_end:


 ;Write the DEVICE REGISTER
 ;;;
  push ax
  add dx,6
  in al,dx           ;Read DEVICE REGISTER
  or al,10000001b    ;Preserve all bits including DEV bit
                     ;and...
                       ;Set BSY and ERR/CHK
                       ;This is for some weird buses
  out dx,al            ;that are half-floating and that also
                       ;change all of their floating registers to
  sub dx,6             ;the same last value written (to the device register).
  pop ax               ;If that's the case, it will cause the bits 0 and 7
                       ;to be set to 1, even for the Status Register, which
                       ;correspond to the ERR/CHK and the BSY bits,
                       ;respectively.
                       ;
                       ;At the same time, those bits correspond to bits that
                       ;are not used for the IDENTIFY DEVICE or
                       ;IDENTIFY PACKET DEVICE commands, and correspond to
                       ;the obsolete, ATA-3 HS0 (bit 0) and a 1 (bit 7).


  call ata_atapi__readregs   ;Inform the program on the device state


;                                                                               ;   mov al,[esi]
;                                                                               ;   test al,00000100b    ;ABRT
;                                                                               ;   jnz .nocount
   mov al,[esi+7]
   test al,00000001b    ;ERR/CHK==1 is error
   jnz .nocount

   test al,00001000b    ;DRQ==0 is error
   jz .nocount


   test al,10000000b    ;BSY==1 is error
   jnz .nocount
    clc      ;All OK, the device will be counted later on
    jmp .end



 .nocount:
   stc   ;Error, the possible device will be discarded


  .end:
   pushf
   mov esi,ata_atapi_ident_buff   ;A 512-byte buffer
   mov edi,esi                    ;Put also in EDI
   call ata_atapi__r512      ;ALWAYS read the identification
   call ata_atapi__pr512     ;Put it on screen
   call ata_atapi__readregs  ;Check the state of the registers.
   popf                      ;This will also provide us with a delay
                             ;equivalent to the read of 8 registers and
                             ;at the same time will give us the complete
                             ;register state for the selected device
 pop edi
 pop esi
 pop ecx
 pop eax
ret







ata_atapi__readregs:
 pushf
 push ecx
 push edi

 mov ecx,7
 mov edi,[EXECUTE_DEVICE_DIAGNOSTIC_signatures_ptr]  ;get value in the pointer


  push dx
  .loop
   inc dx
   a32 insb

  loop .loop
  pop dx

  ror edx,16
  a32 insb
  ror edx,16


 pop edi
 pop ecx
 popf
ret

Code: Select all

REM We will try to run both NASM and YASM in case some of them is missing.
REM Since YASM produces better code, it's called last.

nasm main16.asm -o 16.com
yasm main16.asm -o 16.com
pause