Commit dfe49536 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'platform-drivers-x86-v5.14-2' of... 

Merge tag 'platform-drivers-x86-v5.14-2' of git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86

Pull x86 platform driver fixes from Hans de Goede:
 "A set of bug-fixes and new hardware ids.

  Highlights:

   - amd-pmc fixes

   - think-lmi fixes

   - various new hardware-ids"

* tag 'platform-drivers-x86-v5.14-2' of git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86:
  platform/x86: gigabyte-wmi: add support for B550 Aorus Elite V2
  platform/x86: intel-hid: add Alder Lake ACPI device ID
  platform/x86: think-lmi: Fix possible mem-leaks on tlmi_analyze() error-exit
  platform/x86: think-lmi: Split kobject_init() and kobject_add() calls
  platform/x86: think-lmi: Move pending_reboot_attr to the attributes sysfs dir
  platform/x86: amd-pmc: Fix undefined reference to __udivdi3
  platform/x86: amd-pmc: Fix missing unlock on error in amd_pmc_send_cmd()
  platform/x86: wireless-hotkey: remove hardcoded "hp" from the error message
  platform/x86: amd-pmc: Use return code on suspend
  platform/x86: amd-pmc: Add new acpi id for future PMC controllers
  platform/x86: amd-pmc: Add support for ACPI ID AMDI0006
  platform/x86: amd-pmc: Add support for logging s0ix counters
  platform/x86: amd-pmc: Add support for logging SMU metrics
  platform/x86: amd-pmc: call dump registers only once
  platform/x86: amd-pmc: Fix SMU firmware reporting mechanism
  platform/x86: amd-pmc: Fix command completion code
  platform/x86: think-lmi: Add pending_reboot support
parents 25905f60 2b2c66f6

drivers/platform/x86/amd-pmc.c

+225 −24
Original line number Diff line number Diff line
@@ -46,34 +46,79 @@ 
#define AMD_PMC_RESULT_CMD_UNKNOWN           0xFE

#define AMD_PMC_RESULT_FAILED                0xFF



/* FCH SSC Registers */

#define FCH_S0I3_ENTRY_TIME_L_OFFSET	0x30

#define FCH_S0I3_ENTRY_TIME_H_OFFSET	0x34

#define FCH_S0I3_EXIT_TIME_L_OFFSET	0x38

#define FCH_S0I3_EXIT_TIME_H_OFFSET	0x3C

#define FCH_SSC_MAPPING_SIZE		0x800

#define FCH_BASE_PHY_ADDR_LOW		0xFED81100

#define FCH_BASE_PHY_ADDR_HIGH		0x00000000



/* SMU Message Definations */

#define SMU_MSG_GETSMUVERSION		0x02

#define SMU_MSG_LOG_GETDRAM_ADDR_HI	0x04

#define SMU_MSG_LOG_GETDRAM_ADDR_LO	0x05

#define SMU_MSG_LOG_START		0x06

#define SMU_MSG_LOG_RESET		0x07

#define SMU_MSG_LOG_DUMP_DATA		0x08

#define SMU_MSG_GET_SUP_CONSTRAINTS	0x09

/* List of supported CPU ids */

#define AMD_CPU_ID_RV			0x15D0

#define AMD_CPU_ID_RN			0x1630

#define AMD_CPU_ID_PCO			AMD_CPU_ID_RV

#define AMD_CPU_ID_CZN			AMD_CPU_ID_RN

#define AMD_CPU_ID_YC			0x14B5



#define AMD_SMU_FW_VERSION		0x0

#define PMC_MSG_DELAY_MIN_US		100

#define RESPONSE_REGISTER_LOOP_MAX	200



#define SOC_SUBSYSTEM_IP_MAX	12

#define DELAY_MIN_US		2000

#define DELAY_MAX_US		3000

enum amd_pmc_def {

	MSG_TEST = 0x01,

	MSG_OS_HINT_PCO,

	MSG_OS_HINT_RN,

};



struct amd_pmc_bit_map {

	const char *name;

	u32 bit_mask;

};



static const struct amd_pmc_bit_map soc15_ip_blk[] = {

	{"DISPLAY",	BIT(0)},

	{"CPU",		BIT(1)},

	{"GFX",		BIT(2)},

	{"VDD",		BIT(3)},

	{"ACP",		BIT(4)},

	{"VCN",		BIT(5)},

	{"ISP",		BIT(6)},

	{"NBIO",	BIT(7)},

	{"DF",		BIT(8)},

	{"USB0",	BIT(9)},

	{"USB1",	BIT(10)},

	{"LAPIC",	BIT(11)},

	{}

};



