/*

*

* Contributors:

* NTT DOCOMO, INC. -- Syborg QEMU crashes when using skin + touchscreen device

* 

* Nokia Oyj -- New memregion service added for converting guest OS addresses to host OS addresses

*

*/

#include "Python.h"

#include "structmember.h"

#include "hw/hw.h"

#include "sysemu.h"

#include "devtree.h"

#include "qemu-char.h"

#include "display_state.h"

#include "hw/gui.h"

#include "hw/fb_render_engine.h"

#include "qemu-timer.h"

static void qemu_py_die(void)

{

    PyErr_Print();

    exit(1);

}

#define qemu_py_assert(x) do { if (!(x)) { qemu_py_die(); } } while (0)

static void qemu_py_load_module(const char *name)

{

    PyObject *module;

    module = PyImport_ImportModule(name);

    if (!module)

        qemu_py_die();

}

static int64_t qemu_py_int64_from_pynum(PyObject *ob)

{

    if (PyInt_Check(ob))

        return PyInt_AsLong(ob);

    return PyLong_AsLongLong(ob);

}

static uint64_t qemu_py_uint64_from_pynum(PyObject *ob)

{

    if (PyInt_Check(ob))

        return PyInt_AsUnsignedLongMask(ob);

    return PyLong_AsUnsignedLongLongMask(ob);

}

typedef struct {

    PyObject_HEAD

    PyObject *size;

    PyObject *readl;

    PyObject *writel;

} qemu_py_ioregion;

static void qemu_py_ioregion_dealloc(qemu_py_ioregion *self)

{

    Py_CLEAR(self->size);

    Py_CLEAR(self->readl);

    Py_CLEAR(self->writel);

    self->ob_type->tp_free((PyObject*)self);

}

static int qemu_py_ioregion_init(qemu_py_ioregion *self, PyObject *args,

                                 PyObject *kwds)

{

    static char *kwlist[] = {"size", "readl", "writel", NULL};

    PyObject *obsize;

    PyObject *readl;

    PyObject *writel;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist,

                                     &obsize, &readl, &writel))

        return -1; 

    Py_INCREF(obsize);

    self->size = obsize;

    Py_INCREF(readl);

    self->readl = readl;

    Py_INCREF(writel);

    self->writel = writel;

    return 0;

}

static PyMemberDef qemu_py_ioregion_members[] = {

    {"size", T_OBJECT, offsetof(qemu_py_ioregion, size), 0,

     "size"},

    {"readl", T_OBJECT, offsetof(qemu_py_ioregion, readl), 0,

     "32-bit read"},

    {"writel", T_OBJECT, offsetof(qemu_py_ioregion, writel), 0,

     "32-bit write"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_ioregionType = {

    PyObject_HEAD_INIT(NULL)

    0,                                    /* ob_size */

    "qemu.ioregion",                      /* tp_name */

    sizeof(qemu_py_ioregion),             /* tp_basicsize */

    0,                                    /* tp_itemsize */

    (destructor)qemu_py_ioregion_dealloc, /* tp_dealloc */

    0,                                    /* tp_print */

    0,                                    /* tp_getattr */

    0,                                    /* tp_setattr */

    0,                                    /* tp_compare */

    0,                                    /* tp_repr */

    0,                                    /* tp_as_number */

    0,                                    /* tp_as_sequence */

    0,                                    /* tp_as_mapping */

    0,                                    /* tp_hash  */

    0,                                    /* tp_call */

    0,                                    /* tp_str */

    0,                                    /* tp_getattro */

    0,                                    /* tp_setattro */

    0,                                    /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                   /* tp_flags */

    "QEMU IORegion",                      /* tp_doc */

    0,                                    /* tp_traverse */

    0,                                    /* tp_clear */

    0,		                          /* tp_richcompare */

    0,		                          /* tp_weaklistoffset */

    0,		                          /* tp_iter */

    0,		                          /* tp_iternext */

    0,                                    /* tp_methods */

    qemu_py_ioregion_members,             /* tp_members */

    0,                                    /* tp_getset */

    0,                                    /* tp_base */

    0,                                    /* tp_dict */

    0,                                    /* tp_descr_get */

    0,                                    /* tp_descr_set */

    0,                                    /* tp_dictoffset */

    (initproc)qemu_py_ioregion_init,      /* tp_init */

    0,                                    /* tp_alloc */

    0,                                    /* tp_new */

};

typedef struct {

    PyObject_HEAD

    uint32_t base;

    uint32_t size;

	uint32_t *host_ram_base_ptr;

} qemu_py_memregion;

static void qemu_py_memregion_dealloc(qemu_py_ioregion *self)

	{

    self->ob_type->tp_free((PyObject*)self);

	}

static int qemu_py_memregion_init(qemu_py_memregion *self, PyObject *args,

                                 PyObject *kwds)

	{

    static char *kwlist[] = {"base","size", NULL};

    uint32_t base;

    uint32_t size;

	int ret = -1;

	int region_index = 0;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll", kwlist,

                                     &base, &size ))

		{

        ret = -1; 

		}

	else

		{

		for( region_index = 0; region_index < devtree_ram_map_size; region_index+=1 )

			{

			// The created region needs to fit inside memory regions in device tree configuration

			if( (devtree_ram_map[region_index].base <= base) && 

				((devtree_ram_map[region_index].base + devtree_ram_map[region_index].size) >=

				(base + size)) )

				{

				ret = 0;

				self->base = base;

				self->size = size;

				self->host_ram_base_ptr = (uint32_t*)host_ram_addr(base);

				break;

				}

			else

				{

				ret = -1;

				}

			}

		}

    return ret;

	}

