---

/ata.c

Go to the documentation of this file.

/*! \file ata.c \brief IDE-ATA hard disk interface driver. */
//*****************************************************************************
//
// File Name    : 'ata.c'
// Title        : IDE-ATA interface driver for hard disks
// Author       : Pascal Stang
// Date         : 11/22/2000
// Revised      : 4/19/2003
// Version      : 0.3
// Target MCU   : Atmel AVR Series
// Editor Tabs  : 4
//
// NOTE: This code is currently below version 1.0, and therefore is considered
// to be lacking in some functionality or documentation, or may not be fully
// tested.  Nonetheless, you can expect most functions to work.
//
// This code is distributed under the GNU Public License
//      which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************

#ifndef WIN32
    #include <avr/io.h>
    #include <avr/interrupt.h>
    #include <avr/signal.h>
    #include <avr/pgmspace.h>
//  #include <stdio.h>
#endif
#include "global.h"
#include "timer.h"
#include "rprintf.h"

#include "ata.h"

//#define DEBUG_ATA 1

// global variables

// drive information
typeDriveInfo ataDriveInfo;


void ataInit(void)
{

}

void ataDriveInit(void)
{
    u08 i;
    unsigned char* buffer = (unsigned char*) SECTOR_BUFFER_ADDR;

    // read drive identity
    rprintfProgStrM("\r\nScanning IDE interface...\r\n");
    // Wait for drive to be ready
    ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);
    // issue identify command
    ataWriteByte(ATA_REG_CMDSTATUS1, 0xEC);
    // wait for drive to request data transfer
    ataStatusWait(ATA_SR_DRQ, ATA_SR_DRQ);
    timerPause(200);
    // read in the data
    ataReadDataBuffer(buffer, 512);

    // set local drive info parameters
    ataDriveInfo.cylinders =        *( ((unsigned int*) buffer) + ATA_IDENT_CYLINDERS );
    ataDriveInfo.heads =            *( ((unsigned int*) buffer) + ATA_IDENT_HEADS );
    ataDriveInfo.sectors =          *( ((unsigned int*) buffer) + ATA_IDENT_SECTORS );
    ataDriveInfo.LBAsupport =       *( ((unsigned int*) buffer) + ATA_IDENT_FIELDVALID );
    ataDriveInfo.sizeinsectors =    *( (unsigned long*) (buffer + ATA_IDENT_LBASECTORS*2) );
    // copy model string
    for(i=0; i<40; i+=2)
    {
        // correct for byte order
        ataDriveInfo.model[i  ] = buffer[(ATA_IDENT_MODEL*2) + i + 1];
        ataDriveInfo.model[i+1] = buffer[(ATA_IDENT_MODEL*2) + i    ];
    }
    // terminate string
    ataDriveInfo.model[40] = 0;

    // process and print info
    if(ataDriveInfo.LBAsupport)
    {
        // LBA support
        rprintf("Drive 0: %dMB ", ataDriveInfo.sizeinsectors/(1000000/512) );
        rprintf("LBA mode -- MODEL: ");
    }
    else
    {
        // CHS, no LBA support
        // calculate drive size
        ataDriveInfo.sizeinsectors = (unsigned long) ataDriveInfo.cylinders*
                                                ataDriveInfo.heads*ataDriveInfo.sectors;
        rprintf("Drive 0: %dMB ", ataDriveInfo.sizeinsectors/(1000000/512) );
        rprintf("CHS mode C=%d H=%d S=%d -- MODEL: ", ataDriveInfo.cylinders, ataDriveInfo.heads, ataDriveInfo.sectors );
    }
    // print model information  
    rprintfStr(ataDriveInfo.model); rprintfCRLF();

    // initialize local disk parameters
    //ataDriveInfo.cylinders = ATA_DISKPARM_CLYS;
    //ataDriveInfo.heads = ATA_DISKPARM_HEADS;
    //ataDriveInfo.sectors = ATA_DISKPARM_SECTORS;

}

