/*
 * Copyright 2008-2010, François Revol, revol@free.fr. All rights reserved.
 * Copyright 2003-2006, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <KernelExport.h>
#include <boot/platform.h>
#include <boot/partitions.h>
#include <boot/stdio.h>
#include <boot/stage2.h>

#include <string.h>

#include "Handle.h"
#include "toscalls.h"

//#define TRACE_DEVICES
#ifdef TRACE_DEVICES
#       define TRACE(x) dprintf x
#else
#       define TRACE(x) ;
#endif


// exported from shell.S
extern uint8 gBootedFromImage;
extern uint8 gBootDriveAPI; // ATARI_BOOT_DRIVE_API_*
extern uint8 gBootDriveID;
extern uint32 gBootPartitionOffset;

#define SCRATCH_SIZE (2*4096)
static uint8 gScratchBuffer[SCRATCH_SIZE];

static const uint16 kParametersSizeVersion1 = sizeof(struct tos_bpb);
static const uint16 kParametersSizeVersion2 = 0x1e;
static const uint16 kParametersSizeVersion3 = 0x42;

static const uint16 kDevicePathSignature = 0xbedd;

//XXX clean this up!
struct drive_parameters {
        struct tos_bpb bpb;
        uint16          parameters_size;
        uint16          flags;
        uint32          cylinders;
        uint32          heads;
        uint32          sectors_per_track;
        uint64          sectors;
        uint16          bytes_per_sector;
        /* edd 2.0 */
        //real_addr     device_table;
        /* edd 3.0 */
        uint16          device_path_signature;
        uint8           device_path_size;
        uint8           reserved1[3];
        char            host_bus[4];
        char            interface_type[8];
        union {
                struct {
                        uint16  base_address;
                } legacy;
                struct {
                        uint8   bus;
                        uint8   slot;
                        uint8   function;
                } pci;
                uint8           reserved[8];
        } interface;
        union {
                struct {
                        uint8   slave;
                } ata;
                struct {
                        uint8   slave;
                        uint8   logical_unit;
                } atapi;
                struct {
                        uint8   logical_unit;
                } scsi;
                struct {
                        uint8   tbd;
                } usb;
                struct {
                        uint64  guid;
                } firewire;
                struct {
                        uint64  wwd;
                } fibre;
        } device;
        uint8           reserved2;
        uint8           checksum;
} _PACKED;

struct device_table {
        uint16  base_address;
        uint16  control_port_address;
        uint8   _reserved1 : 4;
        uint8   is_slave : 1;
        uint8   _reserved2 : 1;
        uint8   lba_enabled : 1;
} _PACKED;

struct specification_packet {
        uint8   size;
        uint8   media_type;
        uint8   drive_number;
        uint8   controller_index;
        uint32  start_emulation;
        uint16  device_specification;
        uint8   _more_[9];
} _PACKED;

class BlockHandle : public Handle {
        public:
                BlockHandle(int handle);
                virtual ~BlockHandle();

                virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize);
                virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize);

                virtual off_t Size() const { return fSize; };

                uint32 BlockSize() const { return fBlockSize; }

                bool HasParameters() const { return fHasParameters; }
                const drive_parameters &Parameters() const { return fParameters; }

                virtual status_t FillIdentifier();

                disk_identifier &Identifier() { return fIdentifier; }
                uint8 DriveID() const { return fHandle; }
                status_t InitCheck() const { return fSize > 0 ? B_OK : B_ERROR; };


                
                virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);

        protected:
                uint64  fSize;
                uint32  fBlockSize;
                bool    fHasParameters;
                drive_parameters fParameters;
                disk_identifier fIdentifier;
};


class FloppyDrive : public BlockHandle {
        public:
                FloppyDrive(int handle);
                virtual ~FloppyDrive();

                status_t FillIdentifier();

                virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);

        protected:
                status_t        ReadBPB(struct tos_bpb *bpb);
};


class BIOSDrive : public BlockHandle {
        public:
                BIOSDrive(int handle);
                virtual ~BIOSDrive();

                status_t FillIdentifier();

                virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);

        protected:
                status_t        ReadBPB(struct tos_bpb *bpb);
};


class XHDIDrive : public BlockHandle {
        public:
                XHDIDrive(int handle, uint16 major, uint16 minor);
                virtual ~XHDIDrive();

                status_t FillIdentifier();

                virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);

        protected:
                uint16 fMajor;
                uint16 fMinor;
};


static bool sBlockDevicesAdded = false;


