Cosmos/source/MatthijsTest/MyATAController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Cosmos.Hardware;
using Cosmos.Kernel;

namespace MatthijsTest
{
    public class MyATAController : Device
    {
        private const ushort PrimaryControllerBaseAddress = 0x1F0;
        public static void Scan()
        {
            var xController = new MyATAController(PrimaryControllerBaseAddress);
            xController.Identify(true);
            xController.Identify(false);
            Device.Devices.Add(xController);
        }

        private void Identify(bool masterDrive)
        {
            // Select the drive to identify
            DriveSelectPort = (byte)(masterDrive ? 0xA0 : 0xB0);
            // read status 
            var xStatus = StatusPort;
            xStatus = StatusPort;
            xStatus = StatusPort;
            xStatus = StatusPort;
            xStatus = StatusPort;
            CommandPort = CommandEnum.Identify;
            if (StatusPort == RegularStatusFlagsEnum.None)
            {
                return;
            }

            var xError = false;
            var xReady = false;
            while (true)
            {
                xStatus = StatusPort;
                if (xStatus.HasFlags(RegularStatusFlagsEnum.Error))
                {
                    xError = true;
                    break;
                }
                if (xStatus.HasFlags(RegularStatusFlagsEnum.DataRequest)
                    & !xStatus.HasFlags(RegularStatusFlagsEnum.Busy))
                {
                    xReady = true;
                    break;
                }
            }

            if (xError)
            {
                // preliminary abort, means it's ATAPI or SATA
                // todo: implement support for SATA and ATAPI detection
                return;
            }
            if (!xReady)
            {
                Console.WriteLine("Weird error. Situation not handled in ATAController.Identify!");
                while (true)
                    ;
            }
            // not busy anymore. 
            var xName = masterDrive
                            ? "Master drive"
                            : "Slave drive";
            var xDevice = new MyATADevice(this, xName, masterDrive);
            Devices.Add(xDevice);
            if (masterDrive)
            {
                HasMasterDevice = true;
            }
            else
            {
                HasSlaveDevice = true;
            }
        }

        private MyATAController(ushort baseAddress)
        {
            mType = DeviceType.Storage;
            mAddressSpace = new IOAddressSpace(baseAddress, 8);
        }

        private IOAddressSpace mAddressSpace;
        #region IO Ports
        private ushort DataPort_Word
        {
            get
            {
                return mAddressSpace.Read16(0);
            }
            set
            {
                mAddressSpace.Write16(0, value);
            }
        }

        private byte SectorCountPort
        {
            set
            {
                mAddressSpace.Write8(2, value);
            }
        }

        private byte SectorAddress1Port
        {
            set
            {
                mAddressSpace.Write8(3, value);
            }
        }

        private byte SectorAddress2Port
        {
            set
            {
                mAddressSpace.Write8(4, value);
            }
        }

        private byte SectorAddress3Port
        {
            set
            {
                mAddressSpace.Write8(5, value);
            }
        }

        private RegularStatusFlagsEnum StatusPort
        {
            get
            {
                return (RegularStatusFlagsEnum)mAddressSpace.Read8(7);
            }
        }

        private CommandEnum CommandPort
        {
            set
            {
                mAddressSpace.Write8(7, (byte)value);
            }
        }

        private byte DriveSelectPort
        {
            get
            {
                return mAddressSpace.Read8(6);
            }
            set
            {
                mAddressSpace.Write8(6, value);
            }
        }

        #endregion

        public bool HasMasterDevice
        {
            get;
            private set;
        }

        public bool HasSlaveDevice
        {
            get;
            private set;
        }

        public override string Name
        {
            get
            {
                return "ATA Storage Controller";
            }
        }

        #region PIO
        internal void RealReadBlock_PIO(AddressSpace target)
        {
            for (uint i = 0; i < 256; i++)
            {
                target.Write16(i * 2, DataPort_Word);
            }
        }

        internal void RealWriteBlock_PIO(byte[] source)
        {
            for (uint i = 0; i < 256; i++)
            {
                DataPort_Word = (ushort)(source[i *2] | (source[(i*2)+1] << 8));
            }
        }

