ata_command_block.hpp

#if !defined(__ATA_COMMAND_BLOCK_HPP__)
#define __ATA_COMMAND_BLOCK_HPP__

//
// local includes
//
#include "core/common.hpp"

/*
 * ATA/ATAPI-7 feature sets:
 *
 *   PACKET Command feature set
 *   Power Management feature set
 *   Advanced Power Management feature set
 *   Security Mode feature set
 *   SMART (Self-monitoring, analysis, and reporting technology) feature set
 *   Host Protected Area feature set
 *   CompactFlash Association (CFA) feature set
 *   Removable Media Status Notification and Removable Media feature sets
 *   Power-Up In Standby feature set
 *   Automatic Acoustic Management (AAM) feature set
 *   48-bit Address feature set
 *   Device Configuration Overlay feature set
 *   Media Card Pass Through Command feature set
 *   Streaming feature set
 *   General Purpose Logging feature set
 *   Overlapped feature set
 *   Queued feature set
 *   Long Physical Sector Feature Set for Non-Packet Devices
 *   Long Logical Sector Feature Set for Non-Packet Devices
 */

//
// ATA/ATAPI command block (usually at 0x1f0/0x170)
//
struct __packed(ata_command_block) : public register_block<uint8_t, little_endian>
{
    enum ata_commands
    {
        //
        // mandatory General Feature Set commands (for all devices capable of
        //     reading their media that do not implement the PACKET command feature set)
        //
        COMMAND_EXECUTE_DEVICE_DIAGNOSTIC    = 0x90,
        COMMAND_IDENTIFY_DEVICE              = 0xec,
        COMMAND_READ_DMA                     = 0xc8,
        COMMAND_READ_MULTIPLE                = 0xc4,
        COMMAND_READ_SECTORS                 = 0x20,
        COMMAND_READ_VERIFY_SECTORS          = 0x40,
        COMMAND_SET_FEATURES                 = 0xef,
        COMMAND_SET_MULTIPLE_MODE            = 0xc6,

        //
        // additional mandatory General Feature Set commands (for all devices capable of
        //     writing their media that do not implement the PACKET command feature set)
        //
        COMMAND_FLUSH_CACHE                  = 0xe7,
        COMMAND_WRITE_DMA                    = 0xca,
        COMMAND_WRITE_MULTIPLE               = 0xc5,
        COMMAND_WRITE_SECTORS                = 0x30,

        //
        // optional General Feature Set commands
        //     (for all devices not implementing the PACKET command feature set)
        //
        COMMAND_DOWNLOAD_MICROCODE           = 0x92,
        COMMAND_NOP                          = 0x00,
        COMMAND_READ_BUFFER                  = 0xe4,
        COMMAND_WRITE_BUFFER                 = 0xe8,

        //
        // mandatory Removable Media Status Notification Feature Set commands
        //     (for all devices that do not implement the PACKET command feature set)
        //
        COMMAND_GET_MEDIA_STATUS             = 0xda,
        COMMAND_MEDIA_EJECT                  = 0xed,

        //
        // optional Removable Media Status Notification Feature Set commands
        //     (for all devices that do not implement the PACKET command feature set)
        //
        COMMAND_MEDIA_LOCK                   = 0xde,
        COMMAND_MEDIA_UNLOCK                 = 0xdf,
        // ... and additionally COMMAND_SET_FEATURES (enable/disable media status notification)

        //
        // other relevant commands
        //
        COMMAND_INITIALIZE_DEVICE_PARAMETERS = 0x91,
        COMMAND_RECALL_INTERRUPT             = 0x10
    };

    enum atapi_commands
    {
        //
        // mandatory General Feature Set commands (for all devices capable of
        //     reading their media that implement the PACKET command feature set)
        //
        COMMAND_IDENTIFY_PACKET_DEVICE       = 0xa1,
        // ...
    };

    //
    // specific bits
    //
    static const uint8_t DEVICE_REGISTER_DEVICE_BIT = 4;

    //
    // data register at offset: 0x00
    //
    uint8_t data;

    //
    // error (read) / features (write) register at offset: 0x01
    //
    union
    {
        union
        {
            uint8_t raw;