struct amd_pmc_dev {

	void __iomem *regbase;

	void __iomem *smu_base;

	void __iomem *smu_virt_addr;

	void __iomem *fch_virt_addr;

	u32 base_addr;

	u32 cpu_id;

	u32 active_ips;

	struct device *dev;

	struct mutex lock; /* generic mutex lock */

#if IS_ENABLED(CONFIG_DEBUG_FS)

	struct dentry *dbgfs_dir;

#endif /* CONFIG_DEBUG_FS */

};



static struct amd_pmc_dev pmc;

static int amd_pmc_send_cmd(struct amd_pmc_dev *dev, bool set, u32 *data, u8 msg, bool ret);



static inline u32 amd_pmc_reg_read(struct amd_pmc_dev *dev, int reg_offset)

{
@@ -85,18 +130,77 @@ static inline void amd_pmc_reg_write(struct amd_pmc_dev *dev, int reg_offset, u3 
	iowrite32(val, dev->regbase + reg_offset);

}



struct smu_metrics {

	u32 table_version;

	u32 hint_count;

	u32 s0i3_cyclecount;

	u32 timein_s0i2;

	u64 timeentering_s0i3_lastcapture;

	u64 timeentering_s0i3_totaltime;

	u64 timeto_resume_to_os_lastcapture;

	u64 timeto_resume_to_os_totaltime;

	u64 timein_s0i3_lastcapture;

	u64 timein_s0i3_totaltime;

	u64 timein_swdrips_lastcapture;

	u64 timein_swdrips_totaltime;

	u64 timecondition_notmet_lastcapture[SOC_SUBSYSTEM_IP_MAX];

	u64 timecondition_notmet_totaltime[SOC_SUBSYSTEM_IP_MAX];

} __packed;



#ifdef CONFIG_DEBUG_FS

static int smu_fw_info_show(struct seq_file *s, void *unused)

{

	struct amd_pmc_dev *dev = s->private;

	u32 value;

	struct smu_metrics table;

	int idx;



	if (dev->cpu_id == AMD_CPU_ID_PCO)

		return -EINVAL;



	memcpy_fromio(&table, dev->smu_virt_addr, sizeof(struct smu_metrics));



	seq_puts(s, "\n=== SMU Statistics ===\n");

	seq_printf(s, "Table Version: %d\n", table.table_version);

	seq_printf(s, "Hint Count: %d\n", table.hint_count);

	seq_printf(s, "S0i3 Cycle Count: %d\n", table.s0i3_cyclecount);

	seq_printf(s, "Time (in us) to S0i3: %lld\n", table.timeentering_s0i3_lastcapture);

	seq_printf(s, "Time (in us) in S0i3: %lld\n", table.timein_s0i3_lastcapture);



	seq_puts(s, "\n=== Active time (in us) ===\n");

	for (idx = 0 ; idx < SOC_SUBSYSTEM_IP_MAX ; idx++) {

		if (soc15_ip_blk[idx].bit_mask & dev->active_ips)

			seq_printf(s, "%-8s : %lld\n", soc15_ip_blk[idx].name,

				   table.timecondition_notmet_lastcapture[idx]);

	}



	value = ioread32(dev->smu_base + AMD_SMU_FW_VERSION);

	seq_printf(s, "SMU FW Info: %x\n", value);

	return 0;

}

DEFINE_SHOW_ATTRIBUTE(smu_fw_info);



static int s0ix_stats_show(struct seq_file *s, void *unused)

{

	struct amd_pmc_dev *dev = s->private;

	u64 entry_time, exit_time, residency;



	entry_time = ioread32(dev->fch_virt_addr + FCH_S0I3_ENTRY_TIME_H_OFFSET);

	entry_time = entry_time << 32 | ioread32(dev->fch_virt_addr + FCH_S0I3_ENTRY_TIME_L_OFFSET);



	exit_time = ioread32(dev->fch_virt_addr + FCH_S0I3_EXIT_TIME_H_OFFSET);

	exit_time = exit_time << 32 | ioread32(dev->fch_virt_addr + FCH_S0I3_EXIT_TIME_L_OFFSET);



	/* It's in 48MHz. We need to convert it */

	residency = exit_time - entry_time;

	do_div(residency, 48);



	seq_puts(s, "=== S0ix statistics ===\n");

	seq_printf(s, "S0ix Entry Time: %lld\n", entry_time);

	seq_printf(s, "S0ix Exit Time: %lld\n", exit_time);

	seq_printf(s, "Residency Time: %lld\n", residency);



	return 0;

}

DEFINE_SHOW_ATTRIBUTE(s0ix_stats);



static void amd_pmc_dbgfs_unregister(struct amd_pmc_dev *dev)

{

	debugfs_remove_recursive(dev->dbgfs_dir);
@@ -107,6 +211,8 @@ static void amd_pmc_dbgfs_register(struct amd_pmc_dev *dev) 
	dev->dbgfs_dir = debugfs_create_dir("amd_pmc", NULL);

	debugfs_create_file("smu_fw_info", 0644, dev->dbgfs_dir, dev,

			    &smu_fw_info_fops);

	debugfs_create_file("s0ix_stats", 0644, dev->dbgfs_dir, dev,

			    &s0ix_stats_fops);

}

#else

static inline void amd_pmc_dbgfs_register(struct amd_pmc_dev *dev)
@@ -118,6 +224,32 @@ static inline void amd_pmc_dbgfs_unregister(struct amd_pmc_dev *dev) 
}

