sh4: Fix serial line access for Linux kernels later than 3.2

[qemu.git] / xen-all.c

diff --git a/xen-all.c b/xen-all.c
index dcb57a0a5681360104062cf05e680c86bacf1016..48e881bc29a0ab3f214cf220ce68d90867e10484 100644 (file)
--- a/xen-all.c
+++ b/xen-all.c
@@ -98,6 +98,7 @@ typedef struct XenIOState {
 
     Notifier exit;
     Notifier suspend;
 
     Notifier exit;
     Notifier suspend;

+    Notifier wakeup;

 } XenIOState;
 
 /* Xen specific function for piix pci */
 } XenIOState;
 
 /* Xen specific function for piix pci */


@@ -154,7 +155,7 @@ qemu_irq *xen_interrupt_controller_init(void)
 
 /* Memory Ops */
 
 
 /* Memory Ops */
 

-static void xen_ram_init(ram_addr_t ram_size)
+static void xen_ram_init(ram_addr_t ram_size, MemoryRegion **ram_memory_p)

 {
     MemoryRegion *sysmem = get_system_memory();
     ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
 {
     MemoryRegion *sysmem = get_system_memory();
     ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;


@@ -167,7 +168,8 @@ static void xen_ram_init(ram_addr_t ram_size)
          */
         block_len += HVM_BELOW_4G_MMIO_LENGTH;
     }
          */
         block_len += HVM_BELOW_4G_MMIO_LENGTH;
     }

-    memory_region_init_ram(&ram_memory, "xen.ram", block_len);
+    memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len);
+    *ram_memory_p = &ram_memory;

     vmstate_register_ram_global(&ram_memory);
 
     if (ram_size >= HVM_BELOW_4G_RAM_END) {
     vmstate_register_ram_global(&ram_memory);
 
     if (ram_size >= HVM_BELOW_4G_RAM_END) {


@@ -177,7 +179,7 @@ static void xen_ram_init(ram_addr_t ram_size)
         below_4g_mem_size = ram_size;
     }
 
         below_4g_mem_size = ram_size;
     }
 

-    memory_region_init_alias(&ram_640k, "xen.ram.640k",
+    memory_region_init_alias(&ram_640k, NULL, "xen.ram.640k",

                              &ram_memory, 0, 0xa0000);
     memory_region_add_subregion(sysmem, 0, &ram_640k);
     /* Skip of the VGA IO memory space, it will be registered later by the VGA
                              &ram_memory, 0, 0xa0000);
     memory_region_add_subregion(sysmem, 0, &ram_640k);
     /* Skip of the VGA IO memory space, it will be registered later by the VGA


@@ -186,11 +188,11 @@ static void xen_ram_init(ram_addr_t ram_size)
      * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load
      * the Options ROM, so it is registered here as RAM.
      */
      * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load
      * the Options ROM, so it is registered here as RAM.
      */

-    memory_region_init_alias(&ram_lo, "xen.ram.lo",
+    memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo",

                              &ram_memory, 0xc0000, below_4g_mem_size - 0xc0000);
     memory_region_add_subregion(sysmem, 0xc0000, &ram_lo);
     if (above_4g_mem_size > 0) {
                              &ram_memory, 0xc0000, below_4g_mem_size - 0xc0000);
     memory_region_add_subregion(sysmem, 0xc0000, &ram_lo);
     if (above_4g_mem_size > 0) {

-        memory_region_init_alias(&ram_hi, "xen.ram.hi",
+        memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi",

                                  &ram_memory, 0x100000000ULL,
                                  above_4g_mem_size);
         memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi);
                                  &ram_memory, 0x100000000ULL,
                                  above_4g_mem_size);
         memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi);


