drm/amd/powerplay: refine code in amd_powerplay.c (v2)
[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         return ret;
102 }
103
104
105 static int amdgpu_pp_late_init(void *handle)
106 {
107         int ret = 0;
108         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
109
110         if (adev->powerplay.ip_funcs->late_init)
111                 ret = adev->powerplay.ip_funcs->late_init(
112                                         adev->powerplay.pp_handle);
113
114         return ret;
115 }
116
117 static int amdgpu_pp_sw_init(void *handle)
118 {
119         int ret = 0;
120         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
121
122         if (adev->powerplay.ip_funcs->sw_init)
123                 ret = adev->powerplay.ip_funcs->sw_init(
124                                         adev->powerplay.pp_handle);
125
126         return ret;
127 }
128
129 static int amdgpu_pp_sw_fini(void *handle)
130 {
131         int ret = 0;
132         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
133
134         if (adev->powerplay.ip_funcs->sw_fini)
135                 ret = adev->powerplay.ip_funcs->sw_fini(
136                                         adev->powerplay.pp_handle);
137         if (ret)
138                 return ret;
139
140         return ret;
141 }
142
143 static int amdgpu_pp_hw_init(void *handle)
144 {
145         int ret = 0;
146         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
147
148
149         if (adev->powerplay.ip_funcs->hw_init)
150                 ret = adev->powerplay.ip_funcs->hw_init(
151                                         adev->powerplay.pp_handle);
152
153         return ret;
154 }
155
156 static int amdgpu_pp_hw_fini(void *handle)
157 {
158         int ret = 0;
159         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
160
161         if (adev->powerplay.ip_funcs->hw_fini)
162                 ret = adev->powerplay.ip_funcs->hw_fini(
163                                         adev->powerplay.pp_handle);
164
165         return ret;
166 }
167
168 static void amdgpu_pp_late_fini(void *handle)
169 {
170         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
171
172         if (adev->powerplay.ip_funcs->late_fini)
173                 adev->powerplay.ip_funcs->late_fini(
174                           adev->powerplay.pp_handle);
175
176         if (adev->powerplay.cgs_device)
177                 amdgpu_cgs_destroy_device(adev->powerplay.cgs_device);
178 }
179
180 static int amdgpu_pp_suspend(void *handle)
181 {
182         int ret = 0;
183         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
184
185         if (adev->powerplay.ip_funcs->suspend)
186                 ret = adev->powerplay.ip_funcs->suspend(
187                                          adev->powerplay.pp_handle);
188         return ret;
189 }
190
191 static int amdgpu_pp_resume(void *handle)
192 {
193         int ret = 0;
194         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
195
196         if (adev->powerplay.ip_funcs->resume)
197                 ret = adev->powerplay.ip_funcs->resume(
198                                         adev->powerplay.pp_handle);
199         return ret;
200 }
201
202 static int amdgpu_pp_set_clockgating_state(void *handle,
203                                         enum amd_clockgating_state state)
204 {
205         int ret = 0;
206         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
207
208         if (adev->powerplay.ip_funcs->set_clockgating_state)
209                 ret = adev->powerplay.ip_funcs->set_clockgating_state(
210                                 adev->powerplay.pp_handle, state);
211         return ret;
212 }
213
214 static int amdgpu_pp_set_powergating_state(void *handle,
215                                         enum amd_powergating_state state)
216 {
217         int ret = 0;
218         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
219
220         if (adev->powerplay.ip_funcs->set_powergating_state)
221                 ret = adev->powerplay.ip_funcs->set_powergating_state(
222                                  adev->powerplay.pp_handle, state);
223         return ret;
224 }
225
226
227 static bool amdgpu_pp_is_idle(void *handle)
228 {
229         bool ret = true;
230         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
231
232         if (adev->powerplay.ip_funcs->is_idle)
233                 ret = adev->powerplay.ip_funcs->is_idle(
234                                         adev->powerplay.pp_handle);
235         return ret;
236 }
237
238 static int amdgpu_pp_wait_for_idle(void *handle)
239 {
240         int ret = 0;
241         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
242
243         if (adev->powerplay.ip_funcs->wait_for_idle)
244                 ret = adev->powerplay.ip_funcs->wait_for_idle(
245                                         adev->powerplay.pp_handle);
246         return ret;
247 }
248
249 static int amdgpu_pp_soft_reset(void *handle)
250 {
251         int ret = 0;
252         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
253
254         if (adev->powerplay.ip_funcs->soft_reset)
255                 ret = adev->powerplay.ip_funcs->soft_reset(
256                                         adev->powerplay.pp_handle);
257         return ret;
258 }
259
260 static const struct amd_ip_funcs amdgpu_pp_ip_funcs = {
261         .name = "amdgpu_powerplay",
262         .early_init = amdgpu_pp_early_init,
263         .late_init = amdgpu_pp_late_init,
264         .sw_init = amdgpu_pp_sw_init,
265         .sw_fini = amdgpu_pp_sw_fini,
266         .hw_init = amdgpu_pp_hw_init,
267         .hw_fini = amdgpu_pp_hw_fini,
268         .late_fini = amdgpu_pp_late_fini,
269         .suspend = amdgpu_pp_suspend,
270         .resume = amdgpu_pp_resume,
271         .is_idle = amdgpu_pp_is_idle,
272         .wait_for_idle = amdgpu_pp_wait_for_idle,
273         .soft_reset = amdgpu_pp_soft_reset,
274         .set_clockgating_state = amdgpu_pp_set_clockgating_state,
275         .set_powergating_state = amdgpu_pp_set_powergating_state,
276 };
277
278 const struct amdgpu_ip_block_version amdgpu_pp_ip_block =
279 {
280         .type = AMD_IP_BLOCK_TYPE_SMC,
281         .major = 1,
282         .minor = 0,
283         .rev = 0,
284         .funcs = &amdgpu_pp_ip_funcs,
285 };