static status_t
read_bpb(uint8 drive, struct tos_bpb *bpb)
{
        struct tos_bpb *p;
        p = Getbpb(drive);
        memcpy(bpb, p, sizeof(struct tos_bpb));
        /* Getbpb is buggy so we must force a media change */
        //XXX: docs seems to assume we should loop until it works
        Mediach(drive);
        return B_OK;
}

static status_t
get_drive_parameters(uint8 drive, drive_parameters *parameters)
{
        status_t err;
        err = read_bpb(drive, &parameters->bpb);
        TRACE(("get_drive_parameters: get_bpb: 0x%08lx\n", err));
        TRACE(("get_drive_parameters: bpb: %04x %04x %04x %04x %04x %04x %04x %04x %04x \n",
                        parameters->bpb.recsiz, parameters->bpb.clsiz,
                        parameters->bpb.clsizb, parameters->bpb.rdlen,
                        parameters->bpb.fsiz, parameters->bpb.fatrec,
                        parameters->bpb.datrec, parameters->bpb.numcl,
                        parameters->bpb.bflags));
        
#if 0
        // fill drive_parameters structure with useful values
        parameters->parameters_size = kParametersSizeVersion1;
        parameters->flags = 0;
        parameters->cylinders = (((regs.ecx & 0xc0) << 2) | ((regs.ecx >> 8) & 0xff)) + 1;
        parameters->heads = ((regs.edx >> 8) & 0xff) + 1;
                // heads and cylinders start counting from 0
        parameters->sectors_per_track = regs.ecx & 0x3f;
        parameters->sectors = parameters->cylinders * parameters->heads
                * parameters->sectors_per_track;
        parameters->bytes_per_sector = 512;
#endif
        return B_OK;
}


#if 0
/** parse EDD 3.0 drive path information */

static status_t
fill_disk_identifier_v3(disk_identifier &disk, const drive_parameters &parameters)
{
        if (parameters.parameters_size < kParametersSizeVersion3
                || parameters.device_path_signature != kDevicePathSignature)
                return B_BAD_TYPE;

        // parse host bus

        if (!strncmp(parameters.host_bus, "PCI", 3)) {
                disk.bus_type = PCI_BUS;

                disk.bus.pci.bus = parameters.interface.pci.bus;
                disk.bus.pci.slot = parameters.interface.pci.slot;
                disk.bus.pci.function = parameters.interface.pci.function;
        } else if (!strncmp(parameters.host_bus, "ISA", 3)) {
                disk.bus_type = LEGACY_BUS;

                disk.bus.legacy.base_address = parameters.interface.legacy.base_address;
                dprintf("legacy base address %x\n", disk.bus.legacy.base_address);
        } else {
                dprintf("unknown host bus \"%s\"\n", parameters.host_bus);
                return B_BAD_DATA;
        }

        // parse interface

        if (!strncmp(parameters.interface_type, "ATA", 3)) {
                disk.device_type = ATA_DEVICE;
                disk.device.ata.master = !parameters.device.ata.slave;
                dprintf("ATA device, %s\n", disk.device.ata.master ? "master" : "slave");
        } else if (!strncmp(parameters.interface_type, "ATAPI", 3)) {
                disk.device_type = ATAPI_DEVICE;
                disk.device.atapi.master = !parameters.device.ata.slave;
                disk.device.atapi.logical_unit = parameters.device.atapi.logical_unit;
        } else if (!strncmp(parameters.interface_type, "SCSI", 3)) {
                disk.device_type = SCSI_DEVICE;
                disk.device.scsi.logical_unit = parameters.device.scsi.logical_unit;
        } else if (!strncmp(parameters.interface_type, "USB", 3)) {
                disk.device_type = USB_DEVICE;
                disk.device.usb.tbd = parameters.device.usb.tbd;
        } else if (!strncmp(parameters.interface_type, "1394", 3)) {
                disk.device_type = FIREWIRE_DEVICE;
                disk.device.firewire.guid = parameters.device.firewire.guid;
        } else if (!strncmp(parameters.interface_type, "FIBRE", 3)) {
                disk.device_type = FIBRE_DEVICE;
                disk.device.fibre.wwd = parameters.device.fibre.wwd;
        } else {
                dprintf("unknown interface type \"%s\"\n", parameters.interface_type);
                return B_BAD_DATA;
        }

        return B_OK;
}


/** EDD 2.0 drive table information */

static status_t
fill_disk_identifier_v2(disk_identifier &disk, const drive_parameters &parameters)
{
        if (parameters.device_table.segment == 0xffff
                && parameters.device_table.offset == 0xffff)
                return B_BAD_TYPE;

        device_table *table = (device_table *)LINEAR_ADDRESS(parameters.device_table.segment,
                parameters.device_table.offset);

        disk.bus_type = LEGACY_BUS;
        disk.bus.legacy.base_address = table->base_address;

        disk.device_type = ATA_DEVICE;
        disk.device.ata.master = !table->is_slave;

        return B_OK;
}
#endif

