/*
 * Syborg NAND flash controller
 *
 * Copyright (c) 2009 CodeSourcery
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "hw.h"
#include "syborg.h"
#include "devtree.h"
#include "block.h"
#include "flash.h"

//#define DEBUG_SYBORG_NAND

#ifdef DEBUG_SYBORG_NAND
#define DPRINTF(fmt, args...) \
do { printf("syborg_nand: " fmt , ##args); } while (0)
#define BADF(fmt, args...) \
do { fprintf(stderr, "syborg_nand: error: " fmt , ##args); exit(1);} while (0)
#else
#define DPRINTF(fmt, args...) do {} while(0)
#define BADF(fmt, args...) \
do { fprintf(stderr, "syborg_nand: error: " fmt , ##args);} while (0)
#endif

enum {
    SNAND_ID            = 0,
    SNAND_DATA          = 1,
    SNAND_CTL           = 2,
    SNAND_ECC_COUNT     = 3,
    SNAND_ECC_CP        = 4,
    SNAND_ECC_LP        = 5
};

#define SNAND_CTL_CLE   0x01
#define SNAND_CTL_ALE   0x02
#define SNAND_CTL_CE    0x04
#define SNAND_CTL_WP    0x08
#define SNAND_CTL_RB    0x10
#define SNAND_CTL_IN_MASK \
  (SNAND_CTL_CLE | SNAND_CTL_ALE | SNAND_CTL_CE | SNAND_CTL_WP)

typedef struct {
    QEMUDevice *qdev;
    struct nand_flash_s *nand;
    struct ecc_state_s ecc;
    uint32_t ctl;
} syborg_nand_state;

static uint32_t syborg_nand_ecc_lp(syborg_nand_state *s)
{
    uint32_t v0;
    uint32_t v1;

    v0 = s->ecc.lp[0];
    v1 = s->ecc.lp[1];

#define ODD(n) ((v0 << n) & (1 << (2 * n)))
#define EVEN(n) ((v1 << (n + 1)) & (1 << (2 * n + 1)))
    /* Interleave parity bits.  */
    return ODD( 0) | ODD( 1) | ODD( 2) | ODD( 3)
         | ODD( 4) | ODD( 5) | ODD( 6) | ODD( 7)
         | ODD( 8) | ODD( 9) | ODD(10) | ODD(11)
         | ODD(12) | ODD(13) | ODD(14) | ODD(15)
         | EVEN( 0) | EVEN( 1) | EVEN( 2) | EVEN( 3)
         | EVEN( 4) | EVEN( 5) | EVEN( 6) | EVEN( 7)
         | EVEN( 8) | EVEN( 9) | EVEN(10) | EVEN(11)
         | EVEN(12) | EVEN(13) | EVEN(14) | EVEN(15);
#undef ODD
#undef EVEN
}

static uint32_t syborg_nand_read(void *opaque, target_phys_addr_t offset)
{
    syborg_nand_state *s = (syborg_nand_state *)opaque;
    
    offset &= 0xfff;
    DPRINTF("read 0x%x\n", (int)offset);
    switch(offset >> 2) {
    case SNAND_ID:
        return SYBORG_ID_NAND;
    case SNAND_DATA:
        return ecc_digest(&s->ecc, nand_getio(s->nand));
    case SNAND_CTL:
        {
            int rb;
            nand_getpins(s->nand, &rb);
            return s->ctl | (rb ? SNAND_CTL_RB : 0);
        }
    case SNAND_ECC_COUNT:
        return s->ecc.count;
    case SNAND_ECC_CP:
        return s->ecc.cp;
    case SNAND_ECC_LP:
        return syborg_nand_ecc_lp(s);
    default:
        BADF("Bad read offset 0x%x\n", (int)offset);
        return 0;  
    }
}

static void syborg_nand_write(void *opaque, target_phys_addr_t offset,
                              uint32_t value)
{
    syborg_nand_state *s = (syborg_nand_state *)opaque;
    
    offset &= 0xfff;
    DPRINTF("Write 0x%x=0x%x\n", (int)offset, value);
    switch (offset >> 2) {
    case SNAND_DATA:
        nand_setio(s->nand, ecc_digest(&s->ecc, value & 0xff));
        break;
    case SNAND_CTL:
        s->ctl = value & SNAND_CTL_IN_MASK;
        nand_setpins(s->nand,
                     (value & SNAND_CTL_CLE) != 0,
                     (value & SNAND_CTL_ALE) != 0,
                     (value & SNAND_CTL_CE) != 0,
                     (value & SNAND_CTL_WP) != 0,
                     0);
        break;
    case SNAND_ECC_COUNT:
        if (value != 0) {
            BADF("Bad write to ECC count\n");
        }
        ecc_reset(&s->ecc);
        break;
    default:
        BADF("Bad write offset 0x%x\n", (int)offset);
        break;
    }
}

static CPUReadMemoryFunc *syborg_nand_readfn[] = {
     syborg_nand_read,
     syborg_nand_read,
     syborg_nand_read
};

static CPUWriteMemoryFunc *syborg_nand_writefn[] = {
     syborg_nand_write,
     syborg_nand_write,
     syborg_nand_write
};

static void syborg_nand_save(QEMUFile *f, void *opaque)
{
    syborg_nand_state *s = opaque;

    qemu_put_be32(f, s->ctl);
    ecc_put(f, &s->ecc);
}

static int syborg_nand_load(QEMUFile *f, void *opaque, int version_id)
{
    syborg_nand_state *s = opaque;

    if (version_id != 1)
        return -EINVAL;

    s->ctl = qemu_get_be32(f);
    ecc_get(f, &s->ecc);

    return 0;
}

static const struct
{
    int size;
    int id;
} nand_chips[] =
{
    {1, 0x6e},
    {2, 0x64},
    {4, 0x6b},
    {8, 0xd6},
    {16, 0x33},
    {32, 0x35},
    {64, 0x36},
    {128, 0x78},
    {256, 0x71},
    {512, 0xa2},
    {1024, 0xa1},
    {2048, 0xaa},
    {4096, 0xac},
    {8192, 0xa3},
    {16384, 0xa5},
    {0, 0}
};

static void syborg_nand_create(QEMUDevice *dev)
{
    int n;
    int size;
    syborg_nand_state *s;
    s = (syborg_nand_state *)qemu_mallocz(sizeof(syborg_nand_state));
    s->qdev = dev;
    qdev_set_opaque(dev, s);

    size = qdev_get_property_int(dev, "size");
    n = 0;
    while (nand_chips[n].size && nand_chips[n].size != size) {
        n++;
    }
    if (nand_chips[n].size == 0) {
        BADF("Unsuppored chip size: %d\n", size);
        exit(1);
    }
    s->nand = nand_init(NAND_MFR_SAMSUNG, nand_chips[n].id);
    ecc_reset(&s->ecc);
}

void syborg_nand_register(void)
{
    QEMUDeviceClass *dc;
    dc = qdev_new("syborg,nand", syborg_nand_create, 0);
    qdev_add_registers(dc, syborg_nand_readfn, syborg_nand_writefn, 0x1000);
    qdev_add_property_int(dc, "size", 0);
    qdev_add_savevm(dc, 1, syborg_nand_save, syborg_nand_load);
}