/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 *
 * Copyright (C) 2024 Solomon Peachy
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

/* This is intended to be #included into the ATA driver */

static sector_t total_sectors;
static uint32_t log_sector_size;
static uint16_t identify_info[ATA_IDENTIFY_WORDS] STORAGE_ALIGN_ATTR;
#ifdef HAVE_LBA48
static bool ata_lba48 = false; /* set for 48 bit addressing */
#endif
static bool canflush = true;
static int spinup_time = 0;
static struct mutex ata_mutex SHAREDBSS_ATTR;

#ifdef MAX_PHYS_SECTOR_SIZE
static uint16_t phys_sector_mult = 1;
#endif

int ata_spinup_time(void)
{
    return spinup_time;
}

#ifdef STORAGE_GET_INFO
void ata_get_info(IF_MD(int drive,)struct storage_info *info)
{
    unsigned short *src,*dest;
    static char vendor[8];
    static char product[16];
    static char revision[4];
#ifdef HAVE_MULTIDRIVE
    (void)drive; /* unused for now */
#endif
    int i;

    info->sector_size = log_sector_size;
    info->num_sectors = total_sectors;
#ifdef MAX_PHYS_SECTOR_SIZE
    info->phys_sector_mult = phys_sector_mult;
#endif

    src = (unsigned short*)&identify_info[27];
    dest = (unsigned short*)vendor;
    for (i=0;i<4;i++)
        dest[i] = htobe16(src[i]);
    info->vendor=vendor;

    src = (unsigned short*)&identify_info[31];
    dest = (unsigned short*)product;
    for (i=0;i<8;i++)
        dest[i] = htobe16(src[i]);
    info->product=product;

    src = (unsigned short*)&identify_info[23];
    dest = (unsigned short*)revision;
    for (i=0;i<2;i++)
        dest[i] = htobe16(src[i]);
    info->revision=revision;
}
#endif

#ifdef MAX_PHYS_SECTOR_SIZE

#ifdef MAX_VARIABLE_LOG_SECTOR
#define __MAX_VARIABLE_LOG_SECTOR MAX_VARIABLE_LOG_SECTOR
#else
#define __MAX_VARIABLE_LOG_SECTOR SECTOR_SIZE
#endif

#ifndef STORAGE_ALIGN_ATTR
#define STORAGE_ALIGN_ATTR __attribute__((aligned(sizeof(uint32_t))))
#endif

struct sector_cache_entry {
    unsigned char data[MAX_PHYS_SECTOR_SIZE];
    sector_t sectornum;  /* logical sector */
    bool inuse;
};
/* buffer for reading and writing large physical sectors */
static struct sector_cache_entry sector_cache STORAGE_ALIGN_ATTR;

static int ata_transfer_sectors(uint64_t start,
                                int incount,
                                void* inbuf,
                                int write);

static int cache_sector(sector_t sector)
{
    int rc;

    /* round down to physical sector boundary */
    sector &= ~(phys_sector_mult - 1);

    /* check whether the sector is already cached */
    if (sector_cache.inuse && (sector_cache.sectornum == sector))
        return 0;

    /* not found: read the sector */
    sector_cache.inuse = false;
    rc = ata_transfer_sectors(sector, phys_sector_mult, sector_cache.data, false);
    if (!rc)
    {
        sector_cache.sectornum = sector;
        sector_cache.inuse = true;
    }
    return rc;
}

static inline int flush_current_sector(void)
{
    return ata_transfer_sectors(sector_cache.sectornum, phys_sector_mult,
                                sector_cache.data, true);
}

int ata_read_sectors(IF_MD(int drive,)
                     sector_t start,
                     int incount,
                     void* inbuf)
{
    int rc = 0;
    int offset;

#ifdef HAVE_MULTIDRIVE
    (void)drive; /* unused for now */
#endif
    mutex_lock(&ata_mutex);

    offset = start & (phys_sector_mult - 1);

    if (offset) /* first partial physical sector */
    {
        int partcount = MIN(incount, phys_sector_mult - offset);

        rc = cache_sector(start);
        if (rc)
        {
            rc = rc * 10 - 1;
            goto error;
        }
        memcpy(inbuf, sector_cache.data + offset * log_sector_size,
               partcount * log_sector_size);

        start += partcount;
        inbuf += partcount * log_sector_size;
        incount -= partcount;
    }
    offset = incount & (phys_sector_mult - 1);
    incount -= offset;

    if (incount) /* all complete physical sectors */
    {
        rc = ata_transfer_sectors(start, incount, inbuf, false);
        if (rc)
        {
            rc = rc * 10 - 2;
            goto error;
        }
        start += incount;
        inbuf += incount * log_sector_size;
    }

    if (offset) /* Trailing partial logical sector */
    {
        rc = cache_sector(start);
        if (rc)
        {
            rc = rc * 10 - 3;
            goto error;
        }
        memcpy(inbuf, sector_cache.data, offset * log_sector_size);
    }

  error:
    mutex_unlock(&ata_mutex);

    return rc;
}