static off_t
get_next_check_sum_offset(int32 index, off_t maxSize)
{
        // The boot block often contains the disk superblock, and should be
        // unique enough for most cases
        if (index < 2)
                return index * 512;

        // Try some data in the first part of the drive
        if (index < 4)
                return (maxSize >> 10) + index * 2048;

        // Some random value might do
        return ((system_time() + index) % (maxSize >> 9)) * 512;
}


/**     Computes a check sum for the specified block.
 *      The check sum is the sum of all data in that block interpreted as an
 *      array of uint32 values.
 *      Note, this must use the same method as the one used in kernel/fs/vfs_boot.cpp.
 */

static uint32
compute_check_sum(BlockHandle *drive, off_t offset)
{
        char buffer[512];
        ssize_t bytesRead = drive->ReadAt(NULL, offset, buffer, sizeof(buffer));
        if (bytesRead < B_OK)
                return 0;

        if (bytesRead < (ssize_t)sizeof(buffer))
                memset(buffer + bytesRead, 0, sizeof(buffer) - bytesRead);

        uint32 *array = (uint32 *)buffer;
        uint32 sum = 0;

        for (uint32 i = 0; i < (bytesRead + sizeof(uint32) - 1) / sizeof(uint32); i++) {
                sum += array[i];
        }

        return sum;
}


static void
find_unique_check_sums(NodeList *devices)
{
        NodeIterator iterator = devices->GetIterator();
        Node *device;
        int32 index = 0;
        off_t minSize = 0;
        const int32 kMaxTries = 200;

        while (index < kMaxTries) {
                bool clash = false;

                iterator.Rewind();

                while ((device = iterator.Next()) != NULL) {
                        BlockHandle *drive = (BlockHandle *)device;
#if 0
                        // there is no RTTI in the boot loader...
                        BlockHandle *drive = dynamic_cast<BlockHandle *>(device);
                        if (drive == NULL)
                                continue;
#endif

                        // TODO: currently, we assume that the BIOS provided us with unique
                        //      disk identifiers... hopefully this is a good idea
                        if (drive->Identifier().device_type != UNKNOWN_DEVICE)
                                continue;

                        if (minSize == 0 || drive->Size() < minSize)
                                minSize = drive->Size();

                        // check for clashes

                        NodeIterator compareIterator = devices->GetIterator();
                        while ((device = compareIterator.Next()) != NULL) {
                                BlockHandle *compareDrive = (BlockHandle *)device;

                                if (compareDrive == drive
                                        || compareDrive->Identifier().device_type != UNKNOWN_DEVICE)
                                        continue;

                                if (!memcmp(&drive->Identifier(), &compareDrive->Identifier(),
                                                sizeof(disk_identifier))) {
                                        clash = true;
                                        break;
                                }
                        }

                        if (clash)
                                break;
                }

                if (!clash) {
                        // our work here is done.
                        return;
                }

                // add a new block to the check sums

                off_t offset = get_next_check_sum_offset(index, minSize);
                int32 i = index % NUM_DISK_CHECK_SUMS;
                iterator.Rewind();

                while ((device = iterator.Next()) != NULL) {
                        BlockHandle *drive = (BlockHandle *)device;

                        disk_identifier& disk = drive->Identifier();
                        disk.device.unknown.check_sums[i].offset = offset;
                        disk.device.unknown.check_sums[i].sum = compute_check_sum(drive, offset);

                        TRACE(("disk %x, offset %lld, sum %lu\n", drive->DriveID(), offset,
                                disk.device.unknown.check_sums[i].sum));
                }

                index++;
        }

        // If we get here, we couldn't find a way to differentiate all disks from each other.
        // It's very likely that one disk is an exact copy of the other, so there is nothing
        // we could do, anyway.

        dprintf("Could not make BIOS drives unique! Might boot from the wrong disk...\n");
}


