ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vmstate: port cuda 

Signed-off-by: Juan Quintela <quintela@redhat.com>
This commit is contained in:
Juan Quintela 2010-12-02 13:53:24 +01:00 committed by Anthony Liguori
parent 4acd38cef0
commit c0a93a9efa
1 changed files with 47 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
hw/cuda.c
View File

@ -644,80 +644,56 @@ static CPUReadMemoryFunc * const cuda_read[] = {
&cuda_readl, &cuda_readl,
}; };
static void cuda_save_timer(QEMUFile *f, CUDATimer *s) static bool cuda_timer_exist(void *opaque, int version_id)
{ {
qemu_put_be16s(f, &s->latch); CUDATimer *s = opaque;
qemu_put_be16s(f, &s->counter_value);
qemu_put_sbe64s(f, &s->load_time); return s->timer != NULL;
qemu_put_sbe64s(f, &s->next_irq_time);
if (s->timer)
qemu_put_timer(f, s->timer);
} }
static void cuda_save(QEMUFile *f, void *opaque) static const VMStateDescription vmstate_cuda_timer = {
{ .name = "cuda_timer",
CUDAState *s = (CUDAState *)opaque; .version_id = 0,
.minimum_version_id = 0,
.minimum_version_id_old = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT16(latch, CUDATimer),
VMSTATE_UINT16(counter_value, CUDATimer),
VMSTATE_INT64(load_time, CUDATimer),
VMSTATE_INT64(next_irq_time, CUDATimer),
VMSTATE_TIMER_TEST(timer, CUDATimer, cuda_timer_exist),
VMSTATE_END_OF_LIST()
}
};
qemu_put_ubyte(f, s->b); static const VMStateDescription vmstate_cuda = {
qemu_put_ubyte(f, s->a); .name = "cuda",
qemu_put_ubyte(f, s->dirb); .version_id = 1,
qemu_put_ubyte(f, s->dira); .minimum_version_id = 1,
qemu_put_ubyte(f, s->sr); .minimum_version_id_old = 1,
qemu_put_ubyte(f, s->acr); .fields = (VMStateField[]) {
qemu_put_ubyte(f, s->pcr); VMSTATE_UINT8(a, CUDAState),
qemu_put_ubyte(f, s->ifr); VMSTATE_UINT8(b, CUDAState),
qemu_put_ubyte(f, s->ier); VMSTATE_UINT8(dira, CUDAState),
qemu_put_ubyte(f, s->anh); VMSTATE_UINT8(dirb, CUDAState),
qemu_put_sbe32s(f, &s->data_in_size); VMSTATE_UINT8(sr, CUDAState),
qemu_put_sbe32s(f, &s->data_in_index); VMSTATE_UINT8(acr, CUDAState),
qemu_put_sbe32s(f, &s->data_out_index); VMSTATE_UINT8(pcr, CUDAState),
qemu_put_ubyte(f, s->autopoll); VMSTATE_UINT8(ifr, CUDAState),
qemu_put_buffer(f, s->data_in, sizeof(s->data_in)); VMSTATE_UINT8(ier, CUDAState),
qemu_put_buffer(f, s->data_out, sizeof(s->data_out)); VMSTATE_UINT8(anh, CUDAState),
qemu_put_be32s(f, &s->tick_offset); VMSTATE_INT32(data_in_size, CUDAState),
cuda_save_timer(f, &s->timers[0]); VMSTATE_INT32(data_in_index, CUDAState),
cuda_save_timer(f, &s->timers[1]); VMSTATE_INT32(data_out_index, CUDAState),
} VMSTATE_UINT8(autopoll, CUDAState),
VMSTATE_BUFFER(data_in, CUDAState),
static void cuda_load_timer(QEMUFile *f, CUDATimer *s) VMSTATE_BUFFER(data_out, CUDAState),
{ VMSTATE_UINT32(tick_offset, CUDAState),
qemu_get_be16s(f, &s->latch); VMSTATE_STRUCT_ARRAY(timers, CUDAState, 2, 1,
qemu_get_be16s(f, &s->counter_value); vmstate_cuda_timer, CUDATimer),
qemu_get_sbe64s(f, &s->load_time); VMSTATE_END_OF_LIST()
qemu_get_sbe64s(f, &s->next_irq_time); }
if (s->timer) };
qemu_get_timer(f, s->timer);
}
static int cuda_load(QEMUFile *f, void *opaque, int version_id)
{
CUDAState *s = (CUDAState *)opaque;
if (version_id != 1)
return -EINVAL;
s->b = qemu_get_ubyte(f);
s->a = qemu_get_ubyte(f);
s->dirb = qemu_get_ubyte(f);
s->dira = qemu_get_ubyte(f);
s->sr = qemu_get_ubyte(f);
s->acr = qemu_get_ubyte(f);
s->pcr = qemu_get_ubyte(f);
s->ifr = qemu_get_ubyte(f);
s->ier = qemu_get_ubyte(f);
s->anh = qemu_get_ubyte(f);
qemu_get_sbe32s(f, &s->data_in_size);
qemu_get_sbe32s(f, &s->data_in_index);
qemu_get_sbe32s(f, &s->data_out_index);
s->autopoll = qemu_get_ubyte(f);
qemu_get_buffer(f, s->data_in, sizeof(s->data_in));
qemu_get_buffer(f, s->data_out, sizeof(s->data_out));
qemu_get_be32s(f, &s->tick_offset);
cuda_load_timer(f, &s->timers[0]);
cuda_load_timer(f, &s->timers[1]);
return 0;
}
static void cuda_reset(void *opaque) static void cuda_reset(void *opaque)
{ {
@ -764,6 +740,6 @@ void cuda_init (int *cuda_mem_index, qemu_irq irq)
s->adb_poll_timer = qemu_new_timer_ns(vm_clock, cuda_adb_poll, s); s->adb_poll_timer = qemu_new_timer_ns(vm_clock, cuda_adb_poll, s);
*cuda_mem_index = cpu_register_io_memory(cuda_read, cuda_write, s, *cuda_mem_index = cpu_register_io_memory(cuda_read, cuda_write, s,
DEVICE_NATIVE_ENDIAN); DEVICE_NATIVE_ENDIAN);
register_savevm(NULL, "cuda", -1, 1, cuda_save, cuda_load, s); vmstate_register(NULL, -1, &vmstate_cuda, s);
qemu_register_reset(cuda_reset, s); qemu_register_reset(cuda_reset, s);
} }