summaryrefslogtreecommitdiffstats
path: root/drivers/gpu/nvgpu/volt/volt_dev.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gpu/nvgpu/volt/volt_dev.c')
-rw-r--r--drivers/gpu/nvgpu/volt/volt_dev.c582
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
33u32 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
55static 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
77u32 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
105u32 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
133struct 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
152static 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
168struct 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
187static 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
343done:
344 if (pvolt_dev != NULL)
345 pvolt_dev->num_entries = entry_cnt;
346
347 kfree(ptmp_dev);
348 return status;
349}
350
351static 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
390done:
391 return status;
392}
393
394static 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
415static 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
433static 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
441u32 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
487done:
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
495u32 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
513u32 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
578done:
579 gk20a_dbg_info(" done status %x", status);
580 return status;
581}
582
generated by cgit v1.2.2 (git 2.25.0) at 2024-07-05 01:48:09 -0400