ata_drive.hpp

#if !defined(__ATA_DRIVE_HPP__)
#define __ATA_DRIVE_HPP__

//
// local includes
//
#include "core/drivers/block/block_driver.hpp"
#include "core/machine/machine_base.hpp"
#include "ata_command_block.hpp"
#include "ata_control_block.hpp"

struct ata_drive : public block_driver_constants, private noncopyable
{
    static const uint8_t MAX_MULTIPLE_SECTORS = 128;

    static const uint32_t BUFFER_SIZE = SECTOR_SIZE * 256;

    //
    // keep in sync with block_driver::state_flags_constants
    //
    enum state_flags_constants
    {
        REMOVABLE   = 1 << (static_log2<block_driver::ALL_MASK>::value + 1),
        FAKE_IO     = REMOVABLE << 1,

        ALL_MASK    = block_driver::ALL_MASK | REMOVABLE | FAKE_IO
    };

    typedef bitmask<uint_value_t<ALL_MASK>::least> state_flags;
    static_assert(integer_traits<state_flags::word_type>::const_max >= ALL_MASK,
                  "state_flags's max value is too small");

  protected:
    string drive_name;

    machine_base &machine;

    l4_irq_t irq;

    ata_command_block command_block;

    ata_control_block control_block;

    block_driver * const driver;

    state_flags state;

    uint8_t multiple_sectors;

    uint8_t last_command;

    struct geometry
    {
        enum chs_constants
        {
            MAX_CYLINDERS = 65536,
            MAX_HEADS     = 16,             // 256 for larger disks
            MAX_SECTORS   = 255
        };

        l4_sector_t total_sectors;
        uint32_t    cylinders;
        uint16_t    heads;
        uint8_t     sectors;

        inline uint32_t get_cylinders(const uint16_t heads, const uint8_t sectors)
        {
            return total_sectors / (static_cast<l4_sector_t>(heads) * sectors);
        }

        inline int operator ()(const l4_sector_t total_sectors)
        {
            this->total_sectors=total_sectors;
            this->heads=MAX_HEADS;

            // default: ?/16/63 CHS translation
            static const uint8_t SECTORS[] = {63, MAX_SECTORS};

            for (const uint8_t *sn=beginof(SECTORS); sn != endof(SECTORS); sn++) {
                cylinders=get_cylinders(heads, *sn);
                if (cylinders <= MAX_CYLINDERS) {
                    sectors=*sn;
                    return 0;
                }
            }

            cylinders=heads=sectors=0;
            return -L4_EINVAL;
        }

        inline int operator ()(const uint16_t heads, const uint8_t sectors)
        {
            const uint32_t cylinders=get_cylinders(heads, sectors);
            if (cylinders > MAX_CYLINDERS) return -L4_EINVAL;

            this->cylinders=cylinders;
            this->heads=heads;
            this->sectors=sectors;
            return 0;
        }

        inline uint16_t total_sectors_word(const uint8_t index)
        {
            return total_sectors >> (index * 16);
        }
    } geometry;

    struct transaction
    {
        const ata_drive &drive;

        l4_sector_t sector, number;             // [sectors]
        unsigned    commit_bytes;               // [bytes]
        uint8_t     buffer[BUFFER_SIZE];        // buffer to cache blocks
        uint8_t     *data_ptr, *end_ptr;        // pointer to positions in buffer

        inline transaction(const ata_drive &drive)
            : drive(drive), sector(0), number(0), commit_bytes(0), data_ptr(nullptr), end_ptr(nullptr)
        {}

        inline int reset(void)
        {
            sector=number=commit_bytes=0;
            data_ptr=end_ptr=nullptr;
            return 0;
        }

        inline int setup(l4_sector_t sector, l4_sector_t number, unsigned commit_blocks=0)
        {
            if (unlikely(data_ptr || end_ptr || commit_bytes)) {
                logd(L4VMM_DEBUG_ATA >= 2, L4VMM_ERROR": %s:\n"
                     "  I/O buffer is not empty. %zd bytes untransferred.\n",
                     drive.name(), end_ptr - data_ptr);

                return -L4_EBUSY;
            }

            this->sector=sector;
            this->number=number;
            data_ptr=buffer;
            end_ptr=data_ptr + number * SECTOR_SIZE;
            commit_bytes=commit_blocks * SECTOR_SIZE;

            return 0;
        }

        inline bool is_end_of_block(void) const
        {
            return commit_bytes && ((data_ptr - buffer) % commit_bytes) == 0;
        }

        inline bool is_end(void) const
        {
            return commit_bytes && (data_ptr >= end_ptr);
        }
    } transaction;

  public:
    //
    // constructor & destructor
    //
    ata_drive(machine_base &machine, block_driver *driver=nullptr, state_flags flags=0);
    ~ata_drive(void);

    inline int reset(void)
    {
        return transaction.reset() | (driver ? driver->reset() : 0);
    }