            struct __packed()
            {
              #if LITTLE_ENDIAN_BITFIELD
                unsigned bad_address_mark       : 1;    // bit 0
                unsigned track0_not_found       : 1;    // bit 1
                unsigned command_aborted        : 1;    // bit 2
                unsigned media_change_requested : 1;    // bit 3
                unsigned ID_field_not_found     : 1;    // bit 4
                unsigned medium_changed         : 1;    // bit 5
                unsigned write_protected        : 1;    // bit 6
                unsigned CRC_error              : 1;    // bit 7
              #elif BIG_ENDIAN_BITFIELD
                unsigned CRC_error              : 1;    // bit 7
                unsigned write_protected        : 1;    // bit 6
                unsigned medium_changed         : 1;    // bit 5
                unsigned ID_field_not_found     : 1;    // bit 4
                unsigned media_change_requested : 1;    // bit 3
                unsigned command_aborted        : 1;    // bit 2
                unsigned track0_not_found       : 1;    // bit 1
                unsigned bad_address_mark       : 1;    // bit 0
              #else
                #error unknown bitfield order. fix this.
              #endif
            };

            ACCESS_FUNCTORS(void, uint8_t, raw)
            NUMERIC_ACCESS_OPERATORS(void, uint8_t, raw)
            ANONYMOUS_INCREMENT_OPERATORS(raw)
        } error;

        uint8_t features;
    };

    //
    // sector count (ATA or ATAPI write) / interrupt reason (ATAPI read) at offset: 0x02
    //
    union
    {
        uint8_t sector_count,
                interrupt_reason;
    };

    //
    // sector address at offsets: 0x03-0x05
    //
    union
    {
        //
        // ATA-7: LBA low, mid & high registers
        //
        struct __packed()
        {
            uint8_t low, mid, high;
        } LBA;

        //
        // ATAPI-7: LBA low & byte count low & high registers
        //
        struct __packed()
        {
            uint8_t dummy03;                            // placement dummy

            union
            {
                le_uint16_t raw;

                struct __packed()
                {
                    uint8_t low, high;
                };

                ACCESS_FUNCTORS(void, uint16_t, raw)
                NUMERIC_ACCESS_OPERATORS(void, uint16_t, raw)
                NUMERIC_ACCESS_OPERATORS(void, le_uint16_t, raw)
                ANONYMOUS_INCREMENT_OPERATORS(raw)
            } byte_count;
        };
    };

    //
    // device register at offset: 0x06
    //
    union device
    {
        uint8_t raw;

        struct __packed()
        {
          #if LITTLE_ENDIAN_BITFIELD
            unsigned bit0                       : 1;    // bit 0 (command dependent)
            unsigned bit1                       : 1;    // bit 1 (command dependent)
            unsigned bit2                       : 1;    // bit 2 (command dependent)
            unsigned bit3                       : 1;    // bit 3 (command dependent)
            unsigned dev                        : 1;    // bit 4 (0 = master, 1 = slave)
            unsigned obsolete5                  : 1;    // bit 5 (obsolete as of ATA/ATAPI-7)
            unsigned lba                        : 1;    // bit 6 (LBA addressing: 0 = off, 1 = on)
            unsigned obsolete7                  : 1;    // bit 7 (obsolete as of ATA/ATAPI-7)
          #elif BIG_ENDIAN_BITFIELD
            unsigned obsolete7                  : 1;    // bit 7 (obsolete as of ATA/ATAPI-7)
            unsigned lba                        : 1;    // bit 6 (LBA addressing: 0 = off, 1 = on)
            unsigned obsolete5                  : 1;    // bit 5 (obsolete as of ATA/ATAPI-7)
            unsigned dev                        : 1;    // bit 4 (0 = master, 1 = slave)
            unsigned bit3                       : 1;    // bit 3 (command dependent)
            unsigned bit2                       : 1;    // bit 2 (command dependent)
            unsigned bit1                       : 1;    // bit 1 (command dependent)
            unsigned bit0                       : 1;    // bit 0 (command dependent)
          #else
            #error unknown bitfield order. fix this.
          #endif
        };

        ACCESS_FUNCTORS(device&, uint8_t, raw)
        NUMERIC_ACCESS_OPERATORS(device&, uint8_t, raw)
        INCREMENT_OPERATORS(device, raw)
    } device;

    //
    // status (read) / command (write) register at offset: 0x07
    //
    union
    {
        union
        {
            uint8_t raw;

