/*

 *  Dynamic device configuration and creation.

 *

 *  Copyright (c) 2008 CodeSourcery

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

/* FIXME: check all malloc/strdup exit coeds.  Or better still have

   malloc/strdup abort.  */

#include "qemu-common.h"

#include "sysemu.h"

#include "devtree.h"

#include "hw/boards.h"

#include "libfdt/libfdt.h"

#include "qemu-char.h"

#define BADF(fmt, args...) \

do { fprintf(stderr, "error: " fmt , ##args); exit(1);} while (0)

/* Assume no device will ever need more than 4 register windows.  */

#define MAX_DEV_REGS 4

enum QEMUDeicePropetyType {

    QDEV_PROP_INT,

    QDEV_PROP_STRING

};

typedef struct QEMUDeviceProperty {

    const char *name;

    enum QEMUDeicePropetyType type;

    union {

        int i;

        char *string;

    } value;

    struct QEMUDeviceProperty *next;

} QEMUDeviceProperty;

struct QEMUDeviceClass {

    struct QEMUDeviceClass *next;

    const char *name;

    void *opaque;

    QEMUDeviceProperty *properties;

    int num_irqs;

    int num_regs;

    CPUReadMemoryFunc **mem_read[MAX_DEV_REGS];

    CPUWriteMemoryFunc **mem_write[MAX_DEV_REGS];

    target_phys_addr_t mem_size[MAX_DEV_REGS];

    QDEVCreateFn create;

    SaveStateHandler *save_state;

    LoadStateHandler *load_state;

    int savevm_version;

    unsigned has_chardev:1;

};

struct QEMUDevice {

    QEMUDevice *next;

    QEMUDeviceClass *dc;

    QEMUDeviceProperty *properties;

    qemu_irq **irqp;

    qemu_irq *irq;

    CharDriverState *chardev;

    qemu_irq *irq_sink;

    void *mem_opaque[MAX_DEV_REGS];

    void *opaque;

    int irq_sink_count;

    const void *dt;

    int node_offset;

    uint32_t phandle;

};

const void *machine_devtree;

int machine_devtree_size;

devtree_ram_region *devtree_ram_map;

int devtree_ram_map_size;

/* Device (class) registration.  */

QEMUDeviceClass *cpu_device_class;

static QEMUDeviceClass *all_dc;

QEMUDeviceClass *qdev_new(const char *name, QDEVCreateFn create, int nirq)

{

    QEMUDeviceClass *dc = qemu_mallocz(sizeof(*dc));

    dc->num_irqs = nirq;

    dc->create = create;

    dc->name = qemu_strdup(name);

    dc->next = all_dc;

    all_dc = dc;

    return dc;

}

void qdev_add_chardev(QEMUDeviceClass *dc)

{

    if (dc->has_chardev) {

        BADF("Device class %s already has a chardev\n", dc->name);

    }

    dc->has_chardev = 1;

}

void qdev_add_property_string(QEMUDeviceClass *dc, const char *name,

                              const char *def)

{

    QEMUDeviceProperty *p = qemu_mallocz(sizeof(*p));

    p->name = qemu_strdup(name);

    p->type = QDEV_PROP_STRING;

    if (def)

        p->value.string = qemu_strdup(def);

    p->next = dc->properties;

    dc->properties = p;

}

void qdev_add_property_int(QEMUDeviceClass *dc, const char *name, int def)

{

    QEMUDeviceProperty *p = qemu_mallocz(sizeof(*p));

    p->name = qemu_strdup(name);

    p->type = QDEV_PROP_INT;

    p->value.i = def;

    p->next = dc->properties;

    dc->properties = p;

}

void qdev_add_registers(QEMUDeviceClass *dc, CPUReadMemoryFunc **mem_read,

                        CPUWriteMemoryFunc **mem_write,

                        target_phys_addr_t mem_size)

{

    if (dc->num_regs == MAX_DEV_REGS) {

        BADF("too many regs");

        return;

    }

    dc->mem_read[dc->num_regs] = mem_read;

    dc->mem_write[dc->num_regs] = mem_write;

    dc->mem_size[dc->num_regs] = mem_size;

    dc->num_regs++;

}

void qdev_add_class_opaque(QEMUDeviceClass *dc, void *opaque)

{

    dc->opaque = opaque;

}

void qdev_add_savevm(QEMUDeviceClass *dc, int ver,

                     SaveStateHandler *save_state,

                     LoadStateHandler *load_state)

{

    dc->savevm_version = ver;

    dc->save_state = save_state;

    dc->load_state = load_state;

}

static QEMUDeviceProperty *qdev_copy_properties(QEMUDeviceProperty *src)

{

    QEMUDeviceProperty *first;

    QEMUDeviceProperty **p;

    QEMUDeviceProperty *dest;

    first = NULL;

    p = &first;

    while (src) {

        dest = qemu_mallocz(sizeof(*dest));

        dest->name = src->name;

        dest->type = src->type;

        switch (src->type) {

        case QDEV_PROP_INT:

            dest->value.i = src->value.i;

            break;

        case QDEV_PROP_STRING:

            if (src->value.string)

                dest->value.string = qemu_strdup(src->value.string);

            break;

        }

        src = src->next;

        *p = dest;

        p = &dest->next;

    }

    return first;

}

/* Device manipulation.  */

static QEMUDevice *first_device;

static QEMUDevice *qdev_create(QEMUDeviceClass *dc, const void *dt,

                               int node_offset)

{

    QEMUDevice *dev = qemu_mallocz(sizeof(*dc));

    dev->dc = dc;

    dev->properties = qdev_copy_properties(dc->properties);

    if (dc->num_irqs) {

        dev->irqp = qemu_mallocz(dc->num_irqs * sizeof(qemu_irq *));

        dev->irq = qemu_mallocz(dc->num_irqs * sizeof(qemu_irq));

    }

    dev->node_offset = node_offset;

    dev->dt = dt;

    dev->phandle = fdt_get_phandle(dt, node_offset);

    dev->next = first_device;

    first_device = dev;

    return dev;

}

/* IRQs are not created/linked until all devices have been created.

   This function take a pointer to a qemu_irq object, which will be

   populated later.  */

/* FIXME: Should we just have qdev_irq_{raise,lower}?  */

void qdev_get_irq(QEMUDevice *dev, int n, qemu_irq *p)

{

    if (n >= dev->dc->num_irqs)

        BADF("Bad IRQ %d (%d)\n", n, dev->dc->num_irqs);

    dev->irqp[n] = p;

}

CharDriverState *qdev_get_chardev(QEMUDevice *dev)

{

    return dev->chardev;

}

void qdev_create_interrupts(QEMUDevice *dev, qemu_irq_handler handler, 

                            void *opaque, int n)

{

    dev->irq_sink = qemu_allocate_irqs(handler, opaque, n);

    dev->irq_sink_count = n;

}

int qdev_get_property_int(QEMUDevice *dev, const char *name)

{

    QEMUDeviceProperty *p;

    for (p = dev->properties; p; p = p->next) {

        if (strcmp(name, p->name) == 0) {

            if (p->type != QDEV_PROP_INT)

                abort();

            return p->value.i;

        }

    }

    abort();

}

const char *qdev_get_property_string(QEMUDevice *dev, const char *name)

{

    QEMUDeviceProperty *p;

    for (p = dev->properties; p; p = p->next) {

        if (strcmp(name, p->name) == 0) {

            if (p->type != QDEV_PROP_STRING)

                abort();

            return p->value.string;

        }

    }

    abort();

}

const char *qdev_get_name(QEMUDevice *dev)

{

    return fdt_get_name(dev->dt, dev->node_offset, NULL);

}

void *qdev_get_class_opaque(QEMUDevice *dev)

{

    return dev->dc->opaque;

}

void qdev_set_opaque(QEMUDevice *dev, void *opaque)

{

    dev->opaque = opaque;

}

void qdev_set_region_opaque(QEMUDevice *dev, int n, void *opaque)

{

    dev->mem_opaque[n] = opaque;

}

void qdev_set_irq_level(QEMUDevice *dev, int n, int level)

{

    if (n < 0 || n > dev->dc->num_irqs)

        return;

    qemu_set_irq(dev->irq[n], level);

}

/* FDT handling.  */

static void invalid_devtree(QEMUDevice *dev, const char *msg)

{

    fprintf(stderr, "devtree: %s: %s\n", dev->dc->name, msg);

    exit(1);

}

static const char *fdt_getprop_string(const void *dt, int node,

                                      const char * name)

{

    const char *p;

    int len;

    p = fdt_getprop(dt, node, name, &len);

    if (!p || len == 0)

        return NULL;

    /* Check string is properly terminated.  If the wrong kind of property

       is used then this may not be true.  */

    if (p[len - 1] != 0)

        return NULL;

    return p;

}

static void find_properties(QEMUDevice *dev)

{

    const struct fdt_property *p;

    QEMUDeviceProperty *dp;

    int len;

    for (dp = dev->properties; dp; dp = dp->next) {

        p = fdt_get_property(dev->dt, dev->node_offset, dp->name, &len);

        if (!p)

            continue;

        switch (dp->type) {

        case QDEV_PROP_INT:

            if (len != 4) {

                invalid_devtree(dev, "Bad integer property");

                break;

            }

            dp->value.i = fdt32_to_cpu(*(uint32_t *)p->data);

            break;

        case QDEV_PROP_STRING:

            if (len == 0 || p->data[len - 1]) {

                invalid_devtree(dev, "Bad string property");

                break;

            }

            if (dp->value.string)

                qemu_free(dp->value.string);

            dp->value.string = qemu_strdup((const char *)p->data);

            break;

        }

    }

}

/* We currently assume a fixed address/size.  Enforce that here.  */

static void check_cells(const void *dt, int node, int address, int size)

{

    const struct fdt_property *p;

    int parent;

    int len;

    int n;

    parent = fdt_parent_offset(dt, node);

    if (node < 0) {

        fprintf(stderr, "missing parent node for %s\n",

                fdt_get_name(dt, node, NULL));

        exit(1);

    }

    p = fdt_get_property(dt, parent, "#address-cells", &len);

    if (!p || len != 4) {

        fprintf(stderr,

                "Invalid or missing #address-cells for %s\n",

                fdt_get_name(dt, node, NULL));

        exit(1);

    }

    n = fdt32_to_cpu(*(uint32_t *)p->data);

    if (n != address) {

        fprintf(stderr,

                "Incorrect #address-cells for %s (expected %d got %d)\n",

                fdt_get_name(dt, node, NULL), address, n);

        exit(1);

    }

    p = fdt_get_property(dt, parent, "#size-cells", &len);

    if (!p || len != 4) {

        fprintf(stderr,

                "Invalid or missing #size-cells for %s\n",

                fdt_get_name(dt, node, NULL));

        exit(1);

    }

    n = fdt32_to_cpu(*(uint32_t *)p->data);

    if (n != size) {

        fprintf(stderr,

                "Incorrect #size-cells for %s (expected %d got %d)\n",

                fdt_get_name(dt, node, NULL), size, n);

        exit(1);

    }

}

static void create_from_node(QEMUDeviceClass *dc, const void *dt, int node)

{

    QEMUDevice *d;

    const char *propstr;

    int i;

    d = qdev_create(dc, dt, node);

    if (dc->has_chardev) {

        int n;

        propstr = fdt_getprop_string(dt, node, "chardev");

        if (propstr) {

            i = sscanf(propstr, "serial%d", &n);

            if (i == 1 && n >= 0 && n < MAX_SERIAL_PORTS)

            {

                if (!serial_hds[n])

                {

                    const char* target = fdt_getprop_string(dt, node, "target");

                    if (target)

                        serial_hds[n] = qemu_chr_open(propstr, target);

                }

                d->chardev = serial_hds[n];

            }

        }

    }

    find_properties(d);

    d->dc->create(d);

    if (dc->savevm_version) {

        register_savevm(dc->name, -1, dc->savevm_version,

                        dc->save_state, dc->load_state, d->opaque);

    }

    if (dc->num_regs) {

        const struct fdt_property *p;

        uint32_t base;

        uint32_t *data;

        void *opaque;

        int iomemtype;

        int len;

        check_cells(dt, node, 1, 0);

        p = fdt_get_property(dt, node, "reg", &len);

        if (!p || len != dc->num_regs * 4) {

            invalid_devtree(d, "Missing reg");

            return;

        }

        data = (uint32_t *)p->data;

        for (i = 0; i < dc->num_regs; i++) {

            base = fdt32_to_cpu(*data);

            data++;

            opaque = d->mem_opaque[i];

            if (!opaque)

                opaque = d->opaque;

            iomemtype = cpu_register_io_memory(0, dc->mem_read[i],

                                               dc->mem_write[i], opaque);

            cpu_register_physical_memory(base, dc->mem_size[i], iomemtype);

        }

    }

}

static void scan_devtree(const void *dt)

{

    QEMUDeviceClass *dc;

    int node;

    for (dc = all_dc; dc; dc = dc->next) {

        node = -1;

        while (1) {

            node = fdt_node_offset_by_compatible(dt, node, dc->name);

            if (node < 0)

                break;

            create_from_node(dc, dt, node);

        }

    }

}

/* Create CPU devices.  These are devices so that they can have interrupts.  */

static void create_cpus(const void *dt)

{

    int node = -1;

    while (1) {

        node = fdt_node_offset_by_prop_value(dt, node, "device_type",

                                             "cpu", 4);

        if (node < 0)

            break;

        create_from_node(cpu_device_class, dt, node);

    }

}

/* Add RAM.  */

static void create_ram(const void *dt)

{

    int node = -1;

    const struct fdt_property *p;

    int len;

    uint32_t base;

    uint32_t size;

    uint32_t *data;

    ram_addr_t offset;

    while (1) {

        node = fdt_node_offset_by_prop_value(dt, node, "device_type",

                                             "memory", 7);

        if (node < 0)

            break;

        check_cells(dt, node, 1, 1);

        p = fdt_get_property(dt, node, "reg", &len);

        if (!p || (len % 8) != 0) {

            fprintf(stderr, "bad memory section %s\n",

                    fdt_get_name(dt, node, NULL));

            exit(1);

        }

        data = (uint32_t *)p->data;

        while (len) {

            base = fdt32_to_cpu(data[0]);

            size = fdt32_to_cpu(data[1]);

            data += 2;

            len -= 8;

            /* Ignore zero size regions.  */

            if (size == 0)

                continue;

            offset = qemu_ram_alloc(size);

            cpu_register_physical_memory(base, size, offset | IO_MEM_RAM);