static status_t
add_block_devices(NodeList *devicesList, bool identifierMissing)
{
        int32 map;
        uint8 driveID;
        uint8 driveCount = 0;
        
        if (sBlockDevicesAdded)
                return B_OK;

        if (init_xhdi() >= B_OK) {
                uint16 major;
                uint16 minor;
                uint32 blocksize;
                uint32 blocksize2;
                uint32 blocks;
                uint32 devflags;
                uint32 lastacc;
                char product[33];
                int32 err;

                map = XHDrvMap();
                dprintf("XDrvMap() 0x%08lx\n", map);
                // sadly XDrvmap() has the same issues as XBIOS, it only lists known partitions.
                // so we just iterate on each major and try to see if there is something.
                for (driveID = 0; driveID < 32; driveID++) {
                        uint32 startsect;
                        err = XHInqDev(driveID, &major, &minor, &startsect, NULL);
                        if (err < 0) {
                                ;//dprintf("XHInqDev(%d) error %d\n", driveID, err);
                        } else {
                                dprintf("XHInqDev(%d): (%d,%d):%d\n", driveID, major, minor, startsect);
                        }
                }

                product[32] = '\0';
                for (major = 0; major < 256; major++) {
                        if (major == 64) // we don't want floppies
                                continue;
                        if (major > 23 && major != 64) // extensions and non-standard stuff... skip for speed.
                                break;

                        for (minor = 0; minor < 255; minor++) {
                                if (minor && (major < 8 || major >15))
                                        break; // minor only used for the SCSI LUN AFAIK.
                                if (minor > 15) // are more used at all ?
                                        break;

                                product[0] = '\0';
                                blocksize = 0;
                                blocksize2 = 0;
#if 0
                                err = XHLastAccess(major, minor, &lastacc);
                                if (err < 0) {
                                        ;//dprintf("XHLastAccess(%d,%d) error %d\n", major, minor, err);
                                } else
                                        dprintf("XHLastAccess(%d,%d): %ld\n", major, minor, lastacc);
//continue;
#endif
                                // we can pass NULL pointers but just to play safe we don't.
                                err = XHInqTarget(major, minor, &blocksize, &devflags, product);
                                if (err < 0) {
                                        dprintf("XHInqTarget(%d,%d) error %d\n", major, minor, err);
                                        continue;
                                }
                                err = XHGetCapacity(major, minor, &blocks, &blocksize2);
                                if (err < 0) {
                                        //dprintf("XHGetCapacity(%d,%d) error %d\n", major, minor, err);
                                        continue;
                                }

                                if (blocksize == 0) {
                                        dprintf("XHDI: blocksize for (%d,%d) is 0!\n", major, minor);
                                }
                                //dprintf("XHDI: (%d,%d) blocksize1 %ld blocksize2 %ld\n", major, minor, blocksize, blocksize2);

                                dprintf("XHDI(%d,%d): blksize %d, blocks %d, flags 0x%08lx, '%s'\n", major, minor, blocksize, blocks, devflags, product);
                                driveID = (uint8)major;

                                //if (driveID == gBootDriveID)
                                //      continue;
//continue;

                                BlockHandle *drive = new(nothrow) XHDIDrive(driveID, major, minor);
                                if (drive->InitCheck() != B_OK) {
                                        dprintf("could not add drive (%d,%d)\n", major, minor);
                                        delete drive;
                                        continue;
                                }

                                devicesList->Add(drive);
                                driveCount++;

                                if (drive->FillIdentifier() != B_OK)
                                        identifierMissing = true;
                        }
                }
        }
        if (!driveCount) { // try to fallback to BIOS XXX: use MetaDOS
                map = Drvmap();
                dprintf("Drvmap(): 0x%08lx\n", map);
                for (driveID = 0; driveID < 32; driveID++) {
                        bool present = map & 0x1;
                        map >>= 1;
                        if (!present)
                                continue;

                        if (driveID == gBootDriveID)
                                continue;

                        BlockHandle *drive = new(nothrow) BlockHandle(driveID);
                        if (drive->InitCheck() != B_OK) {
                                dprintf("could not add drive %u\n", driveID);
                                delete drive;
                                continue;
                        }

                        devicesList->Add(drive);
                        driveCount++;

                        if (drive->FillIdentifier() != B_OK)
                                identifierMissing = true;
                }
        }
        dprintf("number of drives: %d\n", driveCount);

        if (identifierMissing) {
                // we cannot distinguish between all drives by identifier, we need
                // compute checksums for them
                find_unique_check_sums(devicesList);
        }

        sBlockDevicesAdded = true;
        return B_OK; 
}


//      #pragma mark -


BlockHandle::BlockHandle(int handle)
        : Handle(handle)
        , fSize(0LL)
        , fBlockSize(0)
        , fHasParameters(false)
          
{
        TRACE(("BlockHandle::%s(): drive ID %u\n", __FUNCTION__, fHandle));
}


BlockHandle::~BlockHandle()
{
}