#endif /* CONFIG_DEBUG_FS */



static int amd_pmc_setup_smu_logging(struct amd_pmc_dev *dev)

{

	u32 phys_addr_low, phys_addr_hi;

	u64 smu_phys_addr;



	if (dev->cpu_id == AMD_CPU_ID_PCO)

		return -EINVAL;



	/* Get Active devices list from SMU */

	amd_pmc_send_cmd(dev, 0, &dev->active_ips, SMU_MSG_GET_SUP_CONSTRAINTS, 1);



	/* Get dram address */

	amd_pmc_send_cmd(dev, 0, &phys_addr_low, SMU_MSG_LOG_GETDRAM_ADDR_LO, 1);

	amd_pmc_send_cmd(dev, 0, &phys_addr_hi, SMU_MSG_LOG_GETDRAM_ADDR_HI, 1);

	smu_phys_addr = ((u64)phys_addr_hi << 32 | phys_addr_low);



	dev->smu_virt_addr = devm_ioremap(dev->dev, smu_phys_addr, sizeof(struct smu_metrics));

	if (!dev->smu_virt_addr)

		return -ENOMEM;



	/* Start the logging */

	amd_pmc_send_cmd(dev, 0, NULL, SMU_MSG_LOG_START, 0);



	return 0;

}



static void amd_pmc_dump_registers(struct amd_pmc_dev *dev)

{

	u32 value;
@@ -132,19 +264,19 @@ static void amd_pmc_dump_registers(struct amd_pmc_dev *dev) 
	dev_dbg(dev->dev, "AMD_PMC_REGISTER_MESSAGE:%x\n", value);

}



static int amd_pmc_send_cmd(struct amd_pmc_dev *dev, bool set)

static int amd_pmc_send_cmd(struct amd_pmc_dev *dev, bool set, u32 *data, u8 msg, bool ret)

