Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[platform/adaptation/renesas_rcar/renesas_kernel.git] / drivers / xen / xen-acpi-pad.c
1 /*
2  * xen-acpi-pad.c - Xen pad interface
3  *
4  * Copyright (c) 2012, Intel Corporation.
5  *    Author: Liu, Jinsong <jinsong.liu@intel.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  */
16
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
19 #include <linux/kernel.h>
20 #include <linux/types.h>
21 #include <acpi/acpi_bus.h>
22 #include <acpi/acpi_drivers.h>
23 #include <asm/xen/hypercall.h>
24 #include <xen/interface/version.h>
25 #include <xen/xen-ops.h>
26
27 #define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"
28 #define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
29 #define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
30 static DEFINE_MUTEX(xen_cpu_lock);
31
32 static int xen_acpi_pad_idle_cpus(unsigned int idle_nums)
33 {
34         struct xen_platform_op op;
35
36         op.cmd = XENPF_core_parking;
37         op.u.core_parking.type = XEN_CORE_PARKING_SET;
38         op.u.core_parking.idle_nums = idle_nums;
39
40         return HYPERVISOR_dom0_op(&op);
41 }
42
43 static int xen_acpi_pad_idle_cpus_num(void)
44 {
45         struct xen_platform_op op;
46
47         op.cmd = XENPF_core_parking;
48         op.u.core_parking.type = XEN_CORE_PARKING_GET;
49
50         return HYPERVISOR_dom0_op(&op)
51                ?: op.u.core_parking.idle_nums;
52 }
53
54 /*
55  * Query firmware how many CPUs should be idle
56  * return -1 on failure
57  */
58 static int acpi_pad_pur(acpi_handle handle)
59 {
60         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
61         union acpi_object *package;
62         int num = -1;
63
64         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_PUR", NULL, &buffer)))
65                 return num;
66
67         if (!buffer.length || !buffer.pointer)
68                 return num;
69
70         package = buffer.pointer;
71
72         if (package->type == ACPI_TYPE_PACKAGE &&
73                 package->package.count == 2 &&
74                 package->package.elements[0].integer.value == 1) /* rev 1 */
75                 num = package->package.elements[1].integer.value;
76
77         kfree(buffer.pointer);
78         return num;
79 }
80
81 /* Notify firmware how many CPUs are idle */
82 static void acpi_pad_ost(acpi_handle handle, int stat,
83         uint32_t idle_nums)
84 {
85         union acpi_object params[3] = {
86                 {.type = ACPI_TYPE_INTEGER,},
87                 {.type = ACPI_TYPE_INTEGER,},
88                 {.type = ACPI_TYPE_BUFFER,},
89         };
90         struct acpi_object_list arg_list = {3, params};
91
92         params[0].integer.value = ACPI_PROCESSOR_AGGREGATOR_NOTIFY;
93         params[1].integer.value =  stat;
94         params[2].buffer.length = 4;
95         params[2].buffer.pointer = (void *)&idle_nums;
96         acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
97 }
98
99 static void acpi_pad_handle_notify(acpi_handle handle)
100 {
101         int idle_nums;
102
103         mutex_lock(&xen_cpu_lock);
104         idle_nums = acpi_pad_pur(handle);
105         if (idle_nums < 0) {
106                 mutex_unlock(&xen_cpu_lock);
107                 return;
108         }
109
110         idle_nums = xen_acpi_pad_idle_cpus(idle_nums)
111                     ?: xen_acpi_pad_idle_cpus_num();
112         if (idle_nums >= 0)
113                 acpi_pad_ost(handle, 0, idle_nums);
114         mutex_unlock(&xen_cpu_lock);
115 }
116
117 static void acpi_pad_notify(acpi_handle handle, u32 event,
118         void *data)
119 {
120         switch (event) {
121         case ACPI_PROCESSOR_AGGREGATOR_NOTIFY:
122                 acpi_pad_handle_notify(handle);
123                 break;
124         default:
125                 pr_warn("Unsupported event [0x%x]\n", event);
126                 break;
127         }
128 }
129
130 static int acpi_pad_add(struct acpi_device *device)
131 {
132         acpi_status status;
133
134         strcpy(acpi_device_name(device), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME);
135         strcpy(acpi_device_class(device), ACPI_PROCESSOR_AGGREGATOR_CLASS);
136
137         status = acpi_install_notify_handler(device->handle,
138                 ACPI_DEVICE_NOTIFY, acpi_pad_notify, device);
139         if (ACPI_FAILURE(status))
140                 return -ENODEV;
141
142         return 0;
143 }
144
145 static int acpi_pad_remove(struct acpi_device *device)
146 {
147         mutex_lock(&xen_cpu_lock);
148         xen_acpi_pad_idle_cpus(0);
149         mutex_unlock(&xen_cpu_lock);
150
151         acpi_remove_notify_handler(device->handle,
152                 ACPI_DEVICE_NOTIFY, acpi_pad_notify);
153         return 0;
154 }
155
156 static const struct acpi_device_id pad_device_ids[] = {
157         {"ACPI000C", 0},
158         {"", 0},
159 };
160
161 static struct acpi_driver acpi_pad_driver = {
162         .name = "processor_aggregator",
163         .class = ACPI_PROCESSOR_AGGREGATOR_CLASS,
164         .ids = pad_device_ids,
165         .ops = {
166                 .add = acpi_pad_add,
167                 .remove = acpi_pad_remove,
168         },
169 };
170
171 static int __init xen_acpi_pad_init(void)
172 {
173         /* Only DOM0 is responsible for Xen acpi pad */
174         if (!xen_initial_domain())
175                 return -ENODEV;
176
177         /* Only Xen4.2 or later support Xen acpi pad */
178         if (!xen_running_on_version_or_later(4, 2))
179                 return -ENODEV;
180
181         return acpi_bus_register_driver(&acpi_pad_driver);
182 }
183 subsys_initcall(xen_acpi_pad_init);