            struct __packed()
            {
              #if LITTLE_ENDIAN_BITFIELD
                unsigned error                  : 1;    // bit 0
                unsigned index                  : 1;    // bit 1 (obsolete as of ATA/ATAPI-7)
                unsigned ECC_error_corrected    : 1;    // bit 2 (obsolete as of ATA/ATAPI-7)
                unsigned data_requested         : 1;    // bit 3
                unsigned seek                   : 1;    // bit 4 (command dependent)
                unsigned device_fault           : 1;    // bit 5 (often called "write error")
                unsigned device_ready           : 1;    // bit 6
                unsigned busy                   : 1;    // bit 7
              #elif BIG_ENDIAN_BITFIELD
                unsigned busy                   : 1;    // bit 7
                unsigned device_ready           : 1;    // bit 6
                unsigned device_fault           : 1;    // bit 5 (often called "write error")
                unsigned seek                   : 1;    // bit 4 (command dependent)
                unsigned data_requested         : 1;    // bit 3
                unsigned ECC_error_corrected    : 1;    // bit 2 (obsolete as of ATA/ATAPI-7)
                unsigned index                  : 1;    // bit 1 (obsolete as of ATA/ATAPI-7)
                unsigned error                  : 1;    // bit 0
              #else
                #error unknown bitfield order. fix this.
              #endif
            };

            ACCESS_FUNCTORS(void, uint8_t, raw)
            NUMERIC_ACCESS_OPERATORS(void, uint8_t, raw)
            ANONYMOUS_INCREMENT_OPERATORS(raw)
        } status;

        uint8_t command;
    };

    //
    // constructor
    //
    inline ata_command_block(void)
    {
        memset(this, 0, static_unsigned_min<sizeof(ata_command_block), 8>::value);
    }

    //
    // offset evaluation functions
    //
    static inline bool is_data(const offset_t offset)
    {
        return offset == 0x00;
    }

    static inline bool is_error_features(const offset_t offset)
    {
        return offset == 0x01;
    }

    static inline bool is_device(const offset_t offset)
    {
        return offset == 0x06;
    }

    static inline bool is_command(const offset_t offset)
    {
        return offset == 0x07;
    }

    static inline bool is_status(const offset_t offset)
    {
        return offset == 0x07;
    }

    //
    // status functions (affecting error & status register)
    //
    inline void status_ok(void)
    {
        error=0;
        status.device_fault=status.error=0;
        status.device_ready=status.seek=1;
        status.busy=status.data_requested=0;
    }

    inline void status_ok_busy(void)
    {
        status_ok();
        status.busy=1;
    }

    inline void status_ok_data_requested(void)
    {
        status_ok();
        status.data_requested=1;
    }

    inline void status_error(void)
    {
        status_ok();
        status.error=1;
    }

    inline void status_aborted(void)
    {
        status_error();
        error.command_aborted=1;
    }

    //
    // address functions
    //
    inline uint32_t lba28_sector_address(void) const
    {
        assertd(L4VMM_DEBUG_ATA, device.lba);
        return static_cast<uint32_t>(LBA.low) |
                   (static_cast<uint32_t>(LBA.mid) << 8) |
                   (static_cast<uint32_t>(LBA.high) << 16) |
                   (static_cast<uint32_t>(device & 0x0f) << 24);
    }

    inline void lba28_sector_address(const uint32_t address)
    {
        assertd(L4VMM_DEBUG_ATA, device.lba);
        LBA.low=address;
        LBA.mid=address >> 8;
        LBA.high=address >> 16;
        device=(device & 0xf0) | ((address >> 24) & 0x0f);
    }

    inline uint16_t lba28_sector_count(void) const
    {
        // 0 usually means 256 sectors
        return sector_count ? sector_count : 256;
    }

    //
    // signature functions
    //
    inline void ata_signature(const bool clear_device_bit=false)
    {
        sector_count=LBA.low=0x01;
        LBA.mid=LBA.high=0x00;
        device&=clear_device_bit ? 0x00 : 0x10;
    }

    inline void atapi_signature(const bool clear_device_bit=false)
    {
        interrupt_reason=LBA.low=0x01;
        byte_count.low=0x14;
        byte_count.high=0xeb;
        device&=clear_device_bit ? 0x00 : 0x10;
    }

    //
    // get descriptional register names
    //
    static inline const char *ata_register_name(const offset_t offset)
    {
        static const char *names[] = {"data", "error/features", "sector count", "LBA low",
                                      "LBA mid", "LBA high", "device", "status/command"};
        return names[offset & 0x07];
    }

    static inline const char *atapi_register_name(const offset_t offset)
    {
        static const char *names[] = {"data", "error/features", "interrupt reason", "LBA_low",
                                      "byte count low", "byte count high", "device select",
                                      "status/command"};
        return names[offset & 0x07];
    }
};

static_assert(sizeof(ata_command_block) == 8, "ata_command_block's size must be 8");

#endif

// ***** end of source ***** //