void ataDiskErr(void)
{
    unsigned char b;

    b = ataReadByte(ATA_REG_ERROR); 
    rprintfProgStrM("ATA Error: "); 
    rprintfu08(b); 
    rprintfCRLF();
}

void ataSetDrivePowerMode(u08 DriveNo, u08 mode, u08 timeout)
{
    // select drive
    ataDriveSelect(DriveNo);
    // Wait for drive to be ready
    ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);

    // set mode
    switch(mode)
    {
    case ATA_DISKMODE_SPINDOWN:     ataWriteByte(ATA_REG_CMDSTATUS1, ATA_CMD_SPINDOWN); break;
    case ATA_DISKMODE_SPINUP:       ataWriteByte(ATA_REG_CMDSTATUS1, ATA_CMD_SPINUP); break;
    case ATA_DISKMODE_SETTIMEOUT:
        ataWriteByte(ATA_REG_SECCOUNT, timeout);
        ataWriteByte(ATA_REG_CMDSTATUS1, ATA_CMD_IDLE_5SU);
        break;
    case ATA_DISKMODE_SLEEP:        ataWriteByte(ATA_REG_CMDSTATUS1, ATA_CMD_SLEEP); break;
    default:
        break;
    }
}

void ataPrintSector( u08 *Buffer)
{
    u08 i;
    u16 j;
    u08 *buf;
    u08 s;

    buf = Buffer;
    
    // print the low order address indicies
    rprintfProgStrM("     00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  0123456789ABCDEF\r\n");
    rprintfProgStrM("     -----------------------------------------------  ---- ASCII -----\r\n");
    
    // print the data
    for(j=0; j<0x20; j++)
    {
        // print the high order address index for this line
        rprintfu16(j<<4);
        rprintfProgStrM(" ");

        // print the hex data
        for(i=0; i<0x10; i++)
        {
            rprintfu08(buf[(j<<4)+i]);
            rprintfProgStrM(" ");
        }
        
        // leave some space
        rprintfProgStrM(" ");

        // print the ascii data
        for(i=0; i<0x10; i++)
        {
            s = buf[(j<<4)+i]; 
            // make sure character is printable
            if(s >= 0x20)
            {
                rprintfChar(s);
            }
            else
            {
                rprintfChar(0x20);
            }

        }
        rprintfCRLF();
    }
}

void ataReadDataBuffer(u08 *Buffer, u16 numBytes)
{
    unsigned int i;

    //sbi(MCUCR, SRW);          // enable RAM waitstate

    // read data from drive
    for (i=0; i<(numBytes/16); i++)
    {
        // optimize by reading 16 bytes in-line before looping
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL);
        *Buffer++ = *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH);
    }
    //cbi(MCUCR, SRW);          // disable RAM waitstate
    
}

void ataWriteDataBuffer(u08 *Buffer, u16 numBytes)
{
    register unsigned char temp;
    unsigned int i;

    //sbi(MCUCR, SRW);          // enable RAM waitstate

    // write data to drive
    for (i=0; i<(numBytes/16); i++)     
    {
        // optimize by writing 16 bytes in-line before looping
        // keep byte order correct by using temp register
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
        temp = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAH) = *Buffer++;
        *((volatile unsigned char*) ATA_REG_BASE + ATA_REG_DATAL) = temp;
    }
    //cbi(MCUCR, SRW);          // disable RAM waitstate

}

u08 ataStatusWait(u08 mask, u08 waitStatus)
{
    register u08 status;

    delay(100);

    // wait for desired status
    while( ((status = ataReadByte(ATA_REG_CMDSTATUS1)) & mask) == waitStatus );

    return status;
}


