U0 ATABlkSel(CBlkDev *bd,I64 blk,I64 cnt)
{
if (bd->type!=BDT_ATAPI && bd->base1)
OutU8(bd->base1+ATAR1_CTRL,0x8);
if (bd->flags & BDF_EXT_SIZE) { //48 Bit LBA?
OutU8(bd->base0+ATAR0_NSECT,cnt.u8[1]);
OutU8(bd->base0+ATAR0_SECT,blk.u8[3]);
OutU8(bd->base0+ATAR0_LCYL,blk.u8[4]);
OutU8(bd->base0+ATAR0_HCYL,blk.u8[5]);
OutU8(bd->base0+ATAR0_NSECT,cnt);
OutU8(bd->base0+ATAR0_SECT,blk);
OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
} else { //28 Bit LBA
OutU8(bd->base0+ATAR0_NSECT,cnt);
OutU8(bd->base0+ATAR0_SECT,blk);
OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4|blk.u8[3]);
}
}
Bool ATAWaitNotBUSY(CBlkDev *bd,F64 timeout)
{
I64 i;
do {
for (i=0;i<3;i++)
if (!(InU8(bd->base0+ATAR0_STAT)&ATAS_BSY))
return TRUE;
Yield;
} while (!(0<timeout<tS));
return FALSE;
}
Bool ATAWaitDRQ(CBlkDev *bd,F64 timeout)
{
I64 i;
do {
for (i=0;i<3;i++)
if (InU8(bd->base0+ATAR0_STAT)&ATAS_DRQ)
return TRUE;
Yield;
} while (!(0<timeout<tS));
return FALSE;
}
Bool ATANop(CBlkDev *bd,F64 timeout)
{
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_FEAT,0);
OutU8(bd->base0+ATAR0_CMD,ATA_NOP);
return ATAWaitNotBUSY(bd,timeout);
}
U0 ATACmd(CBlkDev *bd,U8 cmd)
{
OutU8(bd->base0+ATAR0_FEAT,0);
OutU8(bd->base0+ATAR0_CMD,cmd);
bd->last_time=tS;
PortNop;
}
Bool ATAGetRes(CBlkDev *bd,F64 timeout,U8 *buf,I64 cnt,
I64 _avail,Bool one_read)
{
I64 avail,overflow;
bd->flags&=~BDF_LAST_WAS_WRITE;
MemSet(buf,0,cnt);
while (cnt>0) {
if (!ATAWaitDRQ(bd,timeout))
return FALSE;
if (_avail)
avail=_avail;
else
avail=InU8(bd->base0+ATAR0_HCYL)<<8+InU8(bd->base0+ATAR0_LCYL);
if (avail) {
if (avail>cnt) {
overflow=avail-cnt;
avail=cnt;
} else
overflow=0;
if (avail&2)
RepInU16(buf,avail>>1,bd->base0+ATAR0_DATA);
else
RepInU32(buf,avail>>2,bd->base0+ATAR0_DATA);
cnt-=avail;
buf+=avail;
while (overflow>0) {
InU16(bd->base0+ATAR0_DATA);
overflow-=2;
if (0<timeout<tS)
return FALSE;
}
if (one_read)
break;
} else
Yield;
}
return ATAWaitNotBUSY(bd,timeout);
}
Bool ATAPIWritePktWord(CBlkDev *bd,F64 timeout,...)
{
I64 i;
for (i=0;i<argc;i++) {
if (!ATAWaitDRQ(bd,timeout))
return FALSE;
OutU16(bd->base0+ATAR0_DATA,EndianU16(argv[i]));
bd->last_time=tS;
}
return TRUE;
}
Bool ATAPISetMaxSpeed(CBlkDev *bd)
{
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,0);
OutU8(bd->base0+ATAR0_HCYL,0);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0xBB00,0xFFFF,0xFFFF,0,0,0);
return ATAWaitNotBUSY(bd,0);
}
Bool ATAPISeek(CBlkDev *bd,I64 native_blk)
{
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,0);
OutU8(bd->base0+ATAR0_HCYL,0);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x2B00,native_blk>>16,native_blk,0,0,0);
return ATAWaitNotBUSY(bd,0);
}
Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start)
{
I64 i;
if (start)
i=0x100;
else
i=0;
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
ATACmd(bd,ATA_PACKET);
//Start/Stop
if (ATAPIWritePktWord(bd,timeout,0x1B00,0,i,0,0,0))
return ATAWaitNotBUSY(bd,timeout);
else
return FALSE;
}
I64 ATAGetDevId(CBlkDev *bd,F64 timeout,Bool keep_id_record)
{
I64 res=BDT_NULL;
U16 *id_record=NULL;
if (bd->type!=BDT_ATAPI && bd->base1)
OutU8(bd->base1+ATAR1_CTRL,0x8);
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
ATACmd(bd,ATA_ID_DEV);
if (ATAWaitNotBUSY(bd,timeout)) {
if (InU8(bd->base0+ATAR0_STAT)&ATAS_ERR)
res=BDT_ATAPI;
else {
id_record=ACAlloc(512);
if (ATAGetRes(bd,timeout,id_record,512,512,FALSE))
res=BDT_ATA;
else {
Free(id_record);
id_record=NULL;
}
}
}
if (keep_id_record) {
Free(bd->dev_id_record);
bd->dev_id_record=id_record;
}
return res;
}
I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
{//Returns zero on err
I64 res=0;
Bool okay=TRUE;
if (bd->type==BDT_ATAPI) {
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
ATACmd(bd,ATA_DEV_RST);
if (!ATAWaitNotBUSY(bd,0))
okay=FALSE;
} else {
while (InU8(bd->base0+ATAR0_STAT) & ATAS_BSY) {
if (bd->flags&BDF_LAST_WAS_WRITE)
OutU16(bd->base0+ATAR0_DATA,0);
else
InU16(bd->base0+ATAR0_DATA);
Yield;
if (0<timeout<tS)
return FALSE;
}
if (ATAGetDevId(bd,timeout,TRUE)==BDT_NULL)
okay=FALSE;
else
BEqu(&bd->flags,BDf_EXT_SIZE,Bt(&bd->dev_id_record[86],10));
}
if (okay) {
if (bd->flags & BDF_EXT_SIZE && bd->base1) {
OutU8(bd->base1+ATAR1_CTRL,0x8);
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
ATACmd(bd,ATA_READ_NATIVE_MAX_EXT);
if (ATAWaitNotBUSY(bd,timeout)) {
res.u8[0]=InU8(bd->base0+ATAR0_SECT);
res.u8[1]=InU8(bd->base0+ATAR0_LCYL);
res.u8[2]=InU8(bd->base0+ATAR0_HCYL);
OutU8(bd->base1+ATAR1_CTRL,0x80);
res.u8[3]=InU8(bd->base0+ATAR0_SECT);
res.u8[4]=InU8(bd->base0+ATAR0_LCYL);
res.u8[5]=InU8(bd->base0+ATAR0_HCYL);
if (res>>24==res&0xFFFFFF) {//Kludge to make QEMU work
bd->flags&=~BDF_EXT_SIZE;
res&=0xFFFFFF;
}
}
} else {
if (bd->type!=BDT_ATAPI && bd->base1)
OutU8(bd->base1+ATAR1_CTRL,0x8);
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
ATACmd(bd,ATA_READ_NATIVE_MAX);
if (ATAWaitNotBUSY(bd,timeout)) {
res.u8[0]=InU8(bd->base0+ATAR0_SECT);
res.u8[1]=InU8(bd->base0+ATAR0_LCYL);
res.u8[2]=InU8(bd->base0+ATAR0_HCYL);
res.u8[3]=InU8(bd->base0+ATAR0_SEL) & 0xF;
}
}
}
return bd->max_blk=res;
}
I64 ATAPIReadCapacity(CBlkDev *bd,I64 *_blk_size=NULL)
{//Supposedly this can return a res +/- 75 sects.
//Error might just be for music.
Bool unlock=BlkDevLock(bd);
U32 buf[2];
if (ATAWaitNotBUSY(bd,0)) {
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,8);
OutU8(bd->base0+ATAR0_HCYL,0);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x2500,0,0,0,0,0);
if (!ATAGetRes(bd,0,buf,8,0,TRUE))
buf[0]=buf[1]=0;
} else
buf[0]=buf[1]=0;
if (unlock) BlkDevUnlock(bd);
if (_blk_size) *_blk_size=EndianU32(buf[1]);
return EndianU32(buf[0]);
}
CATAPITrack *ATAPIReadTrackInfo(CBlkDev *bd,I64 blk)
{
CATAPITrack *res=CAlloc(sizeof(CATAPITrack));
Bool unlock=BlkDevLock(bd);
if (ATAWaitNotBUSY(bd,0)) {
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,sizeof(CATAPITrack)&0xFF);
OutU8(bd->base0+ATAR0_HCYL,sizeof(CATAPITrack)>>8);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x5200,blk.u16[1],blk.u16[0],
(sizeof(CATAPITrack)&0xFF00)>>8,(sizeof(CATAPITrack)&0x00FF)<<8,0);
if (!ATAGetRes(bd,0,res,sizeof(CATAPITrack),0,TRUE)) {
Free(res);
res=NULL;
}
} else {
Free(res);
res=NULL;
}
if (unlock) BlkDevUnlock(bd);
return res;
}
Bool ATAInit(CBlkDev *bd)
{
Bool unlock=BlkDevLock(bd),okay=FALSE;
if (bd->type==BDT_ATAPI)
bd->flags&=~BDF_EXT_SIZE;
else
bd->flags|=BDF_EXT_SIZE;
if (ATAReadNativeMax(bd,tS+0.1)) {
ATABlkSel(bd,bd->max_blk,0);
if (bd->flags&BDF_EXT_SIZE)
ATACmd(bd,ATA_SET_MAX_EXT);
else
ATACmd(bd,ATA_SET_MAX);
if (ATAWaitNotBUSY(bd,0)) {
okay=TRUE;
if (bd->type==BDT_ATAPI) {
if (ATAPIStartStop(bd,0,TRUE)) {
if(!ATAPISetMaxSpeed(bd))
okay=FALSE;
} else
okay=FALSE;
}
}
}
if (unlock) BlkDevUnlock(bd);
return okay;
}
Bool ATAPIWaitReady(CBlkDev *bd,F64 timeout)
{
do {
if (!ATAWaitNotBUSY(bd,timeout) ||
!ATANop(bd,timeout) ||
!ATAPIStartStop(bd,timeout,TRUE))
return FALSE;
if (InU8(bd->base0+ATAR0_STAT) & ATAS_DRDY &&
!InU8(bd->base0+ATAR0_FEAT));
return TRUE;
ATAInit(bd);
Yield;
} while (!(0<timeout<tS));
return FALSE;
}
U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
{
I64 retries=3;
Bool unlock=BlkDevLock(bd);
retry:
ATABlkSel(bd,blk,cnt);
if (bd->flags & BDF_EXT_SIZE)
ATACmd(bd,ATA_READ_MULTI_EXT);
else
ATACmd(bd,ATA_READ_MULTI);
if (!ATAGetRes(bd,tS+1.0,buf,cnt*bd->blk_size,BLK_SIZE,FALSE)) {
if (retries--) {
ATAWaitNotBUSY(bd,0);
goto retry;
} else
throw('BlkDev');
}
blkdev.read_cnt+=(cnt*bd->blk_size)>>BLK_SIZE_BITS;
if (unlock) BlkDevUnlock(bd);
}
I64 ATAProbe(I64 base0,I64 base1,I64 unit)
{
CBlkDev bd;
MemSet(&bd,0,sizeof(CBlkDev));
bd.type=BDT_ATAPI;
bd.base0=base0;
bd.base1=base1;
bd.unit=unit;
bd.blk_size=DVD_BLK_SIZE;
return ATAGetDevId(&bd,tS+0.1,FALSE);
}
Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf,
I64 native_blk, I64 cnt,Bool lock)
{
Bool res=FALSE,unlock;
if (cnt<=0)
return FALSE;
if (lock)
unlock=BlkDevLock(bd);
if (ATAPIWaitReady(bd,timeout)) {
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
ATACmd(bd,ATA_PACKET);
if (ATAPIWritePktWord(bd,timeout,0xA800,
native_blk.u16[1],native_blk,cnt.u16[1],cnt,0) &&
ATAGetRes(bd,timeout,buf,cnt*bd->blk_size,0,FALSE)) {
blkdev.read_cnt+=(cnt*bd->blk_size)>>BLK_SIZE_BITS;
res=TRUE;
}
}
// ATAPIStartStop(bd,0,FALSE);
if (lock && unlock) BlkDevUnlock(bd);
return res;
}
U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
{
CDrv *dv=Let2Drv(bd->first_drv_let);
I64 retry,spc=bd->blk_size>>BLK_SIZE_BITS,n,blk2,
l2=bd->max_reads<<1+spc<<1;
U8 *dvd_buf=MAlloc(l2<<BLK_SIZE_BITS);
if (cnt>0) {
if (blk<=bd->max_reads)
blk2=0;
else
blk2=FloorU64(blk-bd->max_reads,spc);
if (blk2+l2>dv->size+dv->drv_offset)
l2=dv->size+dv->drv_offset-blk2;
n=(l2+spc-1)/spc;
retry=4;
while (--retry)
if (ATAPIReadBlks2(bd,tS+7.0+0.004*n,dvd_buf,blk2/spc,n,TRUE))
//n is 0x800 if max_reads. Up to 8 additional seconds
break;
if (!retry)
ATAPIReadBlks2(bd,0,dvd_buf,blk2/spc,n,TRUE);
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,dvd_buf,blk2,n*spc);
MemCpy(buf,dvd_buf+(blk-blk2)<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
}
Free(dvd_buf);
}
Bool ATARBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{
I64 n;
CBlkDev *bd=dv->bd;
while (cnt>0) {
n=cnt;
if (n>bd->max_reads)
n=bd->max_reads;
if (bd->type==BDT_ATAPI)
ATAPIReadBlks(bd,buf,blk,n);
else
ATAReadBlks(bd,buf,blk,n);
buf+=n<<BLK_SIZE_BITS;
blk+=n;
cnt-=n;
}
return TRUE;
}
U0 ATAWriteBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
{//For low level disk access.
//Use BlkWrite() instead.
I64 i,U32s_avail,sects_avail,retries=3;
F64 timeout;
Bool unlock=BlkDevLock(bd);
retry:
ATABlkSel(bd,blk,cnt);
if (bd->flags&BDF_EXT_SIZE)
ATACmd(bd,ATA_WRITE_MULTI_EXT);
else
ATACmd(bd,ATA_WRITE_MULTI);
bd->flags|=BDF_LAST_WAS_WRITE;
while (cnt>0) {
timeout=tS+1.0;
while (TRUE) {
i=InU8(bd->base0+ATAR0_STAT);
if (!(i & ATAS_DRDY)||!(i & ATAS_DRQ)) {
Yield;
} else
break;
if (/* i&ATAS_ERR||*/ tS>timeout) {
if (retries--) {
ATAWaitNotBUSY(bd,0);
goto retry;
} else
throw('BlkDev');
}
}
sects_avail=1;
U32s_avail=sects_avail<<BLK_SIZE_BITS>>2;
RepOutU32(buf,U32s_avail,bd->base0+ATAR0_DATA);
buf+=U32s_avail<<2;
cnt-=sects_avail;
retries=3;
}
ATAWaitNotBUSY(bd,0);
if (unlock) BlkDevUnlock(bd);
}
Bool ATAPISync(CBlkDev *bd)
{
Bool okay=TRUE;
if (!ATAWaitNotBUSY(bd,0))
okay=FALSE;
else {
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,0);
OutU8(bd->base0+ATAR0_HCYL,0);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x3500,0,0,0,0,0);
if (!ATAWaitNotBUSY(bd,0))
okay=FALSE;
}
return okay;
}
U0 ATAPIClose(CBlkDev *bd,I64 close_field=0x200,I64 track=0)
{//0x200 CD/DVD part 1
// 0x300 DVD part 2
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,0);
OutU8(bd->base0+ATAR0_HCYL,0);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x5B00,close_field,track,0,0,0);
ATAWaitNotBUSY(bd,0);
}
U0 ATAPIWriteBlks(CBlkDev *bd,U8 *buf, I64 native_blk, I64 cnt)
{
I64 U32s_avail;
U8 *buf2;
ATAWaitNotBUSY(bd,0);
ATAPISeek(bd,native_blk);
OutU8(bd->base0+ATAR0_FEAT,0);
OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_CMD,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x0400,native_blk.u16[1],native_blk,cnt.u16[1],cnt,0);
bd->flags|=BDF_LAST_WAS_WRITE;
ATAWaitNotBUSY(bd,0);
ATAPISeek(bd,native_blk);
if (bd->flags & BDF_EXT_SIZE)
OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
else
OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0xAA00,native_blk.u16[1],native_blk,cnt.u16[1],cnt,0);
buf2=buf+bd->blk_size*cnt;
while (buf<buf2) {
ATAWaitDRQ(bd,0);
U32s_avail=(InU8(bd->base0+ATAR0_HCYL)<<8+InU8(bd->base0+ATAR0_LCYL))>>2;
if (buf+U32s_avail<<2>buf2)
U32s_avail=(buf2-buf)>>2;
if (U32s_avail) {
RepOutU32(buf,U32s_avail,bd->base0+ATAR0_DATA);
buf+=U32s_avail<<2;
blkdev.write_cnt+=U32s_avail>>(BLK_SIZE_BITS-2);
}
}
ATAWaitNotBUSY(bd,0);
}
Bool ATAWBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{
I64 n,spc;
CBlkDev *bd=dv->bd;
Bool unlock;
spc=bd->blk_size>>BLK_SIZE_BITS;
if (bd->type==BDT_ATAPI) {
unlock=BlkDevLock(bd);
ATAPIWaitReady(bd,0);
}
while (cnt>0) {
n=cnt;
if (n>bd->max_writes)
n=bd->max_writes;
if (bd->type==BDT_ATAPI)
ATAPIWriteBlks(bd,buf,blk/spc,(n+spc-1)/spc);
else
ATAWriteBlks(bd,buf,blk,n);
buf+=n<<BLK_SIZE_BITS;
blk+=n;
cnt-=n;
blkdev.write_cnt+=n;
}
if (bd->type==BDT_ATAPI) {
ATAPISync(bd);
// ATAPIStartStop(bd,0,FALSE);
if (unlock) BlkDevUnlock(bd);
}
return TRUE;
}