ssize_t 
BlockHandle::ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize)
{
        ssize_t ret;
        uint32 offset = pos % fBlockSize;
        pos /= fBlockSize;
        TRACE(("BlockHandle::%s: (%d) %lld, %d\n", __FUNCTION__, fHandle, pos, bufferSize));

        uint32 blocksLeft = (bufferSize + offset + fBlockSize - 1) / fBlockSize;
        int32 totalBytesRead = 0;

        //TRACE(("BIOS reads %lu bytes from %lld (offset = %lu)\n",
        //      blocksLeft * fBlockSize, pos * fBlockSize, offset));

        // read partial block
        if (offset) {
                ret = ReadBlocks(gScratchBuffer, pos, 1);
                if (ret < 0)
                        return ret;
                totalBytesRead += fBlockSize - offset;
                memcpy(buffer, gScratchBuffer + offset, totalBytesRead);
                
        }

        uint32 scratchSize = SCRATCH_SIZE / fBlockSize;

        while (blocksLeft > 0) {
                uint32 blocksRead = blocksLeft;
                if (blocksRead > scratchSize)
                        blocksRead = scratchSize;

                ret = ReadBlocks(gScratchBuffer, pos, blocksRead);
                if (ret < 0)
                        return ret;

                uint32 bytesRead = fBlockSize * blocksRead - offset;
                // copy no more than bufferSize bytes
                if (bytesRead > bufferSize)
                        bytesRead = bufferSize;

                memcpy(buffer, (void *)(gScratchBuffer + offset), bytesRead);
                pos += blocksRead;
                offset = 0;
                blocksLeft -= blocksRead;
                bufferSize -= bytesRead;
                buffer = (void *)((addr_t)buffer + bytesRead);
                totalBytesRead += bytesRead;
        }

        //TRACE(("BlockHandle::%s: %d bytes read\n", __FUNCTION__, totalBytesRead));
        return totalBytesRead;
}


ssize_t 
BlockHandle::WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize)
{
        // we don't have to know how to write
        return B_NOT_ALLOWED;
}


ssize_t
BlockHandle::ReadBlocks(void *buffer, off_t first, int32 count)
{
        return B_NOT_ALLOWED;
}


status_t
BlockHandle::FillIdentifier()
{
        return B_NOT_ALLOWED;
}

//      #pragma mark -

/*
 * BIOS based disk access.
 * Only for fallback from missing XHDI.
 * XXX: This is broken!
 * XXX: check for physical drives in PUN_INFO
 * XXX: at least try to use MetaDOS calls instead.
 */


FloppyDrive::FloppyDrive(int handle)
        : BlockHandle(handle)
{
        TRACE(("FloppyDrive::%s(%d)\n", __FUNCTION__, fHandle));

        /* first check if the drive exists */
        /* note floppy B can be reported present anyway... */
        uint32 map = Drvmap();
        if (!(map & (1 << fHandle))) {
                fSize = 0LL;
                return;
        }
        //XXX: check size

        if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
                dprintf("getting drive parameters for: %u failed!\n", fHandle);
                return;
        }
        // XXX: probe! this is a std 1.44kB floppy
        fBlockSize = 512;
        fParameters.sectors = 1440 * 1024 / 512;
        fParameters.sectors_per_track = 18;
        fParameters.heads = 2;
        fSize = fParameters.sectors * fBlockSize;
        fHasParameters = false;
/*
        parameters->sectors_per_track = 9;
        parameters->cylinders = (1440/2) / (9*2);
        parameters->heads = 2;
        parameters->sectors = parameters->cylinders * parameters->heads
        * parameters->sectors_per_track;
        */
#if 0
        if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
                // old style CHS support

                if (get_drive_parameters(driveID, &fParameters) != B_OK) {
                        dprintf("getting drive parameters for: %u failed!\n", fDriveID);
                        return;
                }

                TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("  total sectors: %lld\n", fParameters.sectors));

                fBlockSize = 512;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = false;
                fHasParameters = false;
        } else {
                TRACE(("size: %x\n", fParameters.parameters_size));
                TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
                TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
                        fParameters.interface_type));
                TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("total sectors: %lld\n", fParameters.sectors));

                fBlockSize = fParameters.bytes_per_sector;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = true;
                fHasParameters = true;
        }
#endif
}


FloppyDrive::~FloppyDrive()
{
}


