}
 
 static inline int
-HYPERVISOR_dom0_op(struct xen_platform_op *platform_op)
+HYPERVISOR_platform_op(struct xen_platform_op *op)
 {
-       platform_op->interface_version = XENPF_INTERFACE_VERSION;
-       return _hypercall1(int, dom0_op, platform_op);
+       op->interface_version = XENPF_INTERFACE_VERSION;
+       return _hypercall1(int, platform_op, op);
 }
 
 static inline int
 
        if (reg != APIC_ID)
                return 0;
 
-       ret = HYPERVISOR_dom0_op(&op);
+       ret = HYPERVISOR_platform_op(&op);
        if (ret)
                return 0;
 
 
 
        set_xen_guest_handle(op.u.set_pminfo.pdc, buf);
 
-       if ((HYPERVISOR_dom0_op(&op) == 0) &&
+       if ((HYPERVISOR_platform_op(&op) == 0) &&
            (buf[2] & (ACPI_PDC_C_C1_FFH | ACPI_PDC_C_C2C3_FFH))) {
                cpuid_leaf5_ecx_val = cx;
                cpuid_leaf5_edx_val = dx;
                info->params.length = sizeof(info->params);
                set_xen_guest_handle(op.u.firmware_info.u.disk_info.edd_params,
                                     &info->params);
-               ret = HYPERVISOR_dom0_op(&op);
+               ret = HYPERVISOR_platform_op(&op);
                if (ret)
                        break;
 
        op.u.firmware_info.type = XEN_FW_DISK_MBR_SIGNATURE;
        for (nr = 0; nr < EDD_MBR_SIG_MAX; nr++) {
                op.u.firmware_info.index = nr;
-               ret = HYPERVISOR_dom0_op(&op);
+               ret = HYPERVISOR_platform_op(&op);
                if (ret)
                        break;
                mbr_signature[nr] = op.u.firmware_info.u.disk_mbr_signature.mbr_signature;
                xen_start_info->console.domU.mfn = 0;
                xen_start_info->console.domU.evtchn = 0;
 
-               if (HYPERVISOR_dom0_op(&op) == 0)
+               if (HYPERVISOR_platform_op(&op) == 0)
                        boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
 
                /* Make sure ACS will be enabled */
 
        op.u.settime.nsecs = now.tv_nsec;
        op.u.settime.system_time = xen_clocksource_read();
 
-       (void)HYPERVISOR_dom0_op(&op);
+       (void)HYPERVISOR_platform_op(&op);
 
        /*
         * Move the next drift compensation time 11 minutes
 
                 bits, val_a, val_b))
                return -1;
 
-       HYPERVISOR_dom0_op(&op);
+       HYPERVISOR_platform_op(&op);
        return 1;
 }
 
 
 {
        struct xen_platform_op op = INIT_EFI_OP(get_time);
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        if (tm) {
        BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.set_time));
        memcpy(&efi_data(op).u.set_time, tm, sizeof(*tm));
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        return efi_data(op).status;
 {
        struct xen_platform_op op = INIT_EFI_OP(get_wakeup_time);
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        if (tm) {
        else
                efi_data(op).misc |= XEN_EFI_SET_WAKEUP_TIME_ENABLE_ONLY;
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        return efi_data(op).status;
        efi_data(op).u.get_variable.size = *data_size;
        set_xen_guest_handle(efi_data(op).u.get_variable.data, data);
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        *data_size = efi_data(op).u.get_variable.size;
        memcpy(&efi_data(op).u.get_next_variable_name.vendor_guid, vendor,
               sizeof(*vendor));
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        *name_size = efi_data(op).u.get_next_variable_name.size;
        efi_data(op).u.set_variable.size = data_size;
        set_xen_guest_handle(efi_data(op).u.set_variable.data, data);
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        return efi_data(op).status;
 
        efi_data(op).u.query_variable_info.attr = attr;
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        *storage_space = efi_data(op).u.query_variable_info.max_store_size;
 {
        struct xen_platform_op op = INIT_EFI_OP(get_next_high_monotonic_count);
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        *count = efi_data(op).misc;
        efi_data(op).u.update_capsule.capsule_count = count;
        efi_data(op).u.update_capsule.sg_list = sg_list;
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        return efi_data(op).status;
                                        capsules);
        efi_data(op).u.query_capsule_capabilities.capsule_count = count;
 
-       if (HYPERVISOR_dom0_op(&op) < 0)
+       if (HYPERVISOR_platform_op(&op) < 0)
                return EFI_UNSUPPORTED;
 
        *max_size = efi_data(op).u.query_capsule_capabilities.max_capsule_size;
        };
        union xenpf_efi_info *info = &op.u.firmware_info.u.efi_info;
 
-       if (!xen_initial_domain() || HYPERVISOR_dom0_op(&op) < 0)
+       if (!xen_initial_domain() || HYPERVISOR_platform_op(&op) < 0)
                return NULL;
 
        /* Here we know that Xen runs on EFI platform. */
        info->vendor.bufsz = sizeof(vendor);
        set_xen_guest_handle(info->vendor.name, vendor);
 
-       if (HYPERVISOR_dom0_op(&op) == 0) {
+       if (HYPERVISOR_platform_op(&op) == 0) {
                efi_systab_xen.fw_vendor = __pa_symbol(vendor);
                efi_systab_xen.fw_revision = info->vendor.revision;
        } else
        op.u.firmware_info.type = XEN_FW_EFI_INFO;
        op.u.firmware_info.index = XEN_FW_EFI_VERSION;
 
-       if (HYPERVISOR_dom0_op(&op) == 0)
+       if (HYPERVISOR_platform_op(&op) == 0)
                efi_systab_xen.hdr.revision = info->version;
 
        op.cmd = XENPF_firmware_info;
        op.u.firmware_info.type = XEN_FW_EFI_INFO;
        op.u.firmware_info.index = XEN_FW_EFI_RT_VERSION;
 
-       if (HYPERVISOR_dom0_op(&op) == 0)
+       if (HYPERVISOR_platform_op(&op) == 0)
                efi.runtime_version = info->version;
 
        return &efi_systab_xen;
 
                .u.cpu_ol.cpuid         = cpu_id,
        };
 
-       return HYPERVISOR_dom0_op(&op);
+       return HYPERVISOR_platform_op(&op);
 }
 
 static int xen_pcpu_up(uint32_t cpu_id)
                .u.cpu_ol.cpuid         = cpu_id,
        };
 
-       return HYPERVISOR_dom0_op(&op);
+       return HYPERVISOR_platform_op(&op);
 }
 
 static ssize_t show_online(struct device *dev,
                .u.pcpu_info.xen_cpuid = cpu,
        };
 