static PyObject *qemu_py_memregion_get_size(qemu_py_memregion *self,

                                    PyObject *args, PyObject *kwds)

	{

	return PyLong_FromUnsignedLong(self->size);

	}

static PyObject *qemu_py_memregion_get_base(qemu_py_memregion *self,

                                    PyObject *args, PyObject *kwds)

	{

	return PyLong_FromUnsignedLong(self->base);

	}

static PyObject *qemu_py_memregion_get_host_base(qemu_py_memregion *self,

                                    PyObject *args, PyObject *kwds)

	{

	return PyLong_FromVoidPtr( (void*)(self->host_ram_base_ptr) );

	}

static PyMethodDef qemu_py_memregion_methods[] = {

    {"size", (PyCFunction)qemu_py_memregion_get_size, METH_VARARGS|METH_KEYWORDS,

     "Get memory region size"},

    {"region_guest_addr", (PyCFunction)qemu_py_memregion_get_base, METH_VARARGS|METH_KEYWORDS,

     "Get memory region base"},

    {"region_host_addr", (PyCFunction)qemu_py_memregion_get_host_base, METH_VARARGS|METH_KEYWORDS,

     "Get memory region host base address"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_memRegionType = {

    PyObject_HEAD_INIT(NULL)

    0,                                      /* ob_size */

    "qemu.memregion",                       /* tp_name */

    sizeof(qemu_py_memregion),              /* tp_basicsize */

    0,                                      /* tp_itemsize */

    (destructor)qemu_py_memregion_dealloc,  /* tp_dealloc */

    0,                                      /* tp_print */

    0,                                      /* tp_getattr */

    0,                                      /* tp_setattr */

    0,                                      /* tp_compare */

    0,                                      /* tp_repr */

    0,                                      /* tp_as_number */

    0,                                      /* tp_as_sequence */

    0,                                      /* tp_as_mapping */

    0,                                      /* tp_hash  */

    0,                                      /* tp_call */

    0,                                      /* tp_str */

    0,                                      /* tp_getattro */

    0,                                      /* tp_setattro */

    0,                                      /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                     /* tp_flags */

    "QEMU MemRegion",                       /* tp_doc */

    0,                                      /* tp_traverse */

    0,                                      /* tp_clear */

    0,		                                /* tp_richcompare */

    0,		                                /* tp_weaklistoffset */

    0,		                                /* tp_iter */

    0,		                                /* tp_iternext */

    qemu_py_memregion_methods,              /* tp_methods */

    0,                                      /* tp_members */

    0,                                      /* tp_getset */

    0,                                      /* tp_base */

    0,                                      /* tp_dict */

    0,                                      /* tp_descr_get */

    0,                                      /* tp_descr_set */

    0,                                      /* tp_dictoffset */

    (initproc)qemu_py_memregion_init,       /* tp_init */

    0,                                      /* tp_alloc */

    0,                                      /* tp_new */

};

typedef struct {

    PyObject_HEAD

    QEMUFile *f;

} qemu_py_file;

static void qemu_py_file_dealloc(qemu_py_file *self)

{

    self->f = NULL;

    self->ob_type->tp_free((PyObject*)self);

}

static int qemu_py_file_init(qemu_py_file *self, PyObject *args,

                             PyObject *kwds)

{

    static char *kwlist[] = {"f", NULL};

    PyObject *obdata;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obdata))

        return -1; 

    self->f = PyCObject_AsVoidPtr(obdata);

    if (PyErr_Occurred())

        return -1;

    return 0;

}

static PyObject *qemu_py_file_get_u32(qemu_py_file *self, PyObject *args)