{

	int rc;

	u8 msg;

	u32 val;



	mutex_lock(&dev->lock);

	/* Wait until we get a valid response */

	rc = readx_poll_timeout(ioread32, dev->regbase + AMD_PMC_REGISTER_RESPONSE,

				val, val > 0, PMC_MSG_DELAY_MIN_US,

				val, val != 0, PMC_MSG_DELAY_MIN_US,

				PMC_MSG_DELAY_MIN_US * RESPONSE_REGISTER_LOOP_MAX);

	if (rc) {

		dev_err(dev->dev, "failed to talk to SMU\n");

		return rc;

		goto out_unlock;

	}



	/* Write zero to response register */
@@ -154,34 +286,91 @@ static int amd_pmc_send_cmd(struct amd_pmc_dev *dev, bool set) 
	amd_pmc_reg_write(dev, AMD_PMC_REGISTER_ARGUMENT, set);



	/* Write message ID to message ID register */

	msg = (dev->cpu_id == AMD_CPU_ID_RN) ? MSG_OS_HINT_RN : MSG_OS_HINT_PCO;

	amd_pmc_reg_write(dev, AMD_PMC_REGISTER_MESSAGE, msg);

	return 0;



	/* Wait until we get a valid response */

	rc = readx_poll_timeout(ioread32, dev->regbase + AMD_PMC_REGISTER_RESPONSE,

				val, val != 0, PMC_MSG_DELAY_MIN_US,

				PMC_MSG_DELAY_MIN_US * RESPONSE_REGISTER_LOOP_MAX);

	if (rc) {

		dev_err(dev->dev, "SMU response timed out\n");

		goto out_unlock;

	}



	switch (val) {

	case AMD_PMC_RESULT_OK:

		if (ret) {

			/* PMFW may take longer time to return back the data */

			usleep_range(DELAY_MIN_US, 10 * DELAY_MAX_US);

			*data = amd_pmc_reg_read(dev, AMD_PMC_REGISTER_ARGUMENT);

		}

		break;

	case AMD_PMC_RESULT_CMD_REJECT_BUSY:

		dev_err(dev->dev, "SMU not ready. err: 0x%x\n", val);

		rc = -EBUSY;

		goto out_unlock;

	case AMD_PMC_RESULT_CMD_UNKNOWN:

		dev_err(dev->dev, "SMU cmd unknown. err: 0x%x\n", val);

		rc = -EINVAL;

		goto out_unlock;

	case AMD_PMC_RESULT_CMD_REJECT_PREREQ:

	case AMD_PMC_RESULT_FAILED:

	default:

		dev_err(dev->dev, "SMU cmd failed. err: 0x%x\n", val);

		rc = -EIO;

		goto out_unlock;

	}



out_unlock:

	mutex_unlock(&dev->lock);

	amd_pmc_dump_registers(dev);

	return rc;

}



static int amd_pmc_get_os_hint(struct amd_pmc_dev *dev)

{

	switch (dev->cpu_id) {

	case AMD_CPU_ID_PCO:

		return MSG_OS_HINT_PCO;

	case AMD_CPU_ID_RN:

	case AMD_CPU_ID_YC:

		return MSG_OS_HINT_RN;

	}

	return -EINVAL;

}



static int __maybe_unused amd_pmc_suspend(struct device *dev)

{

	struct amd_pmc_dev *pdev = dev_get_drvdata(dev);

	int rc;

	u8 msg;



	rc = amd_pmc_send_cmd(pdev, 1);

	/* Reset and Start SMU logging - to monitor the s0i3 stats */

	amd_pmc_send_cmd(pdev, 0, NULL, SMU_MSG_LOG_RESET, 0);

	amd_pmc_send_cmd(pdev, 0, NULL, SMU_MSG_LOG_START, 0);



	msg = amd_pmc_get_os_hint(pdev);

	rc = amd_pmc_send_cmd(pdev, 1, NULL, msg, 0);

	if (rc)

		dev_err(pdev->dev, "suspend failed\n");



	amd_pmc_dump_registers(pdev);

	return 0;

	return rc;

}



static int __maybe_unused amd_pmc_resume(struct device *dev)

{

	struct amd_pmc_dev *pdev = dev_get_drvdata(dev);

	int rc;

	u8 msg;



	rc = amd_pmc_send_cmd(pdev, 0);

	/* Let SMU know that we are looking for stats */

	amd_pmc_send_cmd(pdev, 0, NULL, SMU_MSG_LOG_DUMP_DATA, 0);



	msg = amd_pmc_get_os_hint(pdev);

	rc = amd_pmc_send_cmd(pdev, 0, NULL, msg, 0);

	if (rc)

		dev_err(pdev->dev, "resume failed\n");



	amd_pmc_dump_registers(pdev);

	return 0;

}
@@ -190,6 +379,7 @@ static const struct dev_pm_ops amd_pmc_pm_ops = { 
};