int ata_write_sectors(IF_MD(int drive,)
                      sector_t start,
                      int count,
                      const void* buf)
{
    int rc = 0;
    int offset;

#ifdef HAVE_MULTIDRIVE
    (void)drive; /* unused for now */
#endif
    mutex_lock(&ata_mutex);

    offset = start & (phys_sector_mult - 1);

    if (offset) /* first partial physical sector */
    {
        int partcount = MIN(count, phys_sector_mult - offset);

        rc = cache_sector(start);
        if (rc)
        {
            rc = rc * 10 - 1;
            goto error;
        }
        memcpy(sector_cache.data + offset * log_sector_size, buf,
               partcount * log_sector_size);
        rc = flush_current_sector();
        if (rc)
        {
            rc = rc * 10 - 2;
            goto error;
        }
        start += partcount;
        buf += partcount * log_sector_size;
        count -= partcount;
    }

    offset = count & (phys_sector_mult - 1);
    count -= offset;

    if (count) /* all complete physical sectors */
    {
        rc = ata_transfer_sectors(start, count, (void*)buf, true);
        if (rc)
        {
            rc = rc * 10 - 3;
            goto error;
        }
        start += count;
        buf += count * log_sector_size;
    }

    if (offset) /* Trailing partial logical sector */
    {
        rc = cache_sector(start);
        if (rc)
        {
            rc = rc * 10 - 4;
            goto error;
        }
        memcpy(sector_cache.data, buf, offset * log_sector_size);
        rc = flush_current_sector();
        if (rc)
        {
            rc = rc * 10 - 5;
            goto error;
        }
    }

  error:
    mutex_unlock(&ata_mutex);

    return rc;
}

static int ata_get_phys_sector_mult(void)
{
    int rc = 0;

    /* Find out the physical sector size */
    if((identify_info[106] & 0xe000) == 0x6000) /* B14, B13 */
        phys_sector_mult = BIT_N(identify_info[106] & 0x000f);
    else
        phys_sector_mult = 1;

    DEBUGF("ata: %d logical sectors per phys sector", phys_sector_mult);

    if((identify_info[209] & 0xc000) == 0x4000) { /* B14 */
        if (identify_info[209] & 0x3fff) {
            panicf("ata: Unaligned logical/physical sector mapping");
            // XXX we can probably handle this by adding a fixed offset
            // to all operations and subtracting this from the reported
            // size.  But we don't do tihs until we find a real-world need.
        }
    }

    if (phys_sector_mult > 1)
    {
        /* Check if drive really needs emulation  - if we can access
           sector 1 then assume the drive supports "512e" and will handle
           it better than us, so ignore the large physical sectors.

           The exception here is if the device is partitioned to use
           larger-than-logical "virtual" sectors; in that case we will
           use whichever one (ie physical/"virtual") is larger.
        */
        char throwaway[__MAX_VARIABLE_LOG_SECTOR];
        rc = ata_transfer_sectors(1, 1, &throwaway, false);
        if (rc == 0)
            phys_sector_mult = 1;
    }

    if (phys_sector_mult > (MAX_PHYS_SECTOR_SIZE/log_sector_size))
        panicf("Unsupported physical sector size: %ld",
               phys_sector_mult * log_sector_size);

    memset(&sector_cache, 0, sizeof(sector_cache));

    return 0;
}

void ata_set_phys_sector_mult(unsigned int mult)
{
    unsigned int max = MAX_PHYS_SECTOR_SIZE/log_sector_size;
    /* virtual sector could be larger than pyhsical sector */
    if (!mult || mult > max)
        mult = max;
    /* It needs to be at _least_ the size of the real multiplier */
    if (mult > phys_sector_mult)
        phys_sector_mult = mult;
}

#endif  /* MAX_PHYS_SECTOR_SIZE */
