src/ata.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       ata.cpp, version 1.0                               *
************************************************************
*                                                          *
*ata                                                       *
*                                                          *
*30'12'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/common/io.hpp"
#include "src/ipc/lock.hpp"
#include "src/ata.hpp"

//issue an ata command, with respect to 48-bit lba
//http://forums.xbox-scene.com/index.php?act=ST&f=8&t=65206
//http://www.t13.org/docs2002/d1410r3b.pdf
struct ATAData
 {
        uint8 SectorCount, SectorCountExt;
        uint8 SectorNum, SectorNumExt;
        uint16 Cylinder, CylinderExt;
        uint8 DriveHead;
 };

void ATADelay()
 {
 }

void ATAIssueCommand(uint16 BasePort, uint8 Command, struct ATAData *dt)
 {
//if it hangs here, the lock routine will print a debug message
class IPC::Lock::lock_t l("ataissue");

        l.lock();
        IOPorts::inb(BasePort+PORT_STATUS) && ATA_BUSY;

//      while ( IOPorts::inb(BasePort+PORT_STATUS) && ATA_BUSY  ) ;
// kprintf("Elo!");
 /* 48-bit LBA */
/* this won't hurt for non 48-bit LBA commands since we re-write these registers below */
        IOPorts::outb(BasePort+PORT_SECTORCOUNT, dt->SectorCountExt);
        IOPorts::outb(BasePort+PORT_SECTORNUM, dt->SectorNumExt);
        IOPorts::outb(BasePort+PORT_CYLLOW, dt->CylinderExt & 0xff);
        IOPorts::outb(BasePort+PORT_CYLHIGH, dt->CylinderExt >> 8);

        IOPorts::outb(BasePort+PORT_SECTORCOUNT, dt->SectorCount);
        IOPorts::outb(BasePort+PORT_SECTORNUM, dt->SectorNum);
        IOPorts::outb(BasePort+PORT_CYLLOW, dt->Cylinder & 0xff);
        IOPorts::outb(BasePort+PORT_CYLHIGH, dt->Cylinder >> 8);

        IOPorts::outb(BasePort+PORT_DRIVEHEAD, dt->DriveHead);
        IOPorts::outb(BasePort+PORT_CMD, Command);

        ATADelay();
//      if (IOPorts::inb(BasePort+PORT_STATUS)&&1)
//              kprintf("error!");      //well quite a dirty hack to tell the user things went bad... but who cares? ;p
//      while ( IOPorts::inb(BasePort+PORT_STATUS) && ATA_BUSY ) ;
asm volatile ("still_going:");
        asm volatile ("inb      %dx, %al");
        asm volatile ("testb    $8, %al   ");/*        ;This means the sector buffer requires*/
//                              ;servicing.
        asm volatile("jz      still_going");/*     ;Don't continue until the sector buffer*/
                                //;is ready.    
        l.ulock();
 }

//read a sector; 48bit lba
void ATAReadSector(int nDriveIndex, void *buf, uint64 block, int byte_offset, int nbytes)
 {
ATAData dt;
uint8 ATAReadCommand;
//do we need 48bit lba?
        if( block >= 0x10000000 )
//      if (1)
         {
                dt.SectorCountExt= (nbytes/512)>>8;     //7:0
                dt.SectorCountExt= (nbytes/512)&0xff;   //15:8
                dt.CylinderExt= block>>32;              //47:32
                dt.SectorNumExt= (block>>24)&0xff;      //31:24
                dt.Cylinder= (block>>8)&0xffff; //23:8
                dt.SectorNum= block&0xff;               //7:0
                dt.DriveHead= 16*nDriveIndex | ATA_LBA;
                ATAReadCommand= ATA_READMULTIPLEEXT;
         } else
          { 
                dt.SectorNum=block&0xff;        //lower byte of block,lba
                dt.Cylinder=(block>>8)&0xffff;  //middle two bytes of block
                dt.DriveHead=0xa0|((block>>24)&0xf)|16*nDriveIndex|ATA_LBA; //bits that have to exist and lower nibble of byte 3 of block
                ATAReadCommand= ATA_READWRETRY;
          }
        dt.SectorCount=(nbytes/512)&0xff;
         ATAIssueCommand(ATA_PORT, ATAReadCommand, &dt);
int i;for(i=0;i<nbytes/2;i++)
{
unsigned short x;
asm volatile ("in %%dx, %%ax":"=a"(x):"d"(0x1f0));
//kprintf("%c%c",(char)x,(char)(x>>8));
if (i<byte_offset) continue;
((char*)buf)[i*2-byte_offset]=(char)x;
((char*)buf)[i*2+1-byte_offset]=(char)(x>>8);
}
}