static const struct pci_device_id pmc_pci_ids[] = {

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, AMD_CPU_ID_YC) },

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, AMD_CPU_ID_CZN) },

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, AMD_CPU_ID_RN) },

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, AMD_CPU_ID_PCO) },
@@ -201,9 +391,8 @@ static int amd_pmc_probe(struct platform_device *pdev) 
{

	struct amd_pmc_dev *dev = &pmc;

	struct pci_dev *rdev;

	u32 base_addr_lo;

	u32 base_addr_hi;

	u64 base_addr;

	u32 base_addr_lo, base_addr_hi;

	u64 base_addr, fch_phys_addr;

	int err;

	u32 val;
@@ -248,16 +437,25 @@ static int amd_pmc_probe(struct platform_device *pdev) 
	pci_dev_put(rdev);

	base_addr = ((u64)base_addr_hi << 32 | base_addr_lo);



	dev->smu_base = devm_ioremap(dev->dev, base_addr, AMD_PMC_MAPPING_SIZE);

	if (!dev->smu_base)

		return -ENOMEM;



	dev->regbase = devm_ioremap(dev->dev, base_addr + AMD_PMC_BASE_ADDR_OFFSET,

				    AMD_PMC_MAPPING_SIZE);

	if (!dev->regbase)

		return -ENOMEM;



	amd_pmc_dump_registers(dev);

	mutex_init(&dev->lock);



	/* Use FCH registers to get the S0ix stats */

	base_addr_lo = FCH_BASE_PHY_ADDR_LOW;

	base_addr_hi = FCH_BASE_PHY_ADDR_HIGH;

	fch_phys_addr = ((u64)base_addr_hi << 32 | base_addr_lo);

	dev->fch_virt_addr = devm_ioremap(dev->dev, fch_phys_addr, FCH_SSC_MAPPING_SIZE);

	if (!dev->fch_virt_addr)

		return -ENOMEM;



	/* Use SMU to get the s0i3 debug stats */

	err = amd_pmc_setup_smu_logging(dev);

	if (err)

		dev_err(dev->dev, "SMU debugging info not supported on this platform\n");



	platform_set_drvdata(pdev, dev);

	amd_pmc_dbgfs_register(dev);
@@ -269,11 +467,14 @@ static int amd_pmc_remove(struct platform_device *pdev) 
	struct amd_pmc_dev *dev = platform_get_drvdata(pdev);



	amd_pmc_dbgfs_unregister(dev);

	mutex_destroy(&dev->lock);

	return 0;

}



static const struct acpi_device_id amd_pmc_acpi_ids[] = {

	{"AMDI0005", 0},

	{"AMDI0006", 0},

	{"AMDI0007", 0},

	{"AMD0004", 0},

	{ }

};

drivers/platform/x86/gigabyte-wmi.c

+1 −0
Original line number Diff line number Diff line
@@ -141,6 +141,7 @@ static u8 gigabyte_wmi_detect_sensor_usability(struct wmi_device *wdev) 


static const struct dmi_system_id gigabyte_wmi_known_working_platforms[] = {

	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE"),

	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE V2"),

	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 GAMING X V2"),

	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M AORUS PRO-P"),

	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M DS3H"),

drivers/platform/x86/intel-hid.c

+1 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ static const struct acpi_device_id intel_hid_ids[] = { 
	{"INT33D5", 0},

	{"INTC1051", 0},

	{"INTC1054", 0},

	{"INTC1070", 0},

	{"", 0},

};

MODULE_DEVICE_TABLE(acpi, intel_hid_ids);

drivers/platform/x86/think-lmi.c

+36 −9
Original line number Diff line number Diff line
@@ -571,6 +571,11 @@ static ssize_t current_value_store(struct kobject *kobj, 
	else

		ret = tlmi_save_bios_settings("");



	if (!ret && !tlmi_priv.pending_changes) {

		tlmi_priv.pending_changes = true;

		/* let userland know it may need to check reboot pending again */

		kobject_uevent(&tlmi_priv.class_dev->kobj, KOBJ_CHANGE);

	}

out:

	kfree(auth_str);

	kfree(set_str);
@@ -647,6 +652,14 @@ static struct kobj_type tlmi_pwd_setting_ktype = { 
	.sysfs_ops	= &tlmi_kobj_sysfs_ops,

};



static ssize_t pending_reboot_show(struct kobject *kobj, struct kobj_attribute *attr,

				   char *buf)

{

	return sprintf(buf, "%d\n", tlmi_priv.pending_changes);

}



static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);



/* ---- Initialisation --------------------------------------------------------- */

static void tlmi_release_attr(void)

{
@@ -659,6 +672,7 @@ static void tlmi_release_attr(void) 
			kobject_put(&tlmi_priv.setting[i]->kobj);

		}

	}

	sysfs_remove_file(&tlmi_priv.attribute_kset->kobj, &pending_reboot.attr);

	kset_unregister(tlmi_priv.attribute_kset);



	/* Authentication structures */
