diff options
author | Mahantesh Kumbar <mkumbar@nvidia.com> | 2016-09-19 01:37:46 -0400 |
---|---|---|
committer | Deepak Nibade <dnibade@nvidia.com> | 2016-12-27 04:56:50 -0500 |
commit | 173bdefc92e2e4ef8f1e7e6ead7f86e746bee935 (patch) | |
tree | 69d9a43a453e988c54927ade2f5ce04457eaf312 /drivers/gpu/nvgpu/volt/volt_dev.c | |
parent | db529935a5f50e9e683d44d2eb01d0d76a915792 (diff) |
gpu: nvgpu: add support for voltage config
- changes to read voltage tables from VBIOS
& create boardobj then send to pmu
- Rail, Device & Policy objects are read from VBIOS & created boardobjs
- RPC support to load, Set & get voltage.
JIRA DNVGPU-122
Change-Id: I61621a514eef9c081a64c4ab066f01dfc28f8402
Signed-off-by: Mahantesh Kumbar <mkumbar@nvidia.com>
Reviewed-on: http://git-master/r/1222774
(cherry picked from commit 9da86d8c2c547623cf5f38c89afeb3f5bb1667ac)
Reviewed-on: http://git-master/r/1244656
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>
Tested-by: Terje Bergstrom <tbergstrom@nvidia.com>
Diffstat (limited to 'drivers/gpu/nvgpu/volt/volt_dev.c')
-rw-r--r-- | drivers/gpu/nvgpu/volt/volt_dev.c | 582 |
1 files changed, 582 insertions, 0 deletions
diff --git a/drivers/gpu/nvgpu/volt/volt_dev.c b/drivers/gpu/nvgpu/volt/volt_dev.c new file mode 100644 index 00000000..89040658 --- /dev/null +++ b/drivers/gpu/nvgpu/volt/volt_dev.c | |||
@@ -0,0 +1,582 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms and conditions of the GNU General Public License, | ||
6 | * version 2, as published by the Free Software Foundation. | ||
7 | * | ||
8 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
11 | * more details. | ||
12 | */ | ||
13 | |||
14 | #include <linux/sort.h> | ||
15 | |||
16 | #include "gk20a/gk20a.h" | ||
17 | #include "include/bios.h" | ||
18 | #include "boardobj/boardobjgrp.h" | ||
19 | #include "boardobj/boardobjgrp_e32.h" | ||
20 | #include "pmuif/gpmuifboardobj.h" | ||
21 | #include "gm206/bios_gm206.h" | ||
22 | #include "ctrl/ctrlvolt.h" | ||
23 | #include "gk20a/pmu_gk20a.h" | ||
24 | |||
25 | #include "pmuif/gpmuifperfvfe.h" | ||
26 | #include "include/bios.h" | ||
27 | #include "volt.h" | ||
28 | |||
29 | #define RAW_PERIOD 160 | ||
30 | #define VOLT_DEV_PWM_VOLTAGE_STEPS_INVALID 0 | ||
31 | #define VOLT_DEV_PWM_VOLTAGE_STEPS_DEFAULT 1 | ||
32 | |||
33 | u32 volt_device_pmu_data_init_super(struct gk20a *g, | ||
34 | struct boardobj *pboard_obj, struct nv_pmu_boardobj *ppmudata) | ||
35 | { | ||
36 | u32 status; | ||
37 | struct voltage_device *pdev; | ||
38 | struct nv_pmu_volt_volt_device_boardobj_set *pset; | ||
39 | |||
40 | status = boardobj_pmudatainit_super(g, pboard_obj, ppmudata); | ||
41 | if (status) | ||
42 | return status; | ||
43 | |||
44 | pdev = (struct voltage_device *)pboard_obj; | ||
45 | pset = (struct nv_pmu_volt_volt_device_boardobj_set *)ppmudata; | ||
46 | |||
47 | pset->switch_delay_us = pdev->switch_delay_us; | ||
48 | pset->voltage_min_uv = pdev->voltage_min_uv; | ||
49 | pset->voltage_max_uv = pdev->voltage_max_uv; | ||
50 | pset->volt_step_uv = pdev->volt_step_uv; | ||
51 | |||
52 | return status; | ||
53 | } | ||
54 | |||
55 | static u32 volt_device_pmu_data_init_pwm(struct gk20a *g, | ||
56 | struct boardobj *pboard_obj, struct nv_pmu_boardobj *ppmudata) | ||
57 | { | ||
58 | u32 status = 0; | ||
59 | struct voltage_device_pwm *pdev; | ||
60 | struct nv_pmu_volt_volt_device_pwm_boardobj_set *pset; | ||
61 | |||
62 | status = volt_device_pmu_data_init_super(g, pboard_obj, ppmudata); | ||
63 | if (status) | ||
64 | return status; | ||
65 | |||
66 | pdev = (struct voltage_device_pwm *)pboard_obj; | ||
67 | pset = (struct nv_pmu_volt_volt_device_pwm_boardobj_set *)ppmudata; | ||
68 | |||
69 | pset->raw_period = pdev->raw_period; | ||
70 | pset->voltage_base_uv = pdev->voltage_base_uv; | ||
71 | pset->voltage_offset_scale_uv = pdev->voltage_offset_scale_uv; | ||
72 | pset->pwm_source = pdev->source; | ||
73 | |||
74 | return status; | ||
75 | } | ||
76 | |||
77 | u32 construct_volt_device(struct gk20a *g, | ||
78 | struct boardobj **ppboardobj, u16 size, void *pargs) | ||
79 | { | ||
80 | struct voltage_device *ptmp_dev = (struct voltage_device *)pargs; | ||
81 | struct voltage_device *pvolt_dev = NULL; | ||
82 | u32 status = 0; | ||
83 | |||
84 | status = boardobj_construct_super(g, ppboardobj, size, pargs); | ||
85 | if (status) | ||
86 | return status; | ||
87 | |||
88 | pvolt_dev = (struct voltage_device *)*ppboardobj; | ||
89 | |||
90 | pvolt_dev->volt_domain = ptmp_dev->volt_domain; | ||
91 | pvolt_dev->i2c_dev_idx = ptmp_dev->i2c_dev_idx; | ||
92 | pvolt_dev->switch_delay_us = ptmp_dev->switch_delay_us; | ||
93 | pvolt_dev->rsvd_0 = VOLTAGE_DESCRIPTOR_TABLE_ENTRY_INVALID; | ||
94 | pvolt_dev->rsvd_1 = | ||
95 | VOLTAGE_DESCRIPTOR_TABLE_ENTRY_INVALID; | ||
96 | pvolt_dev->operation_type = ptmp_dev->operation_type; | ||
97 | pvolt_dev->voltage_min_uv = ptmp_dev->voltage_min_uv; | ||
98 | pvolt_dev->voltage_max_uv = ptmp_dev->voltage_max_uv; | ||
99 | |||
100 | pvolt_dev->super.pmudatainit = volt_device_pmu_data_init_super; | ||
101 | |||
102 | return status; | ||
103 | } | ||
104 | |||
105 | u32 construct_pwm_volt_device(struct gk20a *g, struct boardobj **ppboardobj, | ||
106 | u16 size, void *pargs) | ||
107 | { | ||
108 | struct boardobj *pboard_obj = NULL; | ||
109 | struct voltage_device_pwm *ptmp_dev = | ||
110 | (struct voltage_device_pwm *)pargs; | ||
111 | struct voltage_device_pwm *pdev = NULL; | ||
112 | u32 status = 0; | ||
113 | |||
114 | status = construct_volt_device(g, ppboardobj, size, pargs); | ||
115 | if (status) | ||
116 | return status; | ||
117 | |||
118 | pboard_obj = (*ppboardobj); | ||
119 | pdev = (struct voltage_device_pwm *)*ppboardobj; | ||
120 | |||
121 | pboard_obj->pmudatainit = volt_device_pmu_data_init_pwm; | ||
122 | |||
123 | /* Set VOLTAGE_DEVICE_PWM-specific parameters */ | ||
124 | pdev->voltage_base_uv = ptmp_dev->voltage_base_uv; | ||
125 | pdev->voltage_offset_scale_uv = ptmp_dev->voltage_offset_scale_uv; | ||
126 | pdev->source = ptmp_dev->source; | ||
127 | pdev->raw_period = ptmp_dev->raw_period; | ||
128 | |||
129 | return status; | ||
130 | } | ||
131 | |||
132 | |||
133 | struct voltage_device_entry *volt_dev_construct_dev_entry_pwm(struct gk20a *g, | ||
134 | u32 voltage_uv, void *pargs) | ||
135 | { | ||
136 | struct voltage_device_pwm_entry *pentry = NULL; | ||
137 | struct voltage_device_pwm_entry *ptmp_entry = | ||
138 | (struct voltage_device_pwm_entry *)pargs; | ||
139 | |||
140 | pentry = kzalloc(sizeof(struct voltage_device_pwm_entry), GFP_KERNEL); | ||
141 | if (pentry == NULL) | ||
142 | return NULL; | ||
143 | |||
144 | memset(pentry, 0, sizeof(struct voltage_device_pwm_entry)); | ||
145 | |||
146 | pentry->super.voltage_uv = voltage_uv; | ||
147 | pentry->duty_cycle = ptmp_entry->duty_cycle; | ||
148 | |||
149 | return (struct voltage_device_entry *)pentry; | ||
150 | } | ||
151 | |||
152 | static u8 volt_dev_operation_type_convert(u8 vbios_type) | ||
153 | { | ||
154 | switch (vbios_type) { | ||
155 | case NV_VBIOS_VDT_1X_ENTRY_PARAM1_PSV_OPERATION_TYPE_DEFAULT: | ||
156 | return CTRL_VOLT_DEVICE_OPERATION_TYPE_DEFAULT; | ||
157 | |||
158 | case NV_VBIOS_VDT_1X_ENTRY_PARAM1_PSV_OPERATION_TYPE_LPWR_STEADY_STATE: | ||
159 | return CTRL_VOLT_DEVICE_OPERATION_TYPE_LPWR_STEADY_STATE; | ||
160 | |||
161 | case NV_VBIOS_VDT_1X_ENTRY_PARAM1_PSV_OPERATION_TYPE_LPWR_SLEEP_STATE: | ||
162 | return CTRL_VOLT_DEVICE_OPERATION_TYPE_LPWR_SLEEP_STATE; | ||
163 | } | ||
164 | |||
165 | return CTRL_VOLT_DEVICE_OPERATION_TYPE_INVALID; | ||
166 | } | ||
167 | |||
168 | struct voltage_device *volt_volt_device_construct(struct gk20a *g, | ||
169 | void *pargs) | ||
170 | { | ||
171 | struct boardobj *pboard_obj = NULL; | ||
172 | |||
173 | if (BOARDOBJ_GET_TYPE(pargs) == CTRL_VOLT_DEVICE_TYPE_PWM) { | ||
174 | u32 status = construct_pwm_volt_device(g, &pboard_obj, | ||
175 | sizeof(struct voltage_device_pwm), pargs); | ||
176 | if (status) { | ||
177 | gk20a_err(dev_from_gk20a(g), | ||
178 | " Could not allocate memory for VOLTAGE_DEVICE type (%x).", | ||
179 | BOARDOBJ_GET_TYPE(pargs)); | ||
180 | pboard_obj = NULL; | ||
181 | } | ||
182 | } | ||
183 | |||
184 | return (struct voltage_device *)pboard_obj; | ||
185 | } | ||
186 | |||
187 | static u32 volt_get_voltage_device_table_1x_psv(struct gk20a *g, | ||
188 | struct vbios_voltage_device_table_1x_entry *p_bios_entry, | ||
189 | struct voltage_device_metadata *p_Volt_Device_Meta_Data, | ||
190 | u8 entry_Idx) | ||
191 | { | ||
192 | u32 status = 0; | ||
193 | u32 entry_cnt = 0; | ||
194 | struct voltage_device *pvolt_dev = NULL; | ||
195 | struct voltage_device_pwm *pvolt_dev_pwm = NULL; | ||
196 | struct voltage_device_pwm *ptmp_dev = NULL; | ||
197 | u32 duty_cycle; | ||
198 | u32 frequency_hz; | ||
199 | u32 voltage_uv; | ||
200 | u8 ext_dev_idx; | ||
201 | u8 steps; | ||
202 | u8 volt_domain = 0; | ||
203 | struct voltage_device_pwm_entry pwm_entry = { { 0 } }; | ||
204 | |||
205 | ptmp_dev = kzalloc(sizeof(struct voltage_device_pwm), GFP_KERNEL); | ||
206 | if (ptmp_dev == NULL) | ||
207 | return -ENOMEM; | ||
208 | |||
209 | frequency_hz = (u32)BIOS_GET_FIELD(p_bios_entry->param0, | ||
210 | NV_VBIOS_VDT_1X_ENTRY_PARAM0_PSV_INPUT_FREQUENCY); | ||
211 | |||
212 | ext_dev_idx = (u8)BIOS_GET_FIELD(p_bios_entry->param0, | ||
213 | NV_VBIOS_VDT_1X_ENTRY_PARAM0_PSV_EXT_DEVICE_INDEX); | ||
214 | |||
215 | ptmp_dev->super.operation_type = volt_dev_operation_type_convert( | ||
216 | (u8)BIOS_GET_FIELD(p_bios_entry->param1, | ||
217 | NV_VBIOS_VDT_1X_ENTRY_PARAM1_PSV_OPERATION_TYPE)); | ||
218 | |||
219 | if (ptmp_dev->super.operation_type == | ||
220 | CTRL_VOLT_DEVICE_OPERATION_TYPE_INVALID) { | ||
221 | gk20a_err(dev_from_gk20a(g), | ||
222 | " Invalid Voltage Device Operation Type."); | ||
223 | |||
224 | status = -EINVAL; | ||
225 | goto done; | ||
226 | } | ||
227 | |||
228 | ptmp_dev->super.voltage_min_uv = | ||
229 | (u32)BIOS_GET_FIELD(p_bios_entry->param1, | ||
230 | NV_VBIOS_VDT_1X_ENTRY_PARAM1_PSV_VOLTAGE_MINIMUM); | ||
231 | |||
232 | ptmp_dev->super.voltage_max_uv = | ||
233 | (u32)BIOS_GET_FIELD(p_bios_entry->param2, | ||
234 | NV_VBIOS_VDT_1X_ENTRY_PARAM2_PSV_VOLTAGE_MAXIMUM); | ||
235 | |||
236 | ptmp_dev->voltage_base_uv = BIOS_GET_FIELD(p_bios_entry->param3, | ||
237 | NV_VBIOS_VDT_1X_ENTRY_PARAM3_PSV_VOLTAGE_BASE); | ||
238 | |||
239 | steps = (u8)BIOS_GET_FIELD(p_bios_entry->param3, | ||
240 | NV_VBIOS_VDT_1X_ENTRY_PARAM3_PSV_VOLTAGE_STEPS); | ||
241 | if (steps == VOLT_DEV_PWM_VOLTAGE_STEPS_INVALID) | ||
242 | steps = VOLT_DEV_PWM_VOLTAGE_STEPS_DEFAULT; | ||
243 | |||
244 | ptmp_dev->voltage_offset_scale_uv = | ||
245 | BIOS_GET_FIELD(p_bios_entry->param4, | ||
246 | NV_VBIOS_VDT_1X_ENTRY_PARAM4_PSV_OFFSET_SCALE); | ||
247 | |||
248 | volt_domain = volt_rail_vbios_volt_domain_convert_to_internal(g, | ||
249 | (u8)p_bios_entry->volt_domain); | ||
250 | if (volt_domain == CTRL_VOLT_DOMAIN_INVALID) { | ||
251 | gk20a_err(dev_from_gk20a(g), | ||
252 | "invalid voltage domain = %d", | ||
253 | (u8)p_bios_entry->volt_domain); | ||
254 | status = -EINVAL; | ||
255 | goto done; | ||
256 | } | ||
257 | |||
258 | if (ptmp_dev->super.operation_type == | ||
259 | CTRL_VOLT_DEVICE_OPERATION_TYPE_DEFAULT) { | ||
260 | ptmp_dev->source = NV_PMU_PMGR_PWM_SOURCE_THERM_VID_PWM_1; | ||
261 | } else if (ptmp_dev->super.operation_type == | ||
262 | CTRL_VOLT_DEVICE_OPERATION_TYPE_LPWR_STEADY_STATE) { | ||
263 | ptmp_dev->source = NV_PMU_PMGR_PWM_SOURCE_RSVD_0; | ||
264 | } else if (ptmp_dev->super.operation_type == | ||
265 | CTRL_VOLT_DEVICE_OPERATION_TYPE_LPWR_SLEEP_STATE) { | ||
266 | ptmp_dev->source = NV_PMU_PMGR_PWM_SOURCE_RSVD_1; | ||
267 | } | ||
268 | |||
269 | ptmp_dev->raw_period = RAW_PERIOD; | ||
270 | |||
271 | /* Initialize data for parent class. */ | ||
272 | ptmp_dev->super.super.type = CTRL_VOLT_DEVICE_TYPE_PWM; | ||
273 | ptmp_dev->super.volt_domain = volt_domain; | ||
274 | ptmp_dev->super.i2c_dev_idx = ext_dev_idx; | ||
275 | ptmp_dev->super.switch_delay_us = (u16)p_bios_entry->settle_time_us; | ||
276 | |||
277 | pvolt_dev = volt_volt_device_construct(g, ptmp_dev); | ||
278 | if (pvolt_dev == NULL) { | ||
279 | gk20a_err(dev_from_gk20a(g), | ||
280 | " Failure to construct VOLTAGE_DEVICE object."); | ||
281 | |||
282 | status = -EINVAL; | ||
283 | goto done; | ||
284 | } | ||
285 | |||
286 | status = boardobjgrp_objinsert( | ||
287 | &p_Volt_Device_Meta_Data->volt_devices.super, | ||
288 | (struct boardobj *)pvolt_dev, entry_Idx); | ||
289 | if (status) { | ||
290 | gk20a_err(dev_from_gk20a(g), | ||
291 | "could not add VOLTAGE_DEVICE for entry %d into boardobjgrp ", | ||
292 | entry_Idx); | ||
293 | goto done; | ||
294 | } | ||
295 | |||
296 | pvolt_dev_pwm = (struct voltage_device_pwm *)pvolt_dev; | ||
297 | |||
298 | duty_cycle = 0; | ||
299 | do { | ||
300 | voltage_uv = (u32)(pvolt_dev_pwm->voltage_base_uv + | ||
301 | (s32)((((s64)((s32)duty_cycle)) * | ||
302 | pvolt_dev_pwm->voltage_offset_scale_uv) | ||
303 | / ((s64)((s32) pvolt_dev_pwm->raw_period)))); | ||
304 | |||
305 | /* Skip creating entry for invalid voltage. */ | ||
306 | if ((voltage_uv >= pvolt_dev_pwm->super.voltage_min_uv) && | ||
307 | (voltage_uv <= pvolt_dev_pwm->super.voltage_max_uv)) { | ||
308 | if (pvolt_dev_pwm->voltage_offset_scale_uv < 0) | ||
309 | pwm_entry.duty_cycle = | ||
310 | pvolt_dev_pwm->raw_period - duty_cycle; | ||
311 | else | ||
312 | pwm_entry.duty_cycle = duty_cycle; | ||
313 | |||
314 | /* Check if there is room left in the voltage table. */ | ||
315 | if (entry_cnt == VOLTAGE_TABLE_MAX_ENTRIES) { | ||
316 | gk20a_err(dev_from_gk20a(g), "Voltage table is full"); | ||
317 | status = -EINVAL; | ||
318 | goto done; | ||
319 | } | ||
320 | |||
321 | pvolt_dev->pentry[entry_cnt] = | ||
322 | volt_dev_construct_dev_entry_pwm(g, | ||
323 | voltage_uv, &pwm_entry); | ||
324 | if (pvolt_dev->pentry[entry_cnt] == NULL) { | ||
325 | gk20a_err(dev_from_gk20a(g), | ||
326 | " Error creating voltage_device_pwm_entry!"); | ||
327 | status = -EINVAL; | ||
328 | goto done; | ||
329 | } | ||
330 | |||
331 | entry_cnt++; | ||
332 | } | ||
333 | |||
334 | /* Obtain next value after the specified steps. */ | ||
335 | duty_cycle = duty_cycle + (u32)steps; | ||
336 | |||
337 | /* Cap duty cycle to PWM period. */ | ||
338 | if (duty_cycle > pvolt_dev_pwm->raw_period) | ||
339 | duty_cycle = pvolt_dev_pwm->raw_period; | ||
340 | |||
341 | } while (duty_cycle < pvolt_dev_pwm->raw_period); | ||
342 | |||
343 | done: | ||
344 | if (pvolt_dev != NULL) | ||
345 | pvolt_dev->num_entries = entry_cnt; | ||
346 | |||
347 | kfree(ptmp_dev); | ||
348 | return status; | ||
349 | } | ||
350 | |||
351 | static u32 volt_get_volt_devices_table(struct gk20a *g, | ||
352 | struct voltage_device_metadata *pvolt_device_metadata) | ||
353 | { | ||
354 | u32 status = 0; | ||
355 | u8 *volt_device_table_ptr = NULL; | ||
356 | struct vbios_voltage_device_table_1x_header header = { 0 }; | ||
357 | struct vbios_voltage_device_table_1x_entry entry = { 0 }; | ||
358 | u8 entry_idx; | ||
359 | u8 *entry_offset; | ||
360 | |||
361 | if (g->ops.bios.get_perf_table_ptrs) { | ||
362 | volt_device_table_ptr = (u8 *)g->ops.bios.get_perf_table_ptrs(g, | ||
363 | g->bios.perf_token, VOLTAGE_DEVICE_TABLE); | ||
364 | if (volt_device_table_ptr == NULL) { | ||
365 | status = -EINVAL; | ||
366 | goto done; | ||
367 | } | ||
368 | } else { | ||
369 | status = -EINVAL; | ||
370 | goto done; | ||
371 | } | ||
372 | |||
373 | memcpy(&header, volt_device_table_ptr, | ||
374 | sizeof(struct vbios_voltage_device_table_1x_header)); | ||
375 | |||
376 | /* Read in the entries. */ | ||
377 | for (entry_idx = 0; entry_idx < header.num_table_entries; entry_idx++) { | ||
378 | entry_offset = (volt_device_table_ptr + header.header_size + | ||
379 | (entry_idx * header.table_entry_size)); | ||
380 | |||
381 | memcpy(&entry, entry_offset, | ||
382 | sizeof(struct vbios_voltage_device_table_1x_entry)); | ||
383 | |||
384 | if (entry.type == NV_VBIOS_VOLTAGE_DEVICE_1X_ENTRY_TYPE_PSV) | ||
385 | status = volt_get_voltage_device_table_1x_psv(g, | ||
386 | &entry, pvolt_device_metadata, | ||
387 | entry_idx); | ||
388 | } | ||
389 | |||
390 | done: | ||
391 | return status; | ||
392 | } | ||
393 | |||
394 | static u32 _volt_device_devgrp_pmudata_instget(struct gk20a *g, | ||
395 | struct nv_pmu_boardobjgrp *pmuboardobjgrp, | ||
396 | struct nv_pmu_boardobj **ppboardobjpmudata, u8 idx) | ||
397 | { | ||
398 | struct nv_pmu_volt_volt_device_boardobj_grp_set *pgrp_set = | ||
399 | (struct nv_pmu_volt_volt_device_boardobj_grp_set *) | ||
400 | pmuboardobjgrp; | ||
401 | |||
402 | gk20a_dbg_info(""); | ||
403 | |||
404 | /*check whether pmuboardobjgrp has a valid boardobj in index*/ | ||
405 | if (((u32)BIT(idx) & | ||
406 | pgrp_set->hdr.data.super.obj_mask.super.data[0]) == 0) | ||
407 | return -EINVAL; | ||
408 | |||
409 | *ppboardobjpmudata = (struct nv_pmu_boardobj *) | ||
410 | &pgrp_set->objects[idx].data.board_obj; | ||
411 | gk20a_dbg_info("Done"); | ||
412 | return 0; | ||
413 | } | ||
414 | |||
415 | static u32 _volt_device_devgrp_pmustatus_instget(struct gk20a *g, | ||
416 | void *pboardobjgrppmu, | ||
417 | struct nv_pmu_boardobj_query **ppboardobjpmustatus, u8 idx) | ||
418 | { | ||
419 | struct nv_pmu_volt_volt_device_boardobj_grp_get_status *pgrp_get_status | ||
420 | = (struct nv_pmu_volt_volt_device_boardobj_grp_get_status *) | ||
421 | pboardobjgrppmu; | ||
422 | |||
423 | /*check whether pmuboardobjgrp has a valid boardobj in index*/ | ||
424 | if (((u32)BIT(idx) & | ||
425 | pgrp_get_status->hdr.data.super.obj_mask.super.data[0]) == 0) | ||
426 | return -EINVAL; | ||
427 | |||
428 | *ppboardobjpmustatus = (struct nv_pmu_boardobj_query *) | ||
429 | &pgrp_get_status->objects[idx].data.board_obj; | ||
430 | return 0; | ||
431 | } | ||
432 | |||
433 | static int volt_device_volt_cmp(const void *a, const void *b) | ||
434 | { | ||
435 | const struct voltage_device_entry *a_entry = *(const struct voltage_device_entry **)a; | ||
436 | const struct voltage_device_entry *b_entry = *(const struct voltage_device_entry **)b; | ||
437 | |||
438 | return (int)a_entry->voltage_uv - (int)b_entry->voltage_uv; | ||
439 | } | ||
440 | |||
441 | u32 volt_device_state_init(struct gk20a *g, struct voltage_device *pvolt_dev) | ||
442 | { | ||
443 | u32 status = 0; | ||
444 | struct voltage_rail *pRail = NULL; | ||
445 | u8 rail_idx = 0; | ||
446 | |||
447 | sort(pvolt_dev->pentry, pvolt_dev->num_entries, | ||
448 | sizeof(*pvolt_dev->pentry), volt_device_volt_cmp, | ||
449 | NULL); | ||
450 | |||
451 | /* Initialize VOLT_DEVICE step size. */ | ||
452 | if (pvolt_dev->num_entries <= VOLTAGE_TABLE_MAX_ENTRIES_ONE) | ||
453 | pvolt_dev->volt_step_uv = NV_PMU_VOLT_VALUE_0V_IN_UV; | ||
454 | else | ||
455 | pvolt_dev->volt_step_uv = (pvolt_dev->pentry[1]->voltage_uv - | ||
456 | pvolt_dev->pentry[0]->voltage_uv); | ||
457 | |||
458 | /* Build VOLT_RAIL SW state from VOLT_DEVICE SW state. */ | ||
459 | /* If VOLT_RAIL isn't supported, exit. */ | ||
460 | if (VOLT_RAIL_VOLT_3X_SUPPORTED(&g->perf_pmu.volt)) { | ||
461 | rail_idx = volt_rail_volt_domain_convert_to_idx(g, | ||
462 | pvolt_dev->volt_domain); | ||
463 | if (rail_idx == CTRL_BOARDOBJ_IDX_INVALID) { | ||
464 | gk20a_err(dev_from_gk20a(g), | ||
465 | " could not convert voltage domain to rail index."); | ||
466 | status = -EINVAL; | ||
467 | goto done; | ||
468 | } | ||
469 | |||
470 | pRail = VOLT_GET_VOLT_RAIL(&g->perf_pmu.volt, rail_idx); | ||
471 | if (pRail == NULL) { | ||
472 | gk20a_err(dev_from_gk20a(g), | ||
473 | "could not obtain ptr to rail object from rail index"); | ||
474 | status = -EINVAL; | ||
475 | goto done; | ||
476 | } | ||
477 | |||
478 | status = volt_rail_volt_dev_register(g, pRail, | ||
479 | BOARDOBJ_GET_IDX(pvolt_dev), pvolt_dev->operation_type); | ||
480 | if (status) { | ||
481 | gk20a_err(dev_from_gk20a(g), | ||
482 | "Failed to register the device with rail obj"); | ||
483 | goto done; | ||
484 | } | ||
485 | } | ||
486 | |||
487 | done: | ||
488 | if (status) | ||
489 | gk20a_err(dev_from_gk20a(g), | ||
490 | "Error in building rail sw state device sw"); | ||
491 | |||
492 | return status; | ||
493 | } | ||
494 | |||
495 | u32 volt_dev_pmu_setup(struct gk20a *g) | ||
496 | { | ||
497 | u32 status; | ||
498 | struct boardobjgrp *pboardobjgrp = NULL; | ||
499 | |||
500 | gk20a_dbg_info(""); | ||
501 | |||
502 | pboardobjgrp = &g->perf_pmu.volt.volt_dev_metadata.volt_devices.super; | ||
503 | |||
504 | if (!pboardobjgrp->bconstructed) | ||
505 | return -EINVAL; | ||
506 | |||
507 | status = pboardobjgrp->pmuinithandle(g, pboardobjgrp); | ||
508 | |||
509 | gk20a_dbg_info("Done"); | ||
510 | return status; | ||
511 | } | ||
512 | |||
513 | u32 volt_dev_sw_setup(struct gk20a *g) | ||
514 | { | ||
515 | u32 status = 0; | ||
516 | struct boardobjgrp *pboardobjgrp = NULL; | ||
517 | struct voltage_device *pvolt_device; | ||
518 | u8 i; | ||
519 | |||
520 | gk20a_dbg_info(""); | ||
521 | |||
522 | status = boardobjgrpconstruct_e32(&g->perf_pmu.volt.volt_dev_metadata. | ||
523 | volt_devices); | ||
524 | if (status) { | ||
525 | gk20a_err(dev_from_gk20a(g), | ||
526 | "error creating boardobjgrp for volt rail, status - 0x%x", | ||
527 | status); | ||
528 | goto done; | ||
529 | } | ||
530 | |||
531 | pboardobjgrp = &g->perf_pmu.volt.volt_dev_metadata.volt_devices.super; | ||
532 | |||
533 | pboardobjgrp->pmudatainstget = _volt_device_devgrp_pmudata_instget; | ||
534 | pboardobjgrp->pmustatusinstget = _volt_device_devgrp_pmustatus_instget; | ||
535 | |||
536 | /* Obtain Voltage Rail Table from VBIOS */ | ||
537 | status = volt_get_volt_devices_table(g, &g->perf_pmu.volt. | ||
538 | volt_dev_metadata); | ||
539 | if (status) | ||
540 | goto done; | ||
541 | |||
542 | /* Populate data for the VOLT_RAIL PMU interface */ | ||
543 | BOARDOBJGRP_PMU_CONSTRUCT(pboardobjgrp, VOLT, VOLT_DEVICE); | ||
544 | |||
545 | status = BOARDOBJGRP_PMU_CMD_GRP_SET_CONSTRUCT(g, pboardobjgrp, | ||
546 | volt, VOLT, volt_device, VOLT_DEVICE); | ||
547 | if (status) { | ||
548 | gk20a_err(dev_from_gk20a(g), | ||
549 | "error constructing PMU_BOARDOBJ_CMD_GRP_SET interface - 0x%x", | ||
550 | status); | ||
551 | goto done; | ||
552 | } | ||
553 | |||
554 | status = BOARDOBJGRP_PMU_CMD_GRP_GET_STATUS_CONSTRUCT(g, | ||
555 | &g->perf_pmu.volt.volt_dev_metadata.volt_devices.super, | ||
556 | volt, VOLT, volt_device, VOLT_DEVICE); | ||
557 | if (status) { | ||
558 | gk20a_err(dev_from_gk20a(g), | ||
559 | "error constructing PMU_BOARDOBJ_CMD_GRP_SET interface - 0x%x", | ||
560 | status); | ||
561 | goto done; | ||
562 | } | ||
563 | |||
564 | /* update calibration to fuse */ | ||
565 | BOARDOBJGRP_FOR_EACH(&(g->perf_pmu.volt.volt_dev_metadata.volt_devices. | ||
566 | super), | ||
567 | struct voltage_device *, pvolt_device, i) { | ||
568 | status = volt_device_state_init(g, pvolt_device); | ||
569 | if (status) { | ||
570 | gk20a_err(dev_from_gk20a(g), | ||
571 | "failure while executing devices's state init interface"); | ||
572 | gk20a_err(dev_from_gk20a(g), | ||
573 | " railIdx = %d, status = 0x%x", i, status); | ||
574 | goto done; | ||
575 | } | ||
576 | } | ||
577 | |||
578 | done: | ||
579 | gk20a_dbg_info(" done status %x", status); | ||
580 | return status; | ||
581 | } | ||
582 | |||