status_t
FloppyDrive::FillIdentifier()
{
        TRACE(("FloppyDrive::%s: (%d)\n", __FUNCTION__, fHandle));
#if 0
        if (HasParameters()) {
                // try all drive_parameters versions, beginning from the most informative

#if 0
                if (fill_disk_identifier_v3(fIdentifier, fParameters) == B_OK)
                        return B_OK;

                if (fill_disk_identifier_v2(fIdentifier, fParameters) == B_OK)
                        return B_OK;
#else
                // TODO: the above version is the correct one - it's currently
                //              disabled, as the kernel boot code only supports the
                //              UNKNOWN_BUS/UNKNOWN_DEVICE way to find the correct boot
                //              device.
                if (fill_disk_identifier_v3(fIdentifier, fParameters) != B_OK)
                        fill_disk_identifier_v2(fIdentifier, fParameters);

#endif

                // no interesting information, we have to fall back to the default
                // unknown interface/device type identifier
        }

        fIdentifier.bus_type = UNKNOWN_BUS;
        fIdentifier.device_type = UNKNOWN_DEVICE;
        fIdentifier.device.unknown.size = Size();

        for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
                fIdentifier.device.unknown.check_sums[i].offset = -1;
                fIdentifier.device.unknown.check_sums[i].sum = 0;
        }
#endif

        return B_ERROR;
}


static void
hexdump(uint8 *buf, uint32 offset)
{
// hexdump
        
        for (int i = 0; i < 512; i++) {
                if ((i % 16) == 0)
                        TRACE(("%08lx ", offset+i));
                if ((i % 16) == 8)
                TRACE((" "));
                TRACE((" %02x", buf[i]));

                if ((i % 16) == 15)
                        TRACE(("\n"));
        }
}


ssize_t
FloppyDrive::ReadBlocks(void *buffer, off_t first, int32 count)
{
        int sectorsPerBlocks = (fBlockSize / 512);
        int sectorsPerTrack = fParameters.sectors_per_track;
        int heads = fParameters.heads;
        int32 ret;
        //TRACE(("FloppyDrive::%s(%lld,%ld) (%d)\n", __FUNCTION__, first, count, fHandle));
        // force single sector reads to avoid crossing track boundaries
        for (int i = 0; i < count; i++) {
                uint8 *buf = (uint8 *)buffer;
                buf += i * fBlockSize;
                
                int16 track, side, sect;
                sect = (first + i) * sectorsPerBlocks;
                track = sect / (sectorsPerTrack * heads);
                side = (sect / sectorsPerTrack) % heads;
                sect %= sectorsPerTrack;
                sect++; // 1-based
        
                
                /*
                  TRACE(("FloppyDrive::%s: THS: %d %d %d\n",
                  __FUNCTION__, track, side, sect));
                */
                ret = Floprd(buf, 0L, fHandle, sect, track, side, 1);
                if (ret < 0)
                        return toserror(ret);
                //if (first >= 1440)
                //hexdump(buf, (uint32)(first+i)*512);
        }

        return count;
}


//      #pragma mark -

/*
 * BIOS based disk access.
 * Only for fallback from missing XHDI.
 * XXX: This is broken!
 * XXX: check for physical drives in PUN_INFO
 * XXX: at least try to use MetaDOS calls instead.
 */


BIOSDrive::BIOSDrive(int handle)
        : BlockHandle(handle)
{
        TRACE(("BIOSDrive::%s(%d)\n", __FUNCTION__, fHandle));

        /* first check if the drive exists */
        /* note floppy B can be reported present anyway... */
        uint32 map = Drvmap();
        if (!(map & (1 << fHandle))) {
                fSize = 0LL;
                return;
        }
        //XXX: check size

        if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
                dprintf("getting drive parameters for: %u failed!\n", fHandle);
                return;
        }
        fBlockSize = 512;
        fSize = fParameters.sectors * fBlockSize;
        fHasParameters = false;

#if 0
        if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
                // old style CHS support

                if (get_drive_parameters(driveID, &fParameters) != B_OK) {
                        dprintf("getting drive parameters for: %u failed!\n", fDriveID);
                        return;
                }

                TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("  total sectors: %lld\n", fParameters.sectors));

                fBlockSize = 512;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = false;
                fHasParameters = false;
        } else {
                TRACE(("size: %x\n", fParameters.parameters_size));
                TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
                TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
                        fParameters.interface_type));
                TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("total sectors: %lld\n", fParameters.sectors));

                fBlockSize = fParameters.bytes_per_sector;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = true;
                fHasParameters = true;
        }
#endif
}


BIOSDrive::~BIOSDrive()
{
}