@@ -709,8 +723,8 @@ static int tlmi_sysfs_init(void) 


		/* Build attribute */

		tlmi_priv.setting[i]->kobj.kset = tlmi_priv.attribute_kset;

		ret = kobject_init_and_add(&tlmi_priv.setting[i]->kobj, &tlmi_attr_setting_ktype,

				NULL, "%s", tlmi_priv.setting[i]->display_name);

		ret = kobject_add(&tlmi_priv.setting[i]->kobj, NULL,

				  "%s", tlmi_priv.setting[i]->display_name);

		if (ret)

			goto fail_create_attr;
@@ -719,6 +733,10 @@ static int tlmi_sysfs_init(void) 
			goto fail_create_attr;

	}



	ret = sysfs_create_file(&tlmi_priv.attribute_kset->kobj, &pending_reboot.attr);

	if (ret)

		goto fail_create_attr;



	/* Create authentication entries */

	tlmi_priv.authentication_kset = kset_create_and_add("authentication", NULL,

								&tlmi_priv.class_dev->kobj);
@@ -727,8 +745,7 @@ static int tlmi_sysfs_init(void) 
		goto fail_create_attr;

	}

	tlmi_priv.pwd_admin->kobj.kset = tlmi_priv.authentication_kset;

	ret = kobject_init_and_add(&tlmi_priv.pwd_admin->kobj, &tlmi_pwd_setting_ktype,

			NULL, "%s", "Admin");

	ret = kobject_add(&tlmi_priv.pwd_admin->kobj, NULL, "%s", "Admin");

	if (ret)

		goto fail_create_attr;
@@ -737,8 +754,7 @@ static int tlmi_sysfs_init(void) 
		goto fail_create_attr;



	tlmi_priv.pwd_power->kobj.kset = tlmi_priv.authentication_kset;

	ret = kobject_init_and_add(&tlmi_priv.pwd_power->kobj, &tlmi_pwd_setting_ktype,

			NULL, "%s", "System");

	ret = kobject_add(&tlmi_priv.pwd_power->kobj, NULL, "%s", "System");

	if (ret)

		goto fail_create_attr;
@@ -818,6 +834,7 @@ static int tlmi_analyze(void) 
				pr_info("Error retrieving possible values for %d : %s\n",

						i, setting->display_name);

		}

		kobject_init(&setting->kobj, &tlmi_attr_setting_ktype);

		tlmi_priv.setting[i] = setting;

		tlmi_priv.settings_count++;

		kfree(item);
@@ -844,10 +861,12 @@ static int tlmi_analyze(void) 
	if (pwdcfg.password_state & TLMI_PAP_PWD)

		tlmi_priv.pwd_admin->valid = true;



	kobject_init(&tlmi_priv.pwd_admin->kobj, &tlmi_pwd_setting_ktype);



	tlmi_priv.pwd_power = kzalloc(sizeof(struct tlmi_pwd_setting), GFP_KERNEL);

	if (!tlmi_priv.pwd_power) {

		ret = -ENOMEM;

		goto fail_clear_attr;

		goto fail_free_pwd_admin;

	}

	strscpy(tlmi_priv.pwd_power->kbdlang, "us", TLMI_LANG_MAXLEN);

	tlmi_priv.pwd_power->encoding = TLMI_ENCODING_ASCII;
@@ -859,11 +878,19 @@ static int tlmi_analyze(void) 
	if (pwdcfg.password_state & TLMI_POP_PWD)

		tlmi_priv.pwd_power->valid = true;



	kobject_init(&tlmi_priv.pwd_power->kobj, &tlmi_pwd_setting_ktype);



	return 0;



fail_free_pwd_admin:

	kfree(tlmi_priv.pwd_admin);

fail_clear_attr:

	for (i = 0; i < TLMI_SETTINGS_COUNT; ++i)

	for (i = 0; i < TLMI_SETTINGS_COUNT; ++i) {

		if (tlmi_priv.setting[i]) {

			kfree(tlmi_priv.setting[i]->possible_values);

			kfree(tlmi_priv.setting[i]);

		}

	}

	return ret;

}

drivers/platform/x86/think-lmi.h

+1 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ struct think_lmi { 
	bool can_get_bios_selections;

	bool can_set_bios_password;

	bool can_get_password_settings;

	bool pending_changes;



	struct tlmi_attr_setting *setting[TLMI_SETTINGS_COUNT];

	struct device *class_dev;