//read sector with retry
void ATAReadSectorWRetryCHS(bool primarysecondary, char *buf, char head, uint32 SectorCount, char SecNum, uint16 Cylinder)
 {
//      sysfail("disabled.");
// asm("        mov     dx,1f6h");//         ;Drive and head port
// asm("        mov     al,0a0h");         ;Drive 0, head 0
//      asm("out     dx,al");
//bits: 7- always 1, 6- always 0, 5- always 1, 4- DRV- 1 for secondary drive, 0 for primary drive, 3- msb of head number to 0- lsb of head number.
        IOPorts::outb(ATA_PORT+PORT_DRIVEHEAD, 0xa0 + (primarysecondary?0x10:0) + head & 15);
//      asm("mov     dx,1f2h ");        ;Sector count port
//      asm("mov     al,1");            ;Read one sector
//      asm("out     dx,al");
//sector count to read, if 256 sectors then send 0
        IOPorts::outb(ATA_PORT+PORT_SECTORCOUNT, (SectorCount==256?0:SectorCount));
//      asm("mov     dx,1f3h ");        ;Sector number port
//      asm("mov     al,1       ");     ;Read sector one
//      asm("out     dx,al");
//send sector num
        IOPorts::outb(ATA_PORT+PORT_SECTORNUM, SecNum);
//      asm("mov     dx,1f4h ");        ;Cylinder low port
//      asm("mov     al,0       ");     ;Cylinder 0
//      asm("out     dx,al");
//send low byte of cylinder num..
        IOPorts::outb(ATA_PORT+PORT_CYLLOW, (char)Cylinder);
//      asm("mov     dx,1f5h ");        ;Cylinder high port
//      asm("mov     al,0       ");     ;The rest of the cylinder 0
//      asm("out     dx,al");
//..and high
        IOPorts::outb(ATA_PORT+PORT_CYLHIGH, (char)(Cylinder>>8));
//      asm("mov     dx,1f7h ");        ;Command port
//      asm("mov     al,20h     ");     ;Read with retry.
//      asm("out     dx,al");
        IOPorts::outb(ATA_PORT+PORT_CMD, ATA_READWRETRY);
//char buffer[512];
asm("still_going2:");
        asm("inb      %dx, %al");
        asm("testb    $8, %al   ");/*        ;This means the sector buffer requires*/
//                              ;servicing.
        asm("jz      still_going2");/*     ;Don't continue until the sector buffer*/
                                //;is ready.

//      asm("mov     $256, %cx      ");  ;One sector /2
//      asm("mov     %ax,%di"::"a"(&buffer));
//      asm("mov     dx,1f0h  ");       ;Data port - data comes in and out of here.
//      asm("rep     insw");
int i;for(i=0;i<(signed int)SectorCount*256;i++)
{
unsigned short x;
asm volatile ("in %%dx, %%ax":"=a"(x):"d"(0x1f0));
((char*)buf)[i*2]=(char)x;
((char*)buf)[i*2+1]=(char)(x>>8);

//kprintf("%c%c",(char)x,(char)(x>>8));
}
 }

void sub()
 {
char buf[512*16];
//void ATAReadSector(int nDriveIndex, void *buf, uint64 block, int byte_offset, int nbytes)
        ATAReadSector(ATA_PRIMARY, buf,0x0,0,512*2);
//      ATAReadSectorWRetryCHS(ATA_PRIMARY, buf, 1, 2, 2, 0);
int i;
kprintf("Dd");
        for (i=0;i<512*2;i++)putch((char)buf[i]);
        kprintf("D");
        for(;;);
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---