status_t
BIOSDrive::FillIdentifier()
{
        TRACE(("BIOSDrive::%s: (%d)\n", __FUNCTION__, fHandle));
#if 0
        if (HasParameters()) {
                // try all drive_parameters versions, beginning from the most informative

#if 0
                if (fill_disk_identifier_v3(fIdentifier, fParameters) == B_OK)
                        return B_OK;

                if (fill_disk_identifier_v2(fIdentifier, fParameters) == B_OK)
                        return B_OK;
#else
                // TODO: the above version is the correct one - it's currently
                //              disabled, as the kernel boot code only supports the
                //              UNKNOWN_BUS/UNKNOWN_DEVICE way to find the correct boot
                //              device.
                if (fill_disk_identifier_v3(fIdentifier, fParameters) != B_OK)
                        fill_disk_identifier_v2(fIdentifier, fParameters);

#endif

                // no interesting information, we have to fall back to the default
                // unknown interface/device type identifier
        }

        fIdentifier.bus_type = UNKNOWN_BUS;
        fIdentifier.device_type = UNKNOWN_DEVICE;
        fIdentifier.device.unknown.size = Size();

        for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
                fIdentifier.device.unknown.check_sums[i].offset = -1;
                fIdentifier.device.unknown.check_sums[i].sum = 0;
        }
#endif

        return B_ERROR;
}


ssize_t
BIOSDrive::ReadBlocks(void *buffer, off_t first, int32 count)
{
        int sectorsPerBlocks = (fBlockSize / 256);
        int32 ret;
        TRACE(("BIOSDrive::%s(%lld,%ld) (%d)\n", __FUNCTION__, first, count, fHandle));
        // XXX: check for AHDI 3.0 before using long recno!!!
        ret = Rwabs(RW_READ | RW_NOTRANSLATE, buffer, sectorsPerBlocks, -1, fHandle, first * sectorsPerBlocks);
        if (ret < 0)
                return toserror(ret);
        return ret;
}


//      #pragma mark -

/*
 * XHDI based devices
 */


XHDIDrive::XHDIDrive(int handle, uint16 major, uint16 minor)
        : BlockHandle(handle)
{
        /* first check if the drive exists */
        int32 err;
        uint32 devflags;
        uint32 blocks;
        uint32 blocksize;
        char product[33];

        fMajor = major;
        fMinor = minor;
        TRACE(("XHDIDrive::%s(%d, %d, %d)\n", __FUNCTION__, handle, fMajor, fMinor));

        product[32] = '\0';
        err = XHInqTarget(major, minor, &fBlockSize, &devflags, product);
        if (err < 0)
                return;
        //XXX: check size
        err = XHGetCapacity(major, minor, &blocks, &blocksize);
        if (err < 0)
                return;
        
        if (fBlockSize == 0)
                fBlockSize = 512;
        
        fSize = blocks * fBlockSize;
        fHasParameters = false;
#if 0
        if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
                dprintf("getting drive parameters for: %u failed!\n", fHandle);
                return;
        }
        fBlockSize = 512;
        fSize = fParameters.sectors * fBlockSize;
        fHasParameters = false;
#endif
#if 0
        if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
                // old style CHS support

                if (get_drive_parameters(driveID, &fParameters) != B_OK) {
                        dprintf("getting drive parameters for: %u failed!\n", fDriveID);
                        return;
                }

                TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("  total sectors: %lld\n", fParameters.sectors));

                fBlockSize = 512;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = false;
                fHasParameters = false;
        } else {
                TRACE(("size: %x\n", fParameters.parameters_size));
                TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
                TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
                        fParameters.interface_type));
                TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
                        fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
                        fParameters.bytes_per_sector));
                TRACE(("total sectors: %lld\n", fParameters.sectors));

                fBlockSize = fParameters.bytes_per_sector;
                fSize = fParameters.sectors * fBlockSize;
                fLBA = true;
                fHasParameters = true;
        }
#endif
}


XHDIDrive::~XHDIDrive()
{
}


status_t
XHDIDrive::FillIdentifier()
{
        TRACE(("XHDIDrive::%s: (%d,%d)\n", __FUNCTION__, fMajor, fMinor));

        fIdentifier.bus_type = UNKNOWN_BUS;
        fIdentifier.device_type = UNKNOWN_DEVICE;
        fIdentifier.device.unknown.size = Size();
#if 0
        // cf. http://toshyp.atari.org/010008.htm#XHDI-Terminologie
        if (fMajor >= 8 && fMajor <= 15) { // scsi
                fIdentifier.device_type = SCSI_DEVICE;
                fIdentifier.device.scsi.logical_unit = fMinor;
                //XXX: where am I supposed to put the ID ???
        }
#endif

        for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
                fIdentifier.device.unknown.check_sums[i].offset = -1;
                fIdentifier.device.unknown.check_sums[i].sum = 0;
        }

        return B_ERROR;
}