unsigned char ataReadSectorsCHS(    unsigned char Drive, 
                                            unsigned char Head, 
                                            unsigned int Track,
                                            unsigned char Sector,
                                            unsigned int numsectors,
                                            unsigned char *Buffer)
{
    unsigned char temp;

    // Wait for drive to be ready
    temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);

    // Prepare parameters...
    ataWriteByte(ATA_REG_HDDEVSEL, 0xA0+(Drive ? 0x10:00)+Head); // CHS mode/Drive/Head
    ataWriteByte(ATA_REG_CYLHI, Track>>8);          // MSB of track
    ataWriteByte(ATA_REG_CYLLO, Track);             // LSB of track
    ataWriteByte(ATA_REG_STARTSEC, Sector);     // sector
    ataWriteByte(ATA_REG_SECCOUNT, numsectors); // # of sectors

    // Issue read sector command...
    ataWriteByte(ATA_REG_CMDSTATUS1, 0x21);

    // Wait for drive to be ready
    temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);

    if (temp & ATA_SR_ERR)
    {
        rprintfProgStrM("RD ERR\r\n");
        return 1;
    }

    // Wait for drive to request data transfer
    ataStatusWait(ATA_SR_DRQ, 0);

    // read data from drive
    ataReadDataBuffer(Buffer, 512*numsectors);

    // Return the error bit from the status register...
    temp = ataReadByte(ATA_REG_CMDSTATUS1); // read status register

    return (temp & ATA_SR_ERR) ? 1:0;
}


unsigned char ataWriteSectorsCHS(unsigned char Drive, 
                                            unsigned char Head, 
                                            unsigned int Track,
                                            unsigned char Sector,
                                            unsigned int numsectors,
                                            unsigned char *Buffer)
{
    unsigned char temp;

    // Wait for drive to be ready
    temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);

    // Prepare parameters...
    ataWriteByte(ATA_REG_HDDEVSEL, 0xA0+(Drive ? 0x10:00)+Head); // CHS mode/Drive/Head
    ataWriteByte(ATA_REG_CYLHI, Track>>8);          // MSB of track
    ataWriteByte(ATA_REG_CYLLO, Track);             // LSB of track
    ataWriteByte(ATA_REG_STARTSEC, Sector);     // sector
    ataWriteByte(ATA_REG_SECCOUNT, numsectors); // # of sectors

    // Issue write sector command
    ataWriteByte(ATA_REG_CMDSTATUS1, 0x31);

    //delay(100);

    // Wait for drive to request data transfer
    ataStatusWait(ATA_SR_DRQ, 0);

    // write data to drive
    ataWriteDataBuffer(Buffer, 512*numsectors);
    
    // Wait for drive to finish write
    temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);

    // check for errors
    if (temp & ATA_SR_ERR)
    {
        rprintfProgStrM("WR ERR\r\n");
        return 1;
    }

    // Return the error bit from the status register...
    return (temp & ATA_SR_ERR) ? 1:0;
}

unsigned char ataReadSectorsLBA(    unsigned char Drive, 
                                            unsigned long lba,
                                            unsigned int numsectors,
                                    unsigned char *Buffer)
{
    unsigned int cyl, head, sect;
    unsigned char temp;

#ifdef DEBUG_ATA
    rprintfProgStrM("ATA LBA read ");
    rprintfu32(lba); rprintfProgStrM(" ");
    rprintfu16(numsectors); rprintfProgStrM(" ");
    rprintfu16((unsigned int)Buffer); 
    rprintfCRLF();
#endif

    sect = (int) ( lba & 0x000000ffL );
    lba = lba >> 8;
    cyl = (int) ( lba & 0x0000ffff );
    lba = lba >> 16;
    head = ( (int) ( lba & 0x0fL ) ) | ATA_HEAD_USE_LBA;

    temp = ataReadSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );

    if(temp)
        ataDiskErr();
    return temp;
}

unsigned char ataWriteSectorsLBA(   unsigned char Drive, 
                                                unsigned long lba,
                                                unsigned int numsectors,
                                        unsigned char *Buffer)
{
    unsigned int cyl, head, sect;
    unsigned char temp;

#ifdef DEBUG_ATA
    rprintfProgStrM("ATA LBA write ");
    rprintfu32(lba); rprintfProgStrM(" ");
    rprintfu16(numsectors); rprintfProgStrM(" ");
    rprintfu16((unsigned int)Buffer); 
    rprintfCRLF();
#endif

    sect = (int) ( lba & 0x000000ffL );
    lba = lba >> 8;
    cyl = (int) ( lba & 0x0000ffff );
    lba = lba >> 16;
    head = ( (int) ( lba & 0x0fL ) ) | ATA_HEAD_USE_LBA;

    temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );

    if(temp)
        ataDiskErr();
    return temp;
}                                   