@@ -459,6 +461,7 @@ static void xen_set_memory(struct MemoryListener *listener,
 static void xen_region_add(MemoryListener *listener,
                            MemoryRegionSection *section)
 {
 static void xen_region_add(MemoryListener *listener,
                            MemoryRegionSection *section)
 {

+    memory_region_ref(section->mr);

     xen_set_memory(listener, section, true);
 }
 
     xen_set_memory(listener, section, true);
 }
 


@@ -466,6 +469,7 @@ static void xen_region_del(MemoryListener *listener,
                            MemoryRegionSection *section)
 {
     xen_set_memory(listener, section, false);
                            MemoryRegionSection *section)
 {
     xen_set_memory(listener, section, false);

+    memory_region_unref(section->mr);

 }
 
 static void xen_sync_dirty_bitmap(XenIOState *state,
 }
 
 static void xen_sync_dirty_bitmap(XenIOState *state,


@@ -604,19 +608,19 @@ static ioreq_t *cpu_get_ioreq(XenIOState *state)
 
     port = xc_evtchn_pending(state->xce_handle);
     if (port == state->bufioreq_local_port) {
 
     port = xc_evtchn_pending(state->xce_handle);
     if (port == state->bufioreq_local_port) {

-        qemu_mod_timer(state->buffered_io_timer,
-                BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
+        timer_mod(state->buffered_io_timer,
+                BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));

         return NULL;
     }
 
     if (port != -1) {
         return NULL;
     }
 
     if (port != -1) {

-        for (i = 0; i < smp_cpus; i++) {
+        for (i = 0; i < max_cpus; i++) {

             if (state->ioreq_local_port[i] == port) {
                 break;
             }
         }
 
             if (state->ioreq_local_port[i] == port) {
                 break;
             }
         }
 

-        if (i == smp_cpus) {
+        if (i == max_cpus) {

             hw_error("Fatal error while trying to get io event!\n");
         }
 
             hw_error("Fatal error while trying to get io event!\n");
         }
 


@@ -826,10 +830,10 @@ static void handle_buffered_io(void *opaque)
     XenIOState *state = opaque;
 
     if (handle_buffered_iopage(state)) {
     XenIOState *state = opaque;
 
     if (handle_buffered_iopage(state)) {

-        qemu_mod_timer(state->buffered_io_timer,
-                BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
+        timer_mod(state->buffered_io_timer,
+                BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));

     } else {
     } else {

-        qemu_del_timer(state->buffered_io_timer);
+        timer_del(state->buffered_io_timer);

         xc_evtchn_unmask(state->xce_handle, state->bufioreq_local_port);
     }
 }
         xc_evtchn_unmask(state->xce_handle, state->bufioreq_local_port);
     }
 }


@@ -960,7 +964,7 @@ static void xen_main_loop_prepare(XenIOState *state)
         evtchn_fd = xc_evtchn_fd(state->xce_handle);
     }
 
         evtchn_fd = xc_evtchn_fd(state->xce_handle);
     }
 

-    state->buffered_io_timer = qemu_new_timer_ms(rt_clock, handle_buffered_io,
+    state->buffered_io_timer = timer_new_ms(QEMU_CLOCK_REALTIME, handle_buffered_io,

                                                  state);
 
     if (evtchn_fd != -1) {
                                                  state);
 
     if (evtchn_fd != -1) {


@@ -1057,7 +1061,12 @@ static void xen_read_physmap(XenIOState *state)
     free(entries);
 }
 
     free(entries);
 }
 

-int xen_hvm_init(void)
+static void xen_wakeup_notifier(Notifier *notifier, void *data)
+{
+    xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 0);
+}
+
+int xen_hvm_init(MemoryRegion **ram_memory)

 {
     int i, rc;
     unsigned long ioreq_pfn;
 {
     int i, rc;
     unsigned long ioreq_pfn;


@@ -1086,6 +1095,9 @@ int xen_hvm_init(void)
     state->suspend.notify = xen_suspend_notifier;
     qemu_register_suspend_notifier(&state->suspend);
 
     state->suspend.notify = xen_suspend_notifier;
     qemu_register_suspend_notifier(&state->suspend);
 

+    state->wakeup.notify = xen_wakeup_notifier;
+    qemu_register_wakeup_notifier(&state->wakeup);
+

     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
     DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
     state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
     DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
     state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,


@@ -1103,10 +1115,10 @@ int xen_hvm_init(void)
         hw_error("map buffered IO page returned error %d", errno);
     }
 
         hw_error("map buffered IO page returned error %d", errno);
     }
 

-    state->ioreq_local_port = g_malloc0(smp_cpus * sizeof (evtchn_port_t));
+    state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));

 
     /* FIXME: how about if we overflow the page here? */
 
     /* FIXME: how about if we overflow the page here? */

-    for (i = 0; i < smp_cpus; i++) {
+    for (i = 0; i < max_cpus; i++) {

         rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
                                         xen_vcpu_eport(state->shared_page, i));
         if (rc == -1) {
         rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
                                         xen_vcpu_eport(state->shared_page, i));
         if (rc == -1) {


@@ -1132,7 +1144,7 @@ int xen_hvm_init(void)
 
     /* Init RAM management */
     xen_map_cache_init(xen_phys_offset_to_gaddr, state);
 
     /* Init RAM management */
     xen_map_cache_init(xen_phys_offset_to_gaddr, state);

-    xen_ram_init(ram_size);
+    xen_ram_init(ram_size, ram_memory);

 
     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
 
 
     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);