1649b1e3f23db08ac331a2fe70f9238ec3cc9d84
[muen/linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_powerplay.c
1 /*
2  * Copyright 2015 Advanced Micro Devices, Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors: AMD
23  *
24  */
25 #include "atom.h"
26 #include "amdgpu.h"
27 #include "amd_shared.h"
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include "amdgpu_pm.h"
31 #include <drm/amdgpu_drm.h>
32 #include "amdgpu_powerplay.h"
33 #include "si_dpm.h"
34 #include "cik_dpm.h"
35 #include "vi_dpm.h"
36
37 static int amdgpu_pp_early_init(void *handle)
38 {
39         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
40         struct amd_powerplay *amd_pp;
41         int ret = 0;
42
43         amd_pp = &(adev->powerplay);
44         amd_pp->pp_handle = (void *)adev;
45
46         switch (adev->asic_type) {
47         case CHIP_POLARIS11:
48         case CHIP_POLARIS10:
49         case CHIP_POLARIS12:
50         case CHIP_TONGA:
51         case CHIP_FIJI:
52         case CHIP_TOPAZ:
53         case CHIP_CARRIZO:
54         case CHIP_STONEY:
55         case CHIP_VEGA10:
56         case CHIP_RAVEN:
57                 amd_pp->cgs_device = amdgpu_cgs_create_device(adev);
58                 amd_pp->ip_funcs = &pp_ip_funcs;
59                 amd_pp->pp_funcs = &pp_dpm_funcs;
60                 break;
61         /* These chips don't have powerplay implemenations */
62 #ifdef CONFIG_DRM_AMDGPU_SI
63         case CHIP_TAHITI:
64         case CHIP_PITCAIRN:
65         case CHIP_VERDE:
66         case CHIP_OLAND:
67         case CHIP_HAINAN:
68                 amd_pp->ip_funcs = &si_dpm_ip_funcs;
69                 amd_pp->pp_funcs = &si_dpm_funcs;
70         break;
71 #endif
72 #ifdef CONFIG_DRM_AMDGPU_CIK
73         case CHIP_BONAIRE:
74         case CHIP_HAWAII:
75                 if (amdgpu_dpm == -1) {
76                         amd_pp->ip_funcs = &ci_dpm_ip_funcs;
77                         amd_pp->pp_funcs = &ci_dpm_funcs;
78                 } else {
79                         amd_pp->cgs_device = amdgpu_cgs_create_device(adev);
80                         amd_pp->ip_funcs = &pp_ip_funcs;
81                         amd_pp->pp_funcs = &pp_dpm_funcs;
82                 }
83                 break;
84         case CHIP_KABINI:
85         case CHIP_MULLINS:
86         case CHIP_KAVERI:
87                 amd_pp->ip_funcs = &kv_dpm_ip_funcs;
88                 amd_pp->pp_funcs = &kv_dpm_funcs;
89                 break;
90 #endif
91         default:
92                 ret = -EINVAL;
93                 break;
94         }
95
96         if (adev->powerplay.ip_funcs->early_init)
97                 ret = adev->powerplay.ip_funcs->early_init(
98                                         amd_pp->cgs_device ? amd_pp->cgs_device :
99                                         amd_pp->pp_handle);
100
101         if (ret == PP_DPM_DISABLED) {
102                 adev->pm.dpm_enabled = false;
103                 return 0;
104         }
105         return ret;
106 }
107
108
109 static int amdgpu_pp_late_init(void *handle)
110 {
111         int ret = 0;
112         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
113
114         if (adev->powerplay.ip_funcs->late_init)
115                 ret = adev->powerplay.ip_funcs->late_init(
116                                         adev->powerplay.pp_handle);
117
118         return ret;
119 }
120
121 static int amdgpu_pp_sw_init(void *handle)
122 {
123         int ret = 0;
124         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
125
126         if (adev->powerplay.ip_funcs->sw_init)
127                 ret = adev->powerplay.ip_funcs->sw_init(
128                                         adev->powerplay.pp_handle);
129
130         return ret;
131 }
132
133 static int amdgpu_pp_sw_fini(void *handle)
134 {
135         int ret = 0;
136         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
137
138         if (adev->powerplay.ip_funcs->sw_fini)
139                 ret = adev->powerplay.ip_funcs->sw_fini(
140                                         adev->powerplay.pp_handle);
141         if (ret)
142                 return ret;
143
144         return ret;
145 }
146
147 static int amdgpu_pp_hw_init(void *handle)
148 {
149         int ret = 0;
150         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
151
152
153         if (adev->powerplay.ip_funcs->hw_init)
154                 ret = adev->powerplay.ip_funcs->hw_init(
155                                         adev->powerplay.pp_handle);
156
157         if (ret == PP_DPM_DISABLED) {
158                 adev->pm.dpm_enabled = false;
159                 return 0;
160         }
161
162         if ((amdgpu_dpm != 0) && !amdgpu_sriov_vf(adev))
163                 adev->pm.dpm_enabled = true;
164
165         return ret;
166 }
167
168 static int amdgpu_pp_hw_fini(void *handle)
169 {
170         int ret = 0;
171         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
172
173         if (adev->powerplay.ip_funcs->hw_fini)
174                 ret = adev->powerplay.ip_funcs->hw_fini(
175                                         adev->powerplay.pp_handle);
176
177         return ret;
178 }
179
180 static void amdgpu_pp_late_fini(void *handle)
181 {
182         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
183
184         if (adev->powerplay.ip_funcs->late_fini)
185                 adev->powerplay.ip_funcs->late_fini(
186                           adev->powerplay.pp_handle);
187
188         if (adev->powerplay.cgs_device)
189                 amdgpu_cgs_destroy_device(adev->powerplay.cgs_device);
190 }
191
192 static int amdgpu_pp_suspend(void *handle)
193 {
194         int ret = 0;
195         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
196
197         if (adev->powerplay.ip_funcs->suspend)
198                 ret = adev->powerplay.ip_funcs->suspend(
199                                          adev->powerplay.pp_handle);
200         return ret;
201 }
202
203 static int amdgpu_pp_resume(void *handle)
204 {
205         int ret = 0;
206         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
207
208         if (adev->powerplay.ip_funcs->resume)
209                 ret = adev->powerplay.ip_funcs->resume(
210                                         adev->powerplay.pp_handle);
211         return ret;
212 }
213
214 static int amdgpu_pp_set_clockgating_state(void *handle,
215                                         enum amd_clockgating_state state)
216 {
217         int ret = 0;
218         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
219
220         if (adev->powerplay.ip_funcs->set_clockgating_state)
221                 ret = adev->powerplay.ip_funcs->set_clockgating_state(
222                                 adev->powerplay.pp_handle, state);
223         return ret;
224 }
225
226 static int amdgpu_pp_set_powergating_state(void *handle,
227                                         enum amd_powergating_state state)
228 {
229         int ret = 0;
230         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
231
232         if (adev->powerplay.ip_funcs->set_powergating_state)
233                 ret = adev->powerplay.ip_funcs->set_powergating_state(
234                                  adev->powerplay.pp_handle, state);
235         return ret;
236 }
237
238
239 static bool amdgpu_pp_is_idle(void *handle)
240 {
241         bool ret = true;
242         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
243
244         if (adev->powerplay.ip_funcs->is_idle)
245                 ret = adev->powerplay.ip_funcs->is_idle(
246                                         adev->powerplay.pp_handle);
247         return ret;
248 }
249
250 static int amdgpu_pp_wait_for_idle(void *handle)
251 {
252         int ret = 0;
253         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
254
255         if (adev->powerplay.ip_funcs->wait_for_idle)
256                 ret = adev->powerplay.ip_funcs->wait_for_idle(
257                                         adev->powerplay.pp_handle);
258         return ret;
259 }
260
261 static int amdgpu_pp_soft_reset(void *handle)
262 {
263         int ret = 0;
264         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
265
266         if (adev->powerplay.ip_funcs->soft_reset)
267                 ret = adev->powerplay.ip_funcs->soft_reset(
268                                         adev->powerplay.pp_handle);
269         return ret;
270 }
271
272 static const struct amd_ip_funcs amdgpu_pp_ip_funcs = {
273         .name = "amdgpu_powerplay",
274         .early_init = amdgpu_pp_early_init,
275         .late_init = amdgpu_pp_late_init,
276         .sw_init = amdgpu_pp_sw_init,
277         .sw_fini = amdgpu_pp_sw_fini,
278         .hw_init = amdgpu_pp_hw_init,
279         .hw_fini = amdgpu_pp_hw_fini,
280         .late_fini = amdgpu_pp_late_fini,
281         .suspend = amdgpu_pp_suspend,
282         .resume = amdgpu_pp_resume,
283         .is_idle = amdgpu_pp_is_idle,
284         .wait_for_idle = amdgpu_pp_wait_for_idle,
285         .soft_reset = amdgpu_pp_soft_reset,
286         .set_clockgating_state = amdgpu_pp_set_clockgating_state,
287         .set_powergating_state = amdgpu_pp_set_powergating_state,
288 };
289
290 const struct amdgpu_ip_block_version amdgpu_pp_ip_block =
291 {
292         .type = AMD_IP_BLOCK_TYPE_SMC,
293         .major = 1,
294         .minor = 0,
295         .rev = 0,
296         .funcs = &amdgpu_pp_ip_funcs,
297 };