unsigned char ataReadSectors(   unsigned char Drive, 
                                        unsigned long lba,
                                        unsigned int numsectors,
                                unsigned char *Buffer)
{
    unsigned int cyl, head, sect;
    unsigned char temp;

    // check if drive supports native LBA mode
    if(ataDriveInfo.LBAsupport)
    {
        // drive supports using native LBA
        temp = ataReadSectorsLBA(Drive, lba, numsectors, Buffer);
    }
    else
    {
        // drive required CHS access
        #ifdef DEBUG_ATA
            // do this defore destroying lba
            rprintfProgStrM("ATA LBA for CHS read: ");
            rprintfProgStrM("LBA="); rprintfu32(lba); rprintfProgStrM(" ");
        #endif

        // convert LBA to pseudo CHS
        // remember to offset the sector count by one
        sect = (u08) (lba % ataDriveInfo.sectors)+1;
        lba = lba / ataDriveInfo.sectors;
        head = (u08) (lba % ataDriveInfo.heads);
        lba = lba / ataDriveInfo.heads;
        cyl = (u16) lba;

        #ifdef DEBUG_ATA
            rprintfProgStrM("C:H:S=");
            rprintfu16(cyl); rprintfProgStrM(":");
            rprintfu08(head); rprintfProgStrM(":");
            rprintfu08(sect); rprintfCRLF();
        #endif

        temp = ataReadSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );
    }

    if(temp)
        ataDiskErr();
    return temp;
}


unsigned char ataWriteSectors(unsigned char Drive, 
                                        unsigned long lba,
                                        unsigned int numsectors,
                                unsigned char *Buffer)
{
    unsigned int cyl, head, sect;
    unsigned char temp;

    // check if drive supports native LBA mode
    if(ataDriveInfo.LBAsupport)
    {
        // drive supports using native LBA
        temp = ataWriteSectorsLBA(Drive, lba, numsectors, Buffer);
    }
    else
    {
        // drive required CHS access
        #ifdef DEBUG_ATA
            // do this defore destroying lba
            rprintfProgStrM("ATA LBA for CHS write: ");
            rprintfProgStrM("LBA="); rprintfu32(lba); rprintfProgStrM(" ");
        #endif

        // convert LBA to pseudo CHS
        // remember to offset the sector count by one
        sect = (u08) (lba % ataDriveInfo.sectors)+1;
        lba = lba / ataDriveInfo.sectors;
        head = (u08) (lba % ataDriveInfo.heads);
        lba = lba / ataDriveInfo.heads;
        cyl = (u16) lba;

        #ifdef DEBUG_ATA
            rprintfProgStrM("C:H:S=");
            rprintfu16(cyl); rprintfProgStrM(":");
            rprintfu08(head); rprintfProgStrM(":");
            rprintfu08(sect); rprintfCRLF();
        #endif

        temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );
    }

    if(temp)
        ataDiskErr();
    return temp;
}                                   

void ataDriveSelect(u08 DriveNo)
{
    ataWriteByte(ATA_REG_HDDEVSEL, 0xA0+(DriveNo ? 0x10:00)); // Drive selection
}
 
//----------------------------------------------------------------------------
// Set drive mode (STANDBY, IDLE)
//----------------------------------------------------------------------------
/*#define STANDBY 0
#define IDLE    1
#define SLEEP   2 
*/ 

