From a86122e01a3b27652f2dea8cbdadd47ed6b3d216 Mon Sep 17 00:00:00 2001 From: Thomas Fleury Date: Wed, 18 Jan 2017 15:08:38 -0800 Subject: gpu: nvgpu: read overcurrent policy from VBIOS Since pwr_sensors, pwr_topology_ and pwr_policy_* tables in bios.h are not defined as packed, nvgpu driver is not able to find hw threshold pwr_policy table in VBIOS and ends up hard coding the HW thershold policy. Changed definitions to packed, and explicitly unpack structures when parsing the power policy table. Removed the function that did the hard coding. Jira DNVGPU-206 Change-Id: Idc2b5b5c86ddfe735631190dda10218cc462be3b Signed-off-by: Thomas Fleury Reviewed-on: http://git-master/r/1290303 GVS: Gerrit_Virtual_Submit Reviewed-by: Vijayakumar Subbu --- drivers/gpu/nvgpu/pmgr/pwrpolicy.c | 390 +++++++++++++++++++------------------ 1 file changed, 200 insertions(+), 190 deletions(-) (limited to 'drivers/gpu/nvgpu/pmgr/pwrpolicy.c') diff --git a/drivers/gpu/nvgpu/pmgr/pwrpolicy.c b/drivers/gpu/nvgpu/pmgr/pwrpolicy.c index cce3bd5e..1e7e19a3 100644 --- a/drivers/gpu/nvgpu/pmgr/pwrpolicy.c +++ b/drivers/gpu/nvgpu/pmgr/pwrpolicy.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. + * Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, @@ -262,6 +262,11 @@ static struct boardobj *construct_pwr_policy(struct gk20a *g, pwrpolicyhwthreshold = (struct pwr_policy_hw_threshold*)board_obj_ptr; pwrpolicy = (struct pwr_policy *)board_obj_ptr; + gk20a_dbg_fn("min=%u rated=%u max=%u", + pwrpolicyparams->limit_min, + pwrpolicyparams->limit_rated, + pwrpolicyparams->limit_max); + /* Set Super class interfaces */ board_obj_ptr->pmudatainit = _pwr_domains_pmudatainit_hw_threshold; @@ -351,53 +356,6 @@ static struct boardobj *construct_pwr_policy(struct gk20a *g, return board_obj_ptr; } -static u32 _pwr_policy_construct_WAR_policy(struct gk20a *g, - struct pmgr_pwr_policy *ppwrpolicyobjs, - union pwr_policy_data_union *ppwrpolicydata, - u16 pwr_policy_size, - u32 hw_threshold_policy_index, - u32 obj_index) -{ - u32 status = 0; - struct boardobj *boardobj; - - if (!(hw_threshold_policy_index & 0x1)) { - /* CRIT policy */ - ppwrpolicydata->pwrpolicy.limit_min = 1000; - ppwrpolicydata->pwrpolicy.limit_rated = 20000; - ppwrpolicydata->pwrpolicy.limit_max = 20000; - ppwrpolicydata->hw_threshold.threshold_idx = 0; - } else { - /* WARN policy */ - ppwrpolicydata->pwrpolicy.limit_min = 1000; - ppwrpolicydata->pwrpolicy.limit_rated = 11600; - ppwrpolicydata->pwrpolicy.limit_max = 11600; - ppwrpolicydata->hw_threshold.threshold_idx = 1; - } - - boardobj = construct_pwr_policy(g, ppwrpolicydata, - pwr_policy_size, ppwrpolicydata->boardobj.type); - - if (!boardobj) { - gk20a_err(dev_from_gk20a(g), - "unable to create pwr policy for type %d", ppwrpolicydata->boardobj.type); - status = -EINVAL; - goto done; - } - - status = boardobjgrp_objinsert(&ppwrpolicyobjs->pwr_policies.super, - boardobj, obj_index); - - if (status) { - gk20a_err(dev_from_gk20a(g), - "unable to insert pwr policy boardobj for %d", obj_index); - status = -EINVAL; - goto done; - } -done: - return status; -} - static u32 _pwr_policy_construct_WAR_SW_Threshold_policy(struct gk20a *g, struct pmgr_pwr_policy *ppwrpolicyobjs, union pwr_policy_data_union *ppwrpolicydata, @@ -447,15 +405,114 @@ done: return status; } +struct pwr_policy_3x_header_unpacked { + u8 version; + u8 header_size; + u8 table_entry_size; + u8 num_table_entries; + u16 base_sample_period; + u16 min_client_sample_period; + u8 table_rel_entry_size; + u8 num_table_rel_entries; + u8 tgp_policy_idx; + u8 rtp_policy_idx; + u8 mxm_policy_idx; + u8 dnotifier_policy_idx; + u32 d2_limit; + u32 d3_limit; + u32 d4_limit; + u32 d5_limit; + u8 low_sampling_mult; + u8 pwr_tgt_policy_idx; + u8 pwr_tgt_floor_policy_idx; + u8 sm_bus_policy_idx; + u8 table_viol_entry_size; + u8 num_table_viol_entries; +}; + +#define __UNPACK_FIELD(unpacked, packed, field) \ + __builtin_memcpy(&unpacked->field, &packed->field, \ + sizeof(unpacked->field)) + +static inline void devinit_unpack_pwr_policy_header( + struct pwr_policy_3x_header_unpacked *unpacked, + struct pwr_policy_3x_header_struct *packed) +{ + __UNPACK_FIELD(unpacked, packed, version); + __UNPACK_FIELD(unpacked, packed, header_size); + __UNPACK_FIELD(unpacked, packed, table_entry_size); + __UNPACK_FIELD(unpacked, packed, num_table_entries); + __UNPACK_FIELD(unpacked, packed, base_sample_period); + __UNPACK_FIELD(unpacked, packed, min_client_sample_period); + __UNPACK_FIELD(unpacked, packed, table_rel_entry_size); + __UNPACK_FIELD(unpacked, packed, num_table_rel_entries); + __UNPACK_FIELD(unpacked, packed, tgp_policy_idx); + __UNPACK_FIELD(unpacked, packed, rtp_policy_idx); + __UNPACK_FIELD(unpacked, packed, mxm_policy_idx); + __UNPACK_FIELD(unpacked, packed, dnotifier_policy_idx); + __UNPACK_FIELD(unpacked, packed, d2_limit); + __UNPACK_FIELD(unpacked, packed, d3_limit); + __UNPACK_FIELD(unpacked, packed, d4_limit); + __UNPACK_FIELD(unpacked, packed, d5_limit); + __UNPACK_FIELD(unpacked, packed, low_sampling_mult); + __UNPACK_FIELD(unpacked, packed, pwr_tgt_policy_idx); + __UNPACK_FIELD(unpacked, packed, pwr_tgt_floor_policy_idx); + __UNPACK_FIELD(unpacked, packed, sm_bus_policy_idx); + __UNPACK_FIELD(unpacked, packed, table_viol_entry_size); + __UNPACK_FIELD(unpacked, packed, num_table_viol_entries); +} + +struct pwr_policy_3x_entry_unpacked { + u8 flags0; + u8 ch_idx; + u32 limit_min; + u32 limit_rated; + u32 limit_max; + u32 param0; + u32 param1; + u32 param2; + u32 param3; + u32 limit_batt; + u8 flags1; + u8 past_length; + u8 next_length; + u16 ratio_min; + u16 ratio_max; + u8 sample_mult; + u32 filter_param; +}; + +static inline void devinit_unpack_pwr_policy_entry( + struct pwr_policy_3x_entry_unpacked *unpacked, + struct pwr_policy_3x_entry_struct *packed) +{ + __UNPACK_FIELD(unpacked, packed, flags0); + __UNPACK_FIELD(unpacked, packed, ch_idx); + __UNPACK_FIELD(unpacked, packed, limit_min); + __UNPACK_FIELD(unpacked, packed, limit_rated); + __UNPACK_FIELD(unpacked, packed, limit_max); + __UNPACK_FIELD(unpacked, packed, param0); + __UNPACK_FIELD(unpacked, packed, param1); + __UNPACK_FIELD(unpacked, packed, param2); + __UNPACK_FIELD(unpacked, packed, param3); + __UNPACK_FIELD(unpacked, packed, limit_batt); + __UNPACK_FIELD(unpacked, packed, flags1); + __UNPACK_FIELD(unpacked, packed, past_length); + __UNPACK_FIELD(unpacked, packed, next_length); + __UNPACK_FIELD(unpacked, packed, ratio_min); + __UNPACK_FIELD(unpacked, packed, ratio_max); + __UNPACK_FIELD(unpacked, packed, sample_mult); + __UNPACK_FIELD(unpacked, packed, filter_param); +} + static u32 devinit_get_pwr_policy_table(struct gk20a *g, struct pmgr_pwr_policy *ppwrpolicyobjs) { u32 status = 0; - u8 *pwr_policy_table_ptr = NULL; - u8 *curr_pwr_policy_table_ptr = NULL; + u8 *ptr = NULL; struct boardobj *boardobj; - struct pwr_policy_3x_header_struct pwr_policy_table_header = { 0 }; - struct pwr_policy_3x_entry_struct pwr_policy_table_entry = { 0 }; + struct pwr_policy_3x_header_struct *packed_hdr; + struct pwr_policy_3x_header_unpacked hdr; u32 index; u32 obj_index = 0; u16 pwr_policy_size; @@ -469,162 +526,130 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g, if (!g->ops.bios.get_perf_table_ptrs) return -EINVAL; - pwr_policy_table_ptr = (u8 *)g->ops.bios.get_perf_table_ptrs(g, + ptr = (u8 *)g->ops.bios.get_perf_table_ptrs(g, g->bios.perf_token, POWER_CAPPING_TABLE); - if (pwr_policy_table_ptr == NULL) { + if (ptr == NULL) { status = -EINVAL; goto done; } - memcpy(&pwr_policy_table_header.version, - (pwr_policy_table_ptr), - 14); + packed_hdr = (struct pwr_policy_3x_header_struct *)ptr; - memcpy(&pwr_policy_table_header.d2_limit, - (pwr_policy_table_ptr + 14), - (VBIOS_POWER_POLICY_3X_ENTRY_SIZE_2E - 14)); - - if (pwr_policy_table_header.version != + if (packed_hdr->version != VBIOS_POWER_POLICY_VERSION_3X) { status = -EINVAL; goto done; } - if (pwr_policy_table_header.header_size < + if (packed_hdr->header_size < VBIOS_POWER_POLICY_3X_HEADER_SIZE_25) { status = -EINVAL; goto done; } - if (pwr_policy_table_header.table_entry_size != + if (packed_hdr->table_entry_size != VBIOS_POWER_POLICY_3X_ENTRY_SIZE_2E) { status = -EINVAL; goto done; } - curr_pwr_policy_table_ptr = (pwr_policy_table_ptr + - VBIOS_POWER_POLICY_3X_HEADER_SIZE_25); + /* unpack power policy table header */ + devinit_unpack_pwr_policy_header(&hdr, packed_hdr); - for (index = 0; index < pwr_policy_table_header.num_table_entries; - index++) { - u8 class_type; + ptr += VBIOS_POWER_POLICY_3X_HEADER_SIZE_25; - curr_pwr_policy_table_ptr += (pwr_policy_table_header.table_entry_size * index); + for (index = 0; index < hdr.num_table_entries; + index++, ptr += (u32)hdr.table_entry_size) { - pwr_policy_table_entry.flags0 = *curr_pwr_policy_table_ptr; - pwr_policy_table_entry.ch_idx = *(curr_pwr_policy_table_ptr + 1); + struct pwr_policy_3x_entry_struct *packed_entry; + struct pwr_policy_3x_entry_unpacked entry; - memcpy(&pwr_policy_table_entry.limit_min, - (curr_pwr_policy_table_ptr + 2), - 35); - - memcpy(&pwr_policy_table_entry.ratio_min, - (curr_pwr_policy_table_ptr + 2 + 35), - 4); - - pwr_policy_table_entry.sample_mult = - *(curr_pwr_policy_table_ptr + 2 + 35 + 4); + u8 class_type; - memcpy(&pwr_policy_table_entry.filter_param, - (curr_pwr_policy_table_ptr + 2 + 35 + 4 + 1), - 4); + packed_entry = (struct pwr_policy_3x_entry_struct *)ptr; class_type = (u8)BIOS_GET_FIELD( - pwr_policy_table_entry.flags0, + packed_entry->flags0, NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS); - if (class_type == NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_HW_THRESHOLD) { - ppwrpolicyobjs->version = CTRL_PMGR_PWR_POLICY_TABLE_VERSION_3X; - ppwrpolicyobjs->base_sample_period = (u16) - pwr_policy_table_header.base_sample_period; - ppwrpolicyobjs->min_client_sample_period = (u16) - pwr_policy_table_header.min_client_sample_period; - ppwrpolicyobjs->low_sampling_mult = - pwr_policy_table_header.low_sampling_mult; - - ppwrpolicyobjs->policy_idxs[1] = - (u8)pwr_policy_table_header.tgp_policy_idx; - ppwrpolicyobjs->policy_idxs[0] = - (u8)pwr_policy_table_header.rtp_policy_idx; - ppwrpolicyobjs->policy_idxs[2] = - pwr_policy_table_header.mxm_policy_idx; - ppwrpolicyobjs->policy_idxs[3] = - pwr_policy_table_header.dnotifier_policy_idx; - ppwrpolicyobjs->ext_limits[0].limit = - pwr_policy_table_header.d2_limit; - ppwrpolicyobjs->ext_limits[1].limit = - pwr_policy_table_header.d3_limit; - ppwrpolicyobjs->ext_limits[2].limit = - pwr_policy_table_header.d4_limit; - ppwrpolicyobjs->ext_limits[3].limit = - pwr_policy_table_header.d5_limit; - ppwrpolicyobjs->policy_idxs[4] = - pwr_policy_table_header.pwr_tgt_policy_idx; - ppwrpolicyobjs->policy_idxs[5] = - pwr_policy_table_header.pwr_tgt_floor_policy_idx; - ppwrpolicyobjs->policy_idxs[6] = - pwr_policy_table_header.sm_bus_policy_idx; - - integral_control = (bool)BIOS_GET_FIELD( - pwr_policy_table_entry.flags1, - NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_INTEGRAL_CONTROL); - - if (integral_control == 0x01) { - pwr_policy_data.pwrpolicy.integral.past_sample_count = (u8) - pwr_policy_table_entry.past_length; - pwr_policy_data.pwrpolicy.integral.next_sample_count = (u8) - pwr_policy_table_entry.next_length; - pwr_policy_data.pwrpolicy.integral.ratio_limit_max = (u16) - pwr_policy_table_entry.ratio_max; - pwr_policy_data.pwrpolicy.integral.ratio_limit_min = (u16) - pwr_policy_table_entry.ratio_min; - } else { - memset(&(pwr_policy_data.pwrpolicy.integral), 0x0, - sizeof(struct ctrl_pmgr_pwr_policy_info_integral)); - } - pwr_policy_data.hw_threshold.threshold_idx = (u8) - BIOS_GET_FIELD( - pwr_policy_table_entry.param0, - NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_THRES_IDX); - - pwr_policy_data.hw_threshold.b_use_low_threshold = - BIOS_GET_FIELD( - pwr_policy_table_entry.param0, - NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_USE); - - if (pwr_policy_data.hw_threshold.b_use_low_threshold) { - pwr_policy_data.hw_threshold.low_threshold_idx = (u8) - BIOS_GET_FIELD( - pwr_policy_table_entry.param0, - NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_IDX); - - pwr_policy_data.hw_threshold.low_threshold_value = (u16) - BIOS_GET_FIELD( - pwr_policy_table_entry.param1, - NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM1_HW_THRESHOLD_LOW_THRESHOLD_VAL); - } - - pwr_policy_size = sizeof(struct pwr_policy_hw_threshold); - } else + if (class_type != NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_HW_THRESHOLD) continue; + /* unpack power policy table entry */ + devinit_unpack_pwr_policy_entry(&entry, packed_entry); + + ppwrpolicyobjs->version = + CTRL_PMGR_PWR_POLICY_TABLE_VERSION_3X; + ppwrpolicyobjs->base_sample_period = hdr.base_sample_period; + ppwrpolicyobjs->min_client_sample_period = + hdr.min_client_sample_period; + ppwrpolicyobjs->low_sampling_mult = hdr.low_sampling_mult; + + ppwrpolicyobjs->policy_idxs[1] = hdr.tgp_policy_idx; + ppwrpolicyobjs->policy_idxs[0] = hdr.rtp_policy_idx; + ppwrpolicyobjs->policy_idxs[2] = hdr.mxm_policy_idx; + ppwrpolicyobjs->policy_idxs[3] = hdr.dnotifier_policy_idx; + ppwrpolicyobjs->ext_limits[0].limit = hdr.d2_limit; + ppwrpolicyobjs->ext_limits[1].limit = hdr.d3_limit; + ppwrpolicyobjs->ext_limits[2].limit = hdr.d4_limit; + ppwrpolicyobjs->ext_limits[3].limit = hdr.d5_limit; + ppwrpolicyobjs->policy_idxs[4] = hdr.pwr_tgt_policy_idx; + ppwrpolicyobjs->policy_idxs[5] = hdr.pwr_tgt_floor_policy_idx; + ppwrpolicyobjs->policy_idxs[6] = hdr.sm_bus_policy_idx; + + integral_control = (bool)BIOS_GET_FIELD(entry.flags1, + NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_INTEGRAL_CONTROL); + + if (integral_control == 0x01) { + pwr_policy_data.pwrpolicy.integral.past_sample_count = + entry.past_length; + pwr_policy_data.pwrpolicy.integral.next_sample_count = + entry.next_length; + pwr_policy_data.pwrpolicy.integral.ratio_limit_max = + entry.ratio_max; + pwr_policy_data.pwrpolicy.integral.ratio_limit_min = + entry.ratio_min; + } else { + memset(&(pwr_policy_data.pwrpolicy.integral), 0x0, + sizeof(struct ctrl_pmgr_pwr_policy_info_integral)); + } + pwr_policy_data.hw_threshold.threshold_idx = (u8) + BIOS_GET_FIELD(entry.param0, + NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_THRES_IDX); + + pwr_policy_data.hw_threshold.b_use_low_threshold = + BIOS_GET_FIELD(entry.param0, + NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_USE); + + if (pwr_policy_data.hw_threshold.b_use_low_threshold) { + pwr_policy_data.hw_threshold.low_threshold_idx = (u8) + BIOS_GET_FIELD(entry.param0, + NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_IDX); + + pwr_policy_data.hw_threshold.low_threshold_value = (u16) + BIOS_GET_FIELD(entry.param1, + NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM1_HW_THRESHOLD_LOW_THRESHOLD_VAL); + } + + pwr_policy_size = sizeof(struct pwr_policy_hw_threshold); + /* Initialize data for the parent class */ - pwr_policy_data.boardobj.type = CTRL_PMGR_PWR_POLICY_TYPE_HW_THRESHOLD; - pwr_policy_data.pwrpolicy.ch_idx = (u8)pwr_policy_table_entry.ch_idx; + pwr_policy_data.boardobj.type = + CTRL_PMGR_PWR_POLICY_TYPE_HW_THRESHOLD; + pwr_policy_data.pwrpolicy.ch_idx = entry.ch_idx; pwr_policy_data.pwrpolicy.limit_unit = (u8) - BIOS_GET_FIELD( - pwr_policy_table_entry.flags0, + BIOS_GET_FIELD(entry.flags0, NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_LIMIT_UNIT); pwr_policy_data.pwrpolicy.filter_type = (u8) - BIOS_GET_FIELD( - pwr_policy_table_entry.flags1, + BIOS_GET_FIELD(entry.flags1, NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_FILTER_TYPE); - pwr_policy_data.pwrpolicy.limit_min = pwr_policy_table_entry.limit_min; - pwr_policy_data.pwrpolicy.limit_rated = pwr_policy_table_entry.limit_rated; - pwr_policy_data.pwrpolicy.limit_max = pwr_policy_table_entry.limit_max; - pwr_policy_data.pwrpolicy.limit_batt = pwr_policy_table_entry.limit_batt; - pwr_policy_data.pwrpolicy.sample_mult = (u8)pwr_policy_table_entry.sample_mult; + pwr_policy_data.pwrpolicy.limit_min = entry.limit_min; + pwr_policy_data.pwrpolicy.limit_rated = entry.limit_rated; + pwr_policy_data.pwrpolicy.limit_max = entry.limit_max; + pwr_policy_data.pwrpolicy.limit_batt = entry.limit_batt; + + pwr_policy_data.pwrpolicy.sample_mult = (u8)entry.sample_mult; /* Filled the entry.filterParam value in the filterParam */ pwr_policy_data.pwrpolicy.filter_param.block.block_size = 0; @@ -635,11 +660,12 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g, BIT(pwr_policy_data.hw_threshold.threshold_idx); boardobj = construct_pwr_policy(g, &pwr_policy_data, - pwr_policy_size, pwr_policy_data.boardobj.type); + pwr_policy_size, pwr_policy_data.boardobj.type); if (!boardobj) { gk20a_err(dev_from_gk20a(g), - "unable to create pwr policy for %d type %d", index, pwr_policy_data.boardobj.type); + "unable to create pwr policy for %d type %d", + index, pwr_policy_data.boardobj.type); status = -EINVAL; goto done; } @@ -649,7 +675,8 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g, if (status) { gk20a_err(dev_from_gk20a(g), - "unable to insert pwr policy boardobj for %d", index); + "unable to insert pwr policy boardobj for %d", + index); status = -EINVAL; goto done; } @@ -657,23 +684,6 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g, ++obj_index; } - if (hw_threshold_policy_index && - (hw_threshold_policy_index < 0x3)) { - status = _pwr_policy_construct_WAR_policy(g, - ppwrpolicyobjs, - &pwr_policy_data, - pwr_policy_size, - hw_threshold_policy_index, - obj_index); - if (status) { - gk20a_err(dev_from_gk20a(g), - "unable to construct_WAR_policy"); - status = -EINVAL; - goto done; - } - ++obj_index; - } - if (!sw_threshold_policy_index) { status = _pwr_policy_construct_WAR_SW_Threshold_policy(g, ppwrpolicyobjs, -- cgit v1.2.2