ssize_t
XHDIDrive::ReadBlocks(void *buffer, off_t first, int32 count)
{
        int sectorsPerBlock = (fBlockSize / 256);
        int32 ret;
        uint16 flags = RW_READ;
        TRACE(("XHDIDrive::%s(%lld, %d) (%d,%d)\n", __FUNCTION__, first, count, fMajor, fMinor));
        ret = XHReadWrite(fMajor, fMinor, flags, (uint32)first, (uint16)count, buffer);
        if (ret < 0)
                return xhdierror(ret);
        //TRACE(("XHReadWrite: %ld\n", ret));
        /*
        uint8 *b = (uint8 *)buffer;
        int i = 0;
        for (i = 0; i < 512; i+=16) {
                TRACE(("[%8Ld+%3ld] %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 
                        first, i, b[i], b[i+1], b[i+2], b[i+3], b[i+4], b[i+5], b[i+6], b[i+7], 
                        b[i+8], b[i+9], b[i+10], b[i+11], b[i+12], b[i+13], b[i+14], b[i+15]));
                //break;
        }
        */
        return ret;
}




//      #pragma mark -


status_t 
platform_add_boot_device(struct stage2_args *args, NodeList *devicesList)
{
        TRACE(("boot drive ID: %x API: %d\n", gBootDriveID, gBootDriveAPI));
        init_xhdi();

        //XXX: FIXME
        //BlockHandle *drive = new(nothrow) BlockHandle(gBootDriveID);
        BlockHandle *drive;
        switch (gBootDriveAPI) {
                case ATARI_BOOT_DRVAPI_FLOPPY:
                        drive = new(nothrow) FloppyDrive(gBootDriveID);
                        break;
                        /*
                case ATARI_BOOT_DRVAPI_XBIOS:
                        drive = new(nothrow) DMADrive(gBootDriveID);
                        break;
                        */
                case ATARI_BOOT_DRVAPI_XHDI:
                        drive = new(nothrow) XHDIDrive(gBootDriveID, gBootDriveID, 0);
                        break;
                case ATARI_BOOT_DRVAPI_UNKNOWN:
                {
                        // we don't know yet, try to ask ARAnyM via NatFeat
                        int id = nat_feat_get_bootdrive();
                        if (id > -1) {
                                gBootDriveID = id;
                                dprintf("nat_fead_get_bootdrive() = %d\n", id);
                                // XXX: which API does it refer to ??? id = letter - 'a'
                                drive = new(nothrow) XHDIDrive(gBootDriveID, gBootDriveID, 0);
                                break;
                        }
                }
                default:
                        dprintf("unknown boot drive API %d\n", gBootDriveAPI);
                        return B_ERROR;
                        drive = new(nothrow) BIOSDrive(gBootDriveID);
        }

        if (drive == NULL || drive->InitCheck() != B_OK) {
                dprintf("no boot drive!\n");
                return B_ERROR;
        }

        devicesList->Add(drive);

        if (drive->FillIdentifier() != B_OK) {
                // We need to add all block devices to give the kernel the possibility
                // to find the right boot volume
                add_block_devices(devicesList, true);
        }

        TRACE(("boot drive size: %lld bytes\n", drive->Size()));
        gBootParams.SetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, gBootedFromImage);

        return B_OK;
}


status_t
platform_get_boot_partitions(struct stage2_args *args, Node *bootDevice,
        NodeList *list, NodeList *partitionList)
{
        BlockHandle *drive = static_cast<BlockHandle *>(bootDevice);
        off_t offset = (off_t)gBootPartitionOffset * drive->BlockSize();

        dprintf("boot partition offset: %lld\n", offset);

        NodeIterator iterator = list->GetIterator();
        boot::Partition *partition = NULL;
        while ((partition = (boot::Partition *)iterator.Next()) != NULL) {
                TRACE(("partition offset = %lld, size = %lld\n", partition->offset, partition->size));
                // search for the partition that contains the partition
                // offset as reported by the BFS boot block
                if (offset >= partition->offset
                        && offset < partition->offset + partition->size) {
                        partitionList->Insert(partition);
                        return B_OK;
                }
        }

        return B_ENTRY_NOT_FOUND;
}


status_t
platform_add_block_devices(stage2_args *args, NodeList *devicesList)
{
        init_xhdi();
        return add_block_devices(devicesList, false);
}


status_t 
platform_register_boot_device(Node *device)
{
        BlockHandle *drive = (BlockHandle *)device;

#if 0
        check_cd_boot(drive);
#endif

        gBootParams.SetInt64("boot drive number", drive->DriveID());
        gBootParams.SetData(BOOT_VOLUME_DISK_IDENTIFIER, B_RAW_TYPE,
                &drive->Identifier(), sizeof(disk_identifier));

        return B_OK;
}


void
platform_cleanup_devices()
{
}