    inline const char *name(void) const
    {
        return drive_name.c_str();
    }

    inline void set_drive_name_index(const string &name, const uint8_t index)
    {
        drive_name=name;
        command_block.device.dev=index;
    }

    inline bool is_ready(void) const
    {
        return state.is(READY);
    }

    //
    // resources functions
    //
    inline void set_irq(const l4_irq_t irq)
    {
        // the controller requests an IRQ, so always (try to) use what is set
        if (machine.is_valid_irq(irq)) this->irq=irq;
    }

    inline void assert_irq_if_enabled(void) const
    {
        //
        // do not check the IRQ here. if it is not valid, we want to see the error.
        //     assert_irq doesn't check this too.
        //
        if (likely(!control_block.device_control.nIEN)) machine.assert_irq(irq);
    }

    //
    // register block functions
    //
    uint32_t read_command_block(ata_command_block::offset_t offset, access_size access_size);
    int write_command_block(ata_command_block::offset_t offset, uint32_t data, access_size access_size);

    uint32_t read_control_block(ata_control_block::offset_t offset, access_size access_size);
    int write_control_block(ata_control_block::offset_t offset, uint32_t data, access_size access_size);

    //
    // DMA read/write functions:
    //     read_write as the IDE controller was programed
    //
    int read_write_DMA(uint8_t read_write, l4_gpa_t PRD_base);

  protected:
    //
    // ATA command execute functions
    //
    bool check_sector_range(l4_sector_t sector, l4_sector_t number)
    {
        if (likely(sector + number <= geometry.total_sectors)) return true;

        logd(L4VMM_DEBUG_ATA >= 2, L4VMM_ERROR": %s:\n"
             "  trying to access beyond end of device\n", name());
        command_block.lba28_sector_address(geometry.total_sectors);
        return false;
    }

    void identify_device(void);
    void execute_command(uint8_t command);

    //
    // read functions
    //
    inline int read_from_media(uint8_t *dst, l4_sector_t sector, l4_sector_t number)
    {
        if (state.is(FAKE_IO)) return 0;
        const int err=driver->read_sectors(dst, sector, number);

        assert_logd(L4VMM_DEBUG_ATA, err == 0, "%s:\n"
                    "  read I/O error from block driver %s: %s (%d)\n",
                    name(), driver->name(), l4env_errstr(err), err);
        return err;
    }

    inline int read_buffer_from_media(l4_sector_t sector, l4_sector_t number, unsigned commit_blocks=0)
    {
        if (const int err=successfully(transaction.setup(sector, number, commit_blocks))) return err;
        return read_from_media(transaction.buffer, transaction.sector, transaction.number);
    }

    inline uint32_t read_from_buffer(access_size access_size)
    {
        assertd(L4VMM_DEBUG_ATA, transaction.data_ptr != nullptr);

        const uint32_t ret=*reinterpret_cast<uint32_t *>(transaction.data_ptr);
        transaction.data_ptr+=access_size;
        return ret;
    }

    //
    // write functions
    //
    inline int write_to_media(uint8_t *src, l4_sector_t sector, l4_sector_t number)
    {
        if (state.is(FAKE_IO)) return 0;
        const int err=driver->write_sectors(src, sector, number);

        assert_logd(L4VMM_DEBUG_ATA, err == 0, "%s:\n"
                    "  write I/O error from block driver %s: %s (%d)\n",
                    name(), driver->name(), l4env_errstr(err), err);
        return err;
    }

    inline int write_buffer_to_media(void)
    {
        // buffer (and transaction) was set up when the command was issued
        return write_to_media(transaction.buffer, transaction.sector, transaction.number);
    }

    inline int write_to_buffer(uint32_t data, access_size access_size)
    {
        assertd(L4VMM_DEBUG_ATA, transaction.data_ptr != nullptr);

        *reinterpret_cast<uint32_t *>(transaction.data_ptr)=data;
        transaction.data_ptr+=access_size;
        return 0;
    }

    //
    // DMA functions
    //
    inline int read_write_media(uint8_t read_write, l4_hva_t base, l4_hva_t size)
    {
        assertd(L4VMM_DEBUG_ATA, size % SECTOR_SIZE == 0);
        const l4_hva_t number=size / SECTOR_SIZE;

        logd(L4VMM_DEBUG_ATA >= 4, "  transferring "l4_hva_fmt" blocks ["l4_hva_fmt"] %s "l4_hva_fmt"\n",
             number, size, read_write ? "to" : "from", base);

        if (const int err=successfully((read_write) ?
                              read_from_media(reinterpret_cast<uint8_t *>(base), transaction.sector, number) :
                                  write_to_media(reinterpret_cast<uint8_t *>(base), transaction.sector, number))) {
            transaction.reset();
            return err;
        }

        transaction.sector+=number;
        transaction.number-=number;
        return 0;
    }
};

#endif

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