{

    uint32_t val;

    if (self->f) {

        val = qemu_get_be32(self->f);

        return PyLong_FromUnsignedLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_u32(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    uint32_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_uint64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be32(self->f, val);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_get_u64(qemu_py_file *self, PyObject *args)

{

    uint64_t val;

    if (self->f) {

        val = qemu_get_be64(self->f);

        return PyLong_FromUnsignedLongLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_get_s64(qemu_py_file *self, PyObject *args)

{

    int64_t val;

    if (self->f) {

        val = qemu_get_be64(self->f);

        return PyLong_FromLongLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_u64(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    uint64_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_uint64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be64(self->f, val);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_s64(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    int64_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_int64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be64(self->f, val);

    Py_RETURN_NONE;

}

static PyMethodDef qemu_py_file_methods[] = {

    {"get_u32", (PyCFunction)qemu_py_file_get_u32, METH_NOARGS,

     "Read unsigned 32-bit value"},

    {"put_u32", (PyCFunction)qemu_py_file_put_u32, METH_VARARGS|METH_KEYWORDS,

     "Write unsigned 32-bit value"},

    {"get_u64", (PyCFunction)qemu_py_file_get_u64, METH_NOARGS,

     "Read unsigned 64-bit value"},

    {"put_u64", (PyCFunction)qemu_py_file_put_u64, METH_VARARGS|METH_KEYWORDS,

     "Write unsigned 64-bit value"},

    {"get_s64", (PyCFunction)qemu_py_file_get_s64, METH_NOARGS,

     "Read signed 64-bit value"},

    {"put_s64", (PyCFunction)qemu_py_file_put_s64, METH_VARARGS|METH_KEYWORDS,

     "Write signed 64-bit value"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_fileType = {

    PyObject_HEAD_INIT(NULL)

    0,                                    /* ob_size */

    "qemu.file",                          /* tp_name */

    sizeof(qemu_py_file),                 /* tp_basicsize */

    0,                                    /* tp_itemsize */

    (destructor)qemu_py_file_dealloc,     /* tp_dealloc */

    0,                                    /* tp_print */

    0,                                    /* tp_getattr */

    0,                                    /* tp_setattr */

    0,                                    /* tp_compare */

    0,                                    /* tp_repr */

    0,                                    /* tp_as_number */

    0,                                    /* tp_as_sequence */

    0,                                    /* tp_as_mapping */

    0,                                    /* tp_hash  */

    0,                                    /* tp_call */

    0,                                    /* tp_str */

    0,                                    /* tp_getattro */

    0,                                    /* tp_setattro */

    0,                                    /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                   /* tp_flags */

    "QEMU File Object",                   /* tp_doc */

    0,                                    /* tp_traverse */

    0,                                    /* tp_clear */

    0,		                          /* tp_richcompare */

    0,		                          /* tp_weaklistoffset */

    0,		                          /* tp_iter */

    0,		                          /* tp_iternext */

    qemu_py_file_methods,                 /* tp_methods */

    0,                                    /* tp_members */

    0,                                    /* tp_getset */

    0,                                    /* tp_base */

    0,                                    /* tp_dict */

    0,                                    /* tp_descr_get */

    0,                                    /* tp_descr_set */

    0,                                    /* tp_dictoffset */

    (initproc)qemu_py_file_init,          /* tp_init */

    0,                                    /* tp_alloc */

    0,                                    /* tp_new */

};

typedef struct {

    PyObject_HEAD

    ptimer_state *ptimer;

} qemu_py_ptimer;

static void qemu_py_ptimer_dealloc(qemu_py_ptimer *self)

{

    self->ptimer = NULL;

    self->ob_type->tp_free((PyObject*)self);

}

static void qemu_py_ptimer_tick(void *opaque)

{

    PyObject *fn = opaque;

    PyObject *obval;

    obval = PyObject_CallFunctionObjArgs(fn, NULL);

    qemu_py_assert(obval);

    Py_DECREF(obval);

}

static int qemu_py_ptimer_init(qemu_py_ptimer *self, PyObject *args,

                               PyObject *kwds)

{

    static char *kwlist[] = {"tick", "freq", NULL};

    PyObject *tick;

    PyObject *obfreq = NULL;

    uint64_t freq;

    QEMUBH *bh;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,

                                     &tick, &obfreq))

        return -1; 

    if (!PyCallable_Check(tick)) {

        PyErr_SetString(PyExc_TypeError, "tick handler must be callable");

        return -1;

    }

    if (obfreq) {

        freq = qemu_py_uint64_from_pynum(obfreq);

        if (PyErr_Occurred())

            return -1;

    } else {

        freq = 0;

    }

    Py_INCREF(tick);

    bh = qemu_bh_new(qemu_py_ptimer_tick, tick);

    self->ptimer = ptimer_init(bh);

    if (freq)

        ptimer_set_freq(self->ptimer, freq);

    return 0;

}

static PyObject *qemu_py_ptimer_run(qemu_py_ptimer *self,

                                    PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"oneshot", NULL};

    int oneshot;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &oneshot))

        return NULL;

    ptimer_run(self->ptimer, oneshot != 0);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_stop(qemu_py_ptimer *self, PyObject *args)

{

    ptimer_stop(self->ptimer);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_set_limit(qemu_py_ptimer *self,

                                          PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"limit", "reload", NULL};

    PyObject *oblimit;

    uint64_t limit;

    int reload;