        internal void RealWriteBlock_PIO(AddressSpace source)
        {
            for (uint i = 0; i < 256; i++)
            {
                DataPort_Word = source.Read16Unchecked(i * 2);
            }
        }

        internal void ReadSector_LBA28(bool masterDrive, uint block, AddressSpace target)
        {
            var xDriveSelect = (byte)0xE0;
            if (!masterDrive)
            {
                xDriveSelect = 0xF0;
            }
            DriveSelectPort = (byte)(xDriveSelect | ((block >> 24) & 0xF));
            SectorCountPort = 1;
            SectorAddress1Port = (byte)block;
            SectorAddress2Port = (byte)(block >> 8);
            SectorAddress3Port = (byte)(block >> 16);
            CommandPort = CommandEnum.ReadSectors;
            bool xPoll = true;
            bool xError = false;
            do
            {
                var xStatus = StatusPort;
                if ((!xStatus.HasFlags(RegularStatusFlagsEnum.Busy))
                    && xStatus.HasFlags(RegularStatusFlagsEnum.DataRequest))
                {
                    xPoll = false;
                }
                if (xStatus.HasFlags(RegularStatusFlagsEnum.Error)
                    || xStatus.HasFlags(RegularStatusFlagsEnum.DriveFault))
                {
                    xPoll = false;
                    xError = true;
                }

            }
            while (xPoll);
            if (xError)
            {
                throw new Exception("Error while reading sector!");
            }
            RealReadBlock_PIO(target);
        }

        internal void WriteSector_LBA28(bool masterDrive, uint block, byte[] source)
        {
            var xDriveSelect = (byte)0xE0;
            if (!masterDrive)
            {
                xDriveSelect = 0xF0;
            }
            DriveSelectPort = (byte)(xDriveSelect | ((block >> 24) & 0xF));
            SectorCountPort = 1;
            SectorAddress1Port = (byte)block;
            SectorAddress2Port = (byte)(block >> 8);
            SectorAddress3Port = (byte)(block >> 16);
            CommandPort = CommandEnum.WriteSectors;
            bool xPoll = true;
            bool xError = false;
            do
            {
                var xStatus = StatusPort;
                if ((!xStatus.HasFlags(RegularStatusFlagsEnum.Busy))
                    && xStatus.HasFlags(RegularStatusFlagsEnum.DataRequest))
                {
                    xPoll = false;
                }
                if (xStatus.HasFlags(RegularStatusFlagsEnum.Error)
                    || xStatus.HasFlags(RegularStatusFlagsEnum.DriveFault))
                {
                    xPoll = false;
                    xError = true;
                }

            }
            while (xPoll);
            if (xError)
            {
                throw new Exception("Error while writing sector!");
            }
            RealWriteBlock_PIO(source);
        }

        internal void WriteSector_LBA28(bool masterDrive, uint block, AddressSpace source)
        {
            var xDriveSelect = (byte)0xE0;
            if (!masterDrive)
            {
                xDriveSelect = 0xF0;
            }
            DriveSelectPort = (byte)(xDriveSelect | ((block >> 24) & 0xF));
            SectorCountPort = 1;
            SectorAddress1Port = (byte)block;
            SectorAddress2Port = (byte)(block >> 8);
            SectorAddress3Port = (byte)(block >> 16);
            CommandPort = CommandEnum.WriteSectors;
            bool xPoll = true;
            bool xError = false;
            do
            {
                var xStatus = StatusPort;
                if ((!xStatus.HasFlags(RegularStatusFlagsEnum.Busy))
                    && xStatus.HasFlags(RegularStatusFlagsEnum.DataRequest))
                {
                    xPoll = false;
                }
                if (xStatus.HasFlags(RegularStatusFlagsEnum.Error)
                    || xStatus.HasFlags(RegularStatusFlagsEnum.DriveFault))
                {
                    xPoll = false;
                    xError = true;
                }

            }
            while (xPoll);
            if (xError)
            {
                throw new Exception("Error while writing sector!");
            }
            RealWriteBlock_PIO(source);
        }
        #endregion
    }
}