lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [day] [month] [year] [list]
Date:   Fri, 14 Aug 2020 10:13:00 +0800
From:   kernel test robot <lkp@...el.com>
To:     Evan Quan <evan.quan@....com>
Cc:     kbuild-all@...ts.01.org, linux-kernel@...r.kernel.org,
        Alex Deucher <alexander.deucher@....com>
Subject: drivers/gpu/drm/amd/powerplay/smu_cmn.c:485:9: warning: Identical
 condition 'ret', second condition is always false

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head:   dddcbc139e96bd18d8c65ef7b7e440f0d32457c2
commit: caad2613dc4bd7396f1f0d32f5f0e650f9d8ebc4 drm/amd/powerplay: move table setting common code to smu_cmn.c
date:   3 weeks ago
compiler: alpha-linux-gcc (GCC) 9.3.0

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@...el.com>


cppcheck warnings: (new ones prefixed by >>)

   In file included from drivers/gpu/drm/amd/amdgpu/../powerplay/smu_cmn.c:
>> drivers/gpu/drm/amd/powerplay/smu_cmn.c:485:9: warning: Identical condition 'ret', second condition is always false [identicalConditionAfterEarlyExit]
    return ret;
           ^
   drivers/gpu/drm/amd/powerplay/smu_cmn.c:477:6: note: first condition
    if (ret)
        ^
   drivers/gpu/drm/amd/powerplay/smu_cmn.c:485:9: note: second condition
    return ret;
           ^