/*
unsigned char SetMode(unsigned char DriveNo, unsigned char Mode, unsigned char PwrDown) 
{
  WriteBYTE(CMD, 6, 0xA0 + (DriveNo ? 0x10:0x00)); // Select drive
  WriteBYTE(CMD, 2, (PwrDown ? 0x01:0x00)); // Enable automatic power down
  switch (Mode) 
  {
    case STANDBY: WriteBYTE(CMD,7, 0xE2); break;
    case IDLE:    WriteBYTE(CMD,7, 0xE3); break;
    // NOTE: To recover from sleep, either issue a soft or hardware reset !
    // (But not on all drives, f.ex seagate ST3655A it's not nessecary to reset
    // but only to go in Idle mode, But on a Conner CFA170A it's nessecary with
    // a reset)
    case SLEEP:   WriteBYTE(CMD,7, 0xE6); break;
  }
  Timer10mSec=10000;
  while ((ReadBYTE(CMD,7) & 0xC0)!=0x40 && Timer10mSec); // Wait for DRDY & NOT BUSY 
  if (Timer10mSec==0) return 0xFF;                       //   or timeout
 
  // Return the error register...
  return ReadBYTE(CMD, 1);
}

*/

u08 ataReadByte(u08 reg)
{
    register u08 ret;
    //sbi(MCUCR, SRW);          // enable RAM waitstate
    ret = *((volatile unsigned char*) ATA_REG_BASE + reg);
    //cbi(MCUCR, SRW);          // disable RAM waitstate
    return ret;
}

void ataWriteByte(u08 reg, u08 data)
{
    //sbi(MCUCR, SRW);          // enable RAM waitstate
    *((volatile unsigned char*) ATA_REG_BASE + reg) = data;
    //cbi(MCUCR, SRW);          // disable RAM waitstate
}

 
void ataShowRegisters(unsigned char DriveNo) 
{ 
    ataWriteByte(ATA_REG_HDDEVSEL, 0xA0 + (DriveNo ? 0x10:0x00)); // Select drive
    
    rprintfProgStrM("Reg 0=");  rprintfu08(ataReadByte(ATA_REG_DATAL    )); rprintfProgStrM(" ");
    rprintfProgStrM("1=");      rprintfu08(ataReadByte(ATA_REG_ERROR    )); rprintfProgStrM(" ");
    rprintfProgStrM("2=");      rprintfu08(ataReadByte(ATA_REG_SECCOUNT));  rprintfProgStrM(" ");
    rprintfProgStrM("3=");      rprintfu08(ataReadByte(ATA_REG_STARTSEC));  rprintfProgStrM(" ");
    rprintfProgStrM("4=");      rprintfu08(ataReadByte(ATA_REG_CYLLO    )); rprintfProgStrM(" ");
    rprintfProgStrM("5=");      rprintfu08(ataReadByte(ATA_REG_CYLHI    )); rprintfProgStrM(" ");
    rprintfProgStrM("6=");      rprintfu08(ataReadByte(ATA_REG_HDDEVSEL));  rprintfProgStrM(" ");
    rprintfProgStrM("7=");      rprintfu08(ataReadByte(ATA_REG_CMDSTATUS1));    rprintfProgStrM("\n\r");
} 

unsigned char ataSWReset(void)
{
    ataWriteByte(ATA_REG_HDDEVSEL, 0x06);   // SRST and nIEN bits
    delay(10);  // 10uS delay
    ataWriteByte(ATA_REG_HDDEVSEL, 0x02);   // nIEN bits
    delay(10);  // 10 uS delay
   
   while( (ataReadByte(ATA_REG_CMDSTATUS1) & 0xC0) != 0x40 ); // Wait for DRDY and not BSY
    
    return ataReadByte(ATA_REG_CMDSTATUS1) + ataReadByte(ATA_REG_ERROR);
}

/*
unsigned char ATA_Idle(unsigned char Drive)
{

  WriteBYTE(CMD, 6, 0xA0 + (Drive ? 0x10:0x00)); // Select drive
  WriteBYTE(CMD,7, 0xE1);

  while ((ReadBYTE(CMD,7) & 0xC0)!=0x40); // Wait for DRDY & NOT BUSY 

  // Return the error register...
  return ReadBYTE(CMD, 1);
}
*/

---