-       ret = HYPERVISOR_dom0_op(&op);
+       ret = HYPERVISOR_platform_op(&op);
        if (ret)
                return ret;
 
        op.cmd = XENPF_get_cpuinfo;
        while (cpu_id <= max_id) {
                op.u.pcpu_info.xen_cpuid = cpu_id;
-               if (HYPERVISOR_dom0_op(&op)) {
+               if (HYPERVISOR_platform_op(&op)) {
                        cpu_id++;
                        continue;
                }
 
        op.u.cpu_add.acpi_id = pr->acpi_id;
        op.u.cpu_add.pxm = pxm;
 
-       cpu_id = HYPERVISOR_dom0_op(&op);
+       cpu_id = HYPERVISOR_platform_op(&op);
        if (cpu_id < 0)
                pr_err(PREFIX "Failed to hotadd CPU for acpi_id %d\n",
                                pr->acpi_id);
 
        op.u.core_parking.type = XEN_CORE_PARKING_SET;
        op.u.core_parking.idle_nums = idle_nums;
 
-       return HYPERVISOR_dom0_op(&op);
+       return HYPERVISOR_platform_op(&op);
 }
 
 static int xen_acpi_pad_idle_cpus_num(void)
        op.cmd = XENPF_core_parking;
        op.u.core_parking.type = XEN_CORE_PARKING_GET;
 
-       return HYPERVISOR_dom0_op(&op)
+       return HYPERVISOR_platform_op(&op)
               ?: op.u.core_parking.idle_nums;
 }
 
 
        set_xen_guest_handle(op.u.set_pminfo.power.states, dst_cx_states);
 
        if (!no_hypercall)
-               ret = HYPERVISOR_dom0_op(&op);
+               ret = HYPERVISOR_platform_op(&op);
 
        if (!ret) {
                pr_debug("ACPI CPU%u - C-states uploaded.\n", _pr->acpi_id);
        }
 
        if (!no_hypercall)
-               ret = HYPERVISOR_dom0_op(&op);
+               ret = HYPERVISOR_platform_op(&op);
 
        if (!ret) {
                struct acpi_processor_performance *perf;
        info = &op.u.pcpu_info;
        info->xen_cpuid = 0;
 
-       ret = HYPERVISOR_dom0_op(&op);
+       ret = HYPERVISOR_platform_op(&op);
        if (ret)
                return NR_CPUS;
 
        last_cpu = op.u.pcpu_info.max_present;
        for (i = 0; i <= last_cpu; i++) {
                info->xen_cpuid = i;
-               ret = HYPERVISOR_dom0_op(&op);
+               ret = HYPERVISOR_platform_op(&op);
                if (ret)
                        continue;
                max_acpi_id = max(info->acpi_id, max_acpi_id);
 
 
        symnum = symdata->symnum;
 
-       ret = HYPERVISOR_dom0_op(&xs->op);
+       ret = HYPERVISOR_platform_op(&xs->op);
        if (ret < 0)
                return ret;
 
                set_xen_guest_handle(symdata->name, xs->name);
                symdata->symnum--; /* Rewind */
 
-               ret = HYPERVISOR_dom0_op(&xs->op);
+               ret = HYPERVISOR_platform_op(&xs->op);
                if (ret < 0)
                        return ret;
        }
 
 #define __HYPERVISOR_set_callbacks         4
 #define __HYPERVISOR_fpu_taskswitch        5
 #define __HYPERVISOR_sched_op_compat       6
-#define __HYPERVISOR_dom0_op               7
+#define __HYPERVISOR_platform_op           7
 #define __HYPERVISOR_set_debugreg          8
 #define __HYPERVISOR_get_debugreg          9
 #define __HYPERVISOR_update_descriptor    10