>> drivers/gpu/drm/amd/powerplay/smu_cmn.c:336:11: warning: %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]
     size += sprintf(buf + size, "%02d. %-20s (%2d) : %sn",
             ^

vim +/ret +485 drivers/gpu/drm/amd/powerplay/smu_cmn.c

   304	
   305	size_t smu_cmn_get_pp_feature_mask(struct smu_context *smu,
   306					   char *buf)
   307	{
   308		uint32_t feature_mask[2] = { 0 };
   309		int32_t feature_index = 0;
   310		uint32_t count = 0;
   311		uint32_t sort_feature[SMU_FEATURE_COUNT];
   312		uint64_t hw_feature_count = 0;
   313		size_t size = 0;
   314		int ret = 0, i;
   315	
   316		ret = smu_cmn_get_enabled_mask(smu,
   317					       feature_mask,
   318					       2);
   319		if (ret)
   320			return 0;
   321	
   322		size =  sprintf(buf + size, "features high: 0x%08x low: 0x%08x\n",
   323				feature_mask[1], feature_mask[0]);
   324	
   325		for (i = 0; i < SMU_FEATURE_COUNT; i++) {
   326			feature_index = smu_cmn_to_asic_specific_index(smu,
   327								       CMN2ASIC_MAPPING_FEATURE,
   328								       i);
   329			if (feature_index < 0)
   330				continue;
   331			sort_feature[feature_index] = i;
   332			hw_feature_count++;
   333		}
   334	
   335		for (i = 0; i < hw_feature_count; i++) {
 > 336			size += sprintf(buf + size, "%02d. %-20s (%2d) : %s\n",
   337				       count++,
   338				       smu_get_feature_name(smu, sort_feature[i]),
   339				       i,
   340				       !!smu_cmn_feature_is_enabled(smu, sort_feature[i]) ?
   341				       "enabled" : "disabled");
   342		}
   343	
   344		return size;
   345	}
   346	
   347	int smu_cmn_set_pp_feature_mask(struct smu_context *smu,
   348					uint64_t new_mask)
   349	{
   350		int ret = 0;
   351		uint32_t feature_mask[2] = { 0 };
   352		uint64_t feature_2_enabled = 0;
   353		uint64_t feature_2_disabled = 0;
   354		uint64_t feature_enables = 0;
   355	
   356		ret = smu_cmn_get_enabled_mask(smu,
   357					       feature_mask,
   358					       2);
   359		if (ret)
   360			return ret;
   361	
   362		feature_enables = ((uint64_t)feature_mask[1] << 32 |
   363				   (uint64_t)feature_mask[0]);
   364	
   365		feature_2_enabled  = ~feature_enables & new_mask;
   366		feature_2_disabled = feature_enables & ~new_mask;
   367	
   368		if (feature_2_enabled) {
   369			ret = smu_cmn_feature_update_enable_state(smu,
   370								  feature_2_enabled,
   371								  true);
   372			if (ret)
   373				return ret;
   374		}
   375		if (feature_2_disabled) {
   376			ret = smu_cmn_feature_update_enable_state(smu,
   377								  feature_2_disabled,
   378								  false);
   379			if (ret)
   380				return ret;
   381		}
   382	
   383		return ret;
   384	}
   385	
   386	int smu_cmn_disable_all_features_with_exception(struct smu_context *smu,
   387							enum smu_feature_mask mask)
   388	{
   389		uint64_t features_to_disable = U64_MAX;
   390		int skipped_feature_id;
   391	
   392		skipped_feature_id = smu_cmn_to_asic_specific_index(smu,
   393								    CMN2ASIC_MAPPING_FEATURE,
   394								    mask);
   395		if (skipped_feature_id < 0)
   396			return -EINVAL;
   397	
   398		features_to_disable &= ~(1ULL << skipped_feature_id);
   399	
   400		return smu_cmn_feature_update_enable_state(smu,
   401							   features_to_disable,
   402							   0);
   403	}
   404	
   405	int smu_cmn_get_smc_version(struct smu_context *smu,
   406				    uint32_t *if_version,
   407				    uint32_t *smu_version)
   408	{
   409		int ret = 0;
   410	
   411		if (!if_version && !smu_version)
   412			return -EINVAL;
   413	
   414		if (smu->smc_fw_if_version && smu->smc_fw_version)
   415		{
   416			if (if_version)
   417				*if_version = smu->smc_fw_if_version;
   418	
   419			if (smu_version)
   420				*smu_version = smu->smc_fw_version;
   421	
   422			return 0;
   423		}
   424	
   425		if (if_version) {
   426			ret = smu_send_smc_msg(smu, SMU_MSG_GetDriverIfVersion, if_version);
   427			if (ret)
   428				return ret;
   429	
   430			smu->smc_fw_if_version = *if_version;
   431		}
   432	
   433		if (smu_version) {
   434			ret = smu_send_smc_msg(smu, SMU_MSG_GetSmuVersion, smu_version);
   435			if (ret)
   436				return ret;
   437	
   438			smu->smc_fw_version = *smu_version;
   439		}
   440	
   441		return ret;
   442	}
   443	
   444	int smu_cmn_update_table(struct smu_context *smu,
   445				 enum smu_table_id table_index,
   446				 int argument,
   447				 void *table_data,
   448				 bool drv2smu)
   449	{
   450		struct smu_table_context *smu_table = &smu->smu_table;
   451		struct amdgpu_device *adev = smu->adev;
   452		struct smu_table *table = &smu_table->driver_table;
   453		int table_id = smu_cmn_to_asic_specific_index(smu,
   454							      CMN2ASIC_MAPPING_TABLE,
   455							      table_index);
   456		uint32_t table_size;
   457		int ret = 0;
   458		if (!table_data || table_id >= SMU_TABLE_COUNT || table_id < 0)
   459			return -EINVAL;
   460	
   461		table_size = smu_table->tables[table_index].size;
   462	
   463		if (drv2smu) {
   464			memcpy(table->cpu_addr, table_data, table_size);
   465			/*
   466			 * Flush hdp cache: to guard the content seen by
   467			 * GPU is consitent with CPU.
   468			 */
   469			amdgpu_asic_flush_hdp(adev, NULL);
   470		}
   471	
   472		ret = smu_send_smc_msg_with_param(smu, drv2smu ?
   473						  SMU_MSG_TransferTableDram2Smu :
   474						  SMU_MSG_TransferTableSmu2Dram,
   475						  table_id | ((argument & 0xFFFF) << 16),
   476						  NULL);
   477		if (ret)
   478			return ret;
   479	
   480		if (!drv2smu) {
   481			amdgpu_asic_flush_hdp(adev, NULL);
   482			memcpy(table_data, table->cpu_addr, table_size);
   483		}
   484	
 > 485		return ret;
   486	}
   487	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

Powered by blists - more mailing lists