drivers/hwmon/lenovo-ec-sensors.c - linux/torvalds/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * HWMON driver for Lenovo ThinkStation based workstations
  * via the embedded controller registers
  *
  * Copyright (C) 2024 David Ober (Lenovo) <dober@lenovo.com>
  *
  * EC provides:
  * - CPU temperature
  * - DIMM temperature
  * - Chassis zone temperatures
  * - CPU fan RPM
  * - DIMM fan RPM
  * - Chassis fans RPM
  */

 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

 #include <linux/acpi.h>
 #include <linux/bits.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/dmi.h>
 #include <linux/err.h>
 #include <linux/hwmon.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/units.h>

 #define MCHP_SING_IDX			0x0000
 #define MCHP_EMI0_APPLICATION_ID	0x090C
 #define MCHP_EMI0_EC_ADDRESS		0x0902
 #define MCHP_EMI0_EC_DATA_BYTE0		0x0904
 #define MCHP_EMI0_EC_DATA_BYTE1		0x0905
 #define MCHP_EMI0_EC_DATA_BYTE2		0x0906
 #define MCHP_EMI0_EC_DATA_BYTE3		0x0907
 #define IO_REGION_START			0x0900
 #define IO_REGION_LENGTH		0xD

 static inline u8
 get_ec_reg(unsigned char page, unsigned char index)
 {
 	u8 onebyte;
 	unsigned short m_index;
 	unsigned short phy_index = page * 256 + index;

 	outb_p(0x01, MCHP_EMI0_APPLICATION_ID);

 	m_index = phy_index & GENMASK(14, 2);
 	outw_p(m_index, MCHP_EMI0_EC_ADDRESS);

 	onebyte = inb_p(MCHP_EMI0_EC_DATA_BYTE0 + (phy_index & GENMASK(1, 0)));

 	outb_p(0x01, MCHP_EMI0_APPLICATION_ID);  /* write 0x01 again to clean */
 	return onebyte;
 }

 enum systems {
 	LENOVO_PX,
 	LENOVO_P7,
 	LENOVO_P5,
 	LENOVO_P8,
 };

 static int px_temp_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

 static const char * const lenovo_px_ec_temp_label[] = {
 	"CPU1",
 	"CPU2",
 	"R_DIMM1",
 	"L_DIMM1",
 	"R_DIMM2",
 	"L_DIMM2",
 	"PCH",
 	"M2_R",
 	"M2_Z1R",
 	"M2_Z2R",
 	"PCI_Z1",
 	"PCI_Z2",
 	"PCI_Z3",
 	"PCI_Z4",
 	"AMB",
 };

 static int gen_temp_map[] = {0, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

 static const char * const lenovo_gen_ec_temp_label[] = {
 	"CPU1",
 	"R_DIMM",
 	"L_DIMM",
 	"PCH",
 	"M2_R",
 	"M2_Z1R",
 	"M2_Z2R",
 	"PCI_Z1",
 	"PCI_Z2",
 	"PCI_Z3",
 	"PCI_Z4",
 	"AMB",
 };

 static int px_fan_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

 static const char * const px_ec_fan_label[] = {
 	"CPU1_Fan",
 	"CPU2_Fan",
 	"Front_Fan1-1",
 	"Front_Fan1-2",
 	"Front_Fan2",
 	"Front_Fan3",
 	"MEM_Fan1",
 	"MEM_Fan2",
 	"Rear_Fan1",
 	"Rear_Fan2",
 	"Flex_Bay_Fan1",
 	"Flex_Bay_Fan2",
 	"Flex_Bay_Fan2",
 	"PSU_HDD_Fan",
 	"PSU1_Fan",
 	"PSU2_Fan",
 };

 static int p7_fan_map[] = {0, 2, 3, 4, 5, 6, 7, 8, 10, 11, 14};

 static const char * const p7_ec_fan_label[] = {
 	"CPU1_Fan",
 	"HP_CPU_Fan1",
 	"HP_CPU_Fan2",
 	"PCIE1_4_Fan",
 	"PCIE5_7_Fan",
 	"MEM_Fan1",
 	"MEM_Fan2",
 	"Rear_Fan1",
 	"BCB_Fan",
 	"Flex_Bay_Fan",
 	"PSU_Fan",
 };

 static int p5_fan_map[] = {0, 5, 6, 7, 8, 10, 11, 14};

 static const char * const p5_ec_fan_label[] = {
 	"CPU_Fan",
 	"HDD_Fan",
 	"Duct_Fan1",
 	"MEM_Fan",
 	"Rear_Fan",
 	"Front_Fan",
 	"Flex_Bay_Fan",
 	"PSU_Fan",
 };

 static int p8_fan_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14};

 static const char * const p8_ec_fan_label[] = {
 	"CPU1_Fan",
 	"CPU2_Fan",
 	"HP_CPU_Fan1",
 	"HP_CPU_Fan2",
 	"PCIE1_4_Fan",
 	"PCIE5_7_Fan",
 	"DIMM1_Fan1",
 	"DIMM1_Fan2",
 	"DIMM2_Fan1",
 	"DIMM2_Fan2",
 	"Rear_Fan",
 	"HDD_Bay_Fan",
 	"Flex_Bay_Fan",
 	"PSU_Fan",
 };

 struct ec_sensors_data {
 	struct mutex mec_mutex; /* lock for sensor data access */
 	const char *const *fan_labels;
 	const char *const *temp_labels;
 	const int *fan_map;
 	const int *temp_map;
 };

 static int
 lenovo_ec_do_read_temp(struct ec_sensors_data *data, u32 attr, int channel, long *val)
 {
 	u8 lsb;

 	switch (attr) {
 	case hwmon_temp_input:
 		mutex_lock(&data->mec_mutex);
 		lsb = get_ec_reg(2, 0x81 + channel);
 		mutex_unlock(&data->mec_mutex);
 		if (lsb <= 0x40)
 			return -ENODATA;
 		*val = (lsb - 0x40) * 1000;
 		return 0;
 	default:
 		return -EOPNOTSUPP;
 	}
 }

 static int
 lenovo_ec_do_read_fan(struct ec_sensors_data *data, u32 attr, int channel, long *val)
 {
 	u8 lsb, msb;

 	channel *= 2;
 	switch (attr) {
 	case hwmon_fan_input:
 		mutex_lock(&data->mec_mutex);
 		lsb = get_ec_reg(4, 0x20 + channel);
 		msb = get_ec_reg(4, 0x21 + channel);
 		mutex_unlock(&data->mec_mutex);
 		*val = (msb << 8) + lsb;
 		return 0;
 	case hwmon_fan_max:
 		mutex_lock(&data->mec_mutex);
 		lsb = get_ec_reg(4, 0x40 + channel);
 		msb = get_ec_reg(4, 0x41 + channel);
 		mutex_unlock(&data->mec_mutex);
 		*val = (msb << 8) + lsb;
 		return 0;
 	default:
 		return -EOPNOTSUPP;
 	}
 }

 static int
 lenovo_ec_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type,
 			    u32 attr, int channel, const char **str)
 {
 	struct ec_sensors_data *state = dev_get_drvdata(dev);

 	switch (type) {
 	case hwmon_temp:
 		*str = state->temp_labels[channel];
 		return 0;
 	case hwmon_fan:
 		*str = state->fan_labels[channel];
 		return 0;
 	default:
 		return -EOPNOTSUPP;
 	}
 }

 static int
 lenovo_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
 		     u32 attr, int channel, long *val)
 {
 	struct ec_sensors_data *data = dev_get_drvdata(dev);

 	switch (type) {
 	case hwmon_temp:
 		return lenovo_ec_do_read_temp(data, attr, data->temp_map[channel], val);
 	case hwmon_fan:
 		return lenovo_ec_do_read_fan(data, attr, data->fan_map[channel], val);
 	default:
 		return -EOPNOTSUPP;
 	}
 }

 static umode_t
 lenovo_ec_hwmon_is_visible(const void *data, enum hwmon_sensor_types type,
 			   u32 attr, int channel)
 {
 	switch (type) {
 	case hwmon_temp:
 		if (attr == hwmon_temp_input || attr == hwmon_temp_label)
 			return 0444;
 		return 0;
 	case hwmon_fan:
 		if (attr == hwmon_fan_input || attr == hwmon_fan_max || attr == hwmon_fan_label)
 			return 0444;
 		return 0;
 	default:
 		return 0;
 	}
 }

 static const struct hwmon_channel_info *lenovo_ec_hwmon_info_px[] = {
 	HWMON_CHANNEL_INFO(temp,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL),
 	HWMON_CHANNEL_INFO(fan,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX),
 	NULL
 };

 static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p8[] = {
 	HWMON_CHANNEL_INFO(temp,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL),
 	HWMON_CHANNEL_INFO(fan,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX),
 	NULL
 };

 static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p7[] = {
 	HWMON_CHANNEL_INFO(temp,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL),
 	HWMON_CHANNEL_INFO(fan,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX),
 	NULL
 };

 static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p5[] = {
 	HWMON_CHANNEL_INFO(temp,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL,
 			   HWMON_T_INPUT | HWMON_T_LABEL),
 	HWMON_CHANNEL_INFO(fan,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX,
 			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MAX),
 	NULL
 };

 static const struct hwmon_ops lenovo_ec_hwmon_ops = {
 	.is_visible = lenovo_ec_hwmon_is_visible,
 	.read = lenovo_ec_hwmon_read,
 	.read_string = lenovo_ec_hwmon_read_string,
 };

 static struct hwmon_chip_info lenovo_ec_chip_info = {
 	.ops = &lenovo_ec_hwmon_ops,
 };

 static const struct dmi_system_id thinkstation_dmi_table[] = {
 	{
 		.ident = "LENOVO_PX",
 		.driver_data = (void *)(long)LENOVO_PX,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30EU"),
 		},
 	},
 	{
 		.ident = "LENOVO_PX",
 		.driver_data = (void *)(long)LENOVO_PX,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30EV"),
 		},
 	},
 	{
 		.ident = "LENOVO_P7",
 		.driver_data = (void *)(long)LENOVO_P7,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30F2"),
 		},
 	},
 	{
 		.ident = "LENOVO_P7",
 		.driver_data = (void *)(long)LENOVO_P7,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30F3"),
 		},
 	},
 	{
 		.ident = "LENOVO_P5",
 		.driver_data = (void *)(long)LENOVO_P5,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30G9"),
 		},
 	},
 	{
 		.ident = "LENOVO_P5",
 		.driver_data = (void *)(long)LENOVO_P5,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30GA"),
 		},
 	},
 	{
 		.ident = "LENOVO_P8",
 		.driver_data = (void *)(long)LENOVO_P8,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30HH"),
 		},
 	},
 	{
 		.ident = "LENOVO_P8",
 		.driver_data = (void *)(long)LENOVO_P8,
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "30HJ"),
 		},
 	},
 	{}
 };
 MODULE_DEVICE_TABLE(dmi, thinkstation_dmi_table);

 static int lenovo_ec_probe(struct platform_device *pdev)
 {
 	struct device *hwdev;
 	struct ec_sensors_data *ec_data;
 	const struct hwmon_chip_info *chip_info;
 	struct device *dev = &pdev->dev;
 	const struct dmi_system_id *dmi_id;
 	int app_id;

 	ec_data = devm_kzalloc(dev, sizeof(struct ec_sensors_data), GFP_KERNEL);
 	if (!ec_data)
 		return -ENOMEM;

 	if (!request_region(IO_REGION_START, IO_REGION_LENGTH, "LNV-WKS")) {
 		pr_err(":request fail\n");
 		return -EIO;
 	}

 	dev_set_drvdata(dev, ec_data);

 	chip_info = &lenovo_ec_chip_info;

 	mutex_init(&ec_data->mec_mutex);

 	mutex_lock(&ec_data->mec_mutex);
 	app_id = inb_p(MCHP_EMI0_APPLICATION_ID);
 	if (app_id) /* check EMI Application ID Value */
 		outb_p(app_id, MCHP_EMI0_APPLICATION_ID); /* set EMI Application ID to 0 */
 	outw_p(MCHP_SING_IDX, MCHP_EMI0_EC_ADDRESS);
 	mutex_unlock(&ec_data->mec_mutex);

 	if ((inb_p(MCHP_EMI0_EC_DATA_BYTE0) != 'M') &&
 	    (inb_p(MCHP_EMI0_EC_DATA_BYTE1) != 'C') &&
 	    (inb_p(MCHP_EMI0_EC_DATA_BYTE2) != 'H') &&
 	    (inb_p(MCHP_EMI0_EC_DATA_BYTE3) != 'P')) {
 		release_region(IO_REGION_START, IO_REGION_LENGTH);
 		return -ENODEV;
 	}

 	dmi_id = dmi_first_match(thinkstation_dmi_table);

 	switch ((long)dmi_id->driver_data) {
 	case 0:
 		ec_data->fan_labels = px_ec_fan_label;
 		ec_data->temp_labels = lenovo_px_ec_temp_label;
 		ec_data->fan_map = px_fan_map;
 		ec_data->temp_map = px_temp_map;
 		lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_px;
 		break;
 	case 1:
 		ec_data->fan_labels = p7_ec_fan_label;
 		ec_data->temp_labels = lenovo_gen_ec_temp_label;
 		ec_data->fan_map = p7_fan_map;
 		ec_data->temp_map = gen_temp_map;
 		lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p7;
 		break;
 	case 2:
 		ec_data->fan_labels = p5_ec_fan_label;
 		ec_data->temp_labels = lenovo_gen_ec_temp_label;
 		ec_data->fan_map = p5_fan_map;
 		ec_data->temp_map = gen_temp_map;
 		lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p5;
 		break;
 	case 3:
 		ec_data->fan_labels = p8_ec_fan_label;
 		ec_data->temp_labels = lenovo_gen_ec_temp_label;
 		ec_data->fan_map = p8_fan_map;
 		ec_data->temp_map = gen_temp_map;
 		lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p8;
 		break;
 	default:
 		release_region(IO_REGION_START, IO_REGION_LENGTH);
 		return -ENODEV;
 	}

 	hwdev = devm_hwmon_device_register_with_info(dev, "lenovo_ec",
 						     ec_data,
 						     chip_info, NULL);

 	return PTR_ERR_OR_ZERO(hwdev);
 }

 static struct platform_driver lenovo_ec_sensors_platform_driver = {
 	.driver = {
 		.name	= "lenovo-ec-sensors",
 	},
 	.probe = lenovo_ec_probe,
 };

 static struct platform_device *lenovo_ec_sensors_platform_device;

 static int __init lenovo_ec_init(void)
 {
 	if (!dmi_check_system(thinkstation_dmi_table))
 		return -ENODEV;

 	lenovo_ec_sensors_platform_device =
 		platform_create_bundle(&lenovo_ec_sensors_platform_driver,
 				       lenovo_ec_probe, NULL, 0, NULL, 0);

 	if (IS_ERR(lenovo_ec_sensors_platform_device)) {
 		release_region(IO_REGION_START, IO_REGION_LENGTH);
 		return PTR_ERR(lenovo_ec_sensors_platform_device);
 	}

 	return 0;
 }
 module_init(lenovo_ec_init);

 static void __exit lenovo_ec_exit(void)
 {
 	release_region(IO_REGION_START, IO_REGION_LENGTH);
 	platform_device_unregister(lenovo_ec_sensors_platform_device);
 	platform_driver_unregister(&lenovo_ec_sensors_platform_driver);
 }
 module_exit(lenovo_ec_exit);

 MODULE_AUTHOR("David Ober <dober@lenovo.com>");
 MODULE_DESCRIPTION("HWMON driver for sensors accessible via EC in LENOVO motherboards");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* HWMON driver for Lenovo ThinkStation based workstations
	* via the embedded controller registers
	*
	* Copyright (C) 2024 David Ober (Lenovo) <dober@lenovo.com>
	*
	* EC provides:
	* - CPU temperature
	* - DIMM temperature
	* - Chassis zone temperatures
	* - CPU fan RPM
	* - DIMM fan RPM
	* - Chassis fans RPM
	*/

	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

	#include <linux/acpi.h>
	#include <linux/bits.h>
	#include <linux/delay.h>
	#include <linux/device.h>
	#include <linux/dmi.h>
	#include <linux/err.h>
	#include <linux/hwmon.h>
	#include <linux/io.h>
	#include <linux/ioport.h>
	#include <linux/module.h>
	#include <linux/mutex.h>
	#include <linux/platform_device.h>
	#include <linux/types.h>
	#include <linux/units.h>

	#define MCHP_SING_IDX 0x0000
	#define MCHP_EMI0_APPLICATION_ID 0x090C
	#define MCHP_EMI0_EC_ADDRESS 0x0902
	#define MCHP_EMI0_EC_DATA_BYTE0 0x0904
	#define MCHP_EMI0_EC_DATA_BYTE1 0x0905
	#define MCHP_EMI0_EC_DATA_BYTE2 0x0906
	#define MCHP_EMI0_EC_DATA_BYTE3 0x0907
	#define IO_REGION_START 0x0900
	#define IO_REGION_LENGTH 0xD

	static inline u8
	get_ec_reg(unsigned char page, unsigned char index)
	{
	u8 onebyte;
	unsigned short m_index;
	unsigned short phy_index = page * 256 + index;

	outb_p(0x01, MCHP_EMI0_APPLICATION_ID);

	m_index = phy_index & GENMASK(14, 2);
	outw_p(m_index, MCHP_EMI0_EC_ADDRESS);

	onebyte = inb_p(MCHP_EMI0_EC_DATA_BYTE0 + (phy_index & GENMASK(1, 0)));

	outb_p(0x01, MCHP_EMI0_APPLICATION_ID); /* write 0x01 again to clean */
	return onebyte;
	}

	enum systems {
	LENOVO_PX,
	LENOVO_P7,
	LENOVO_P5,
	LENOVO_P8,
	};

	static int px_temp_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

	static const char * const lenovo_px_ec_temp_label[] = {
	"CPU1",
	"CPU2",
	"R_DIMM1",
	"L_DIMM1",
	"R_DIMM2",
	"L_DIMM2",
	"PCH",
	"M2_R",
	"M2_Z1R",
	"M2_Z2R",
	"PCI_Z1",
	"PCI_Z2",
	"PCI_Z3",
	"PCI_Z4",
	"AMB",
	};

	static int gen_temp_map[] = {0, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

	static const char * const lenovo_gen_ec_temp_label[] = {
	"CPU1",
	"R_DIMM",
	"L_DIMM",
	"PCH",
	"M2_R",
	"M2_Z1R",
	"M2_Z2R",
	"PCI_Z1",
	"PCI_Z2",
	"PCI_Z3",
	"PCI_Z4",
	"AMB",
	};

	static int px_fan_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

	static const char * const px_ec_fan_label[] = {
	"CPU1_Fan",
	"CPU2_Fan",
	"Front_Fan1-1",
	"Front_Fan1-2",
	"Front_Fan2",
	"Front_Fan3",
	"MEM_Fan1",
	"MEM_Fan2",
	"Rear_Fan1",
	"Rear_Fan2",
	"Flex_Bay_Fan1",
	"Flex_Bay_Fan2",
	"Flex_Bay_Fan2",
	"PSU_HDD_Fan",
	"PSU1_Fan",
	"PSU2_Fan",
	};

	static int p7_fan_map[] = {0, 2, 3, 4, 5, 6, 7, 8, 10, 11, 14};

	static const char * const p7_ec_fan_label[] = {
	"CPU1_Fan",
	"HP_CPU_Fan1",
	"HP_CPU_Fan2",
	"PCIE1_4_Fan",
	"PCIE5_7_Fan",
	"MEM_Fan1",
	"MEM_Fan2",
	"Rear_Fan1",
	"BCB_Fan",
	"Flex_Bay_Fan",
	"PSU_Fan",
	};

	static int p5_fan_map[] = {0, 5, 6, 7, 8, 10, 11, 14};

	static const char * const p5_ec_fan_label[] = {
	"CPU_Fan",
	"HDD_Fan",
	"Duct_Fan1",
	"MEM_Fan",
	"Rear_Fan",
	"Front_Fan",
	"Flex_Bay_Fan",
	"PSU_Fan",
	};

	static int p8_fan_map[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14};

	static const char * const p8_ec_fan_label[] = {
	"CPU1_Fan",
	"CPU2_Fan",
	"HP_CPU_Fan1",
	"HP_CPU_Fan2",
	"PCIE1_4_Fan",
	"PCIE5_7_Fan",
	"DIMM1_Fan1",
	"DIMM1_Fan2",
	"DIMM2_Fan1",
	"DIMM2_Fan2",
	"Rear_Fan",
	"HDD_Bay_Fan",
	"Flex_Bay_Fan",
	"PSU_Fan",
	};

	struct ec_sensors_data {
	struct mutex mec_mutex; /* lock for sensor data access */
	const char const fan_labels;
	const char const temp_labels;
	const int *fan_map;
	const int *temp_map;
	};

	static int
	lenovo_ec_do_read_temp(struct ec_sensors_data data, u32 attr, int channel, long val)
	{
	u8 lsb;

	switch (attr) {
	case hwmon_temp_input:
	mutex_lock(&data->mec_mutex);
	lsb = get_ec_reg(2, 0x81 + channel);
	mutex_unlock(&data->mec_mutex);
	if (lsb <= 0x40)
	return -ENODATA;
	val = (lsb - 0x40) 1000;
	return 0;
	default:
	return -EOPNOTSUPP;
	}
	}

	static int
	lenovo_ec_do_read_fan(struct ec_sensors_data data, u32 attr, int channel, long val)
	{
	u8 lsb, msb;

	channel *= 2;
	switch (attr) {
	case hwmon_fan_input:
	mutex_lock(&data->mec_mutex);
	lsb = get_ec_reg(4, 0x20 + channel);
	msb = get_ec_reg(4, 0x21 + channel);
	mutex_unlock(&data->mec_mutex);
	*val = (msb << 8) + lsb;
	return 0;
	case hwmon_fan_max:
	mutex_lock(&data->mec_mutex);
	lsb = get_ec_reg(4, 0x40 + channel);
	msb = get_ec_reg(4, 0x41 + channel);
	mutex_unlock(&data->mec_mutex);
	*val = (msb << 8) + lsb;
	return 0;
	default:
	return -EOPNOTSUPP;
	}
	}

	static int
	lenovo_ec_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type,
	u32 attr, int channel, const char **str)
	{
	struct ec_sensors_data *state = dev_get_drvdata(dev);

	switch (type) {
	case hwmon_temp:
	*str = state->temp_labels[channel];
	return 0;
	case hwmon_fan:
	*str = state->fan_labels[channel];
	return 0;
	default:
	return -EOPNOTSUPP;
	}
	}

	static int
	lenovo_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
	u32 attr, int channel, long *val)
	{
	struct ec_sensors_data *data = dev_get_drvdata(dev);

	switch (type) {
	case hwmon_temp:
	return lenovo_ec_do_read_temp(data, attr, data->temp_map[channel], val);
	case hwmon_fan:
	return lenovo_ec_do_read_fan(data, attr, data->fan_map[channel], val);
	default:
	return -EOPNOTSUPP;
	}
	}

	static umode_t
	lenovo_ec_hwmon_is_visible(const void *data, enum hwmon_sensor_types type,
	u32 attr, int channel)
	{
	switch (type) {
	case hwmon_temp:
	if (attr == hwmon_temp_input \|\| attr == hwmon_temp_label)
	return 0444;
	return 0;
	case hwmon_fan:
	if (attr == hwmon_fan_input \|\| attr == hwmon_fan_max \|\| attr == hwmon_fan_label)
	return 0444;
	return 0;
	default:
	return 0;
	}
	}

	static const struct hwmon_channel_info *lenovo_ec_hwmon_info_px[] = {
	HWMON_CHANNEL_INFO(temp,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL),
	HWMON_CHANNEL_INFO(fan,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX),
	NULL
	};

	static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p8[] = {
	HWMON_CHANNEL_INFO(temp,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL),
	HWMON_CHANNEL_INFO(fan,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX),
	NULL
	};

	static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p7[] = {
	HWMON_CHANNEL_INFO(temp,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL),
	HWMON_CHANNEL_INFO(fan,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX),
	NULL
	};

	static const struct hwmon_channel_info *lenovo_ec_hwmon_info_p5[] = {
	HWMON_CHANNEL_INFO(temp,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL,
	HWMON_T_INPUT \| HWMON_T_LABEL),
	HWMON_CHANNEL_INFO(fan,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX,
	HWMON_F_INPUT \| HWMON_F_LABEL \| HWMON_F_MAX),
	NULL
	};

	static const struct hwmon_ops lenovo_ec_hwmon_ops = {
	.is_visible = lenovo_ec_hwmon_is_visible,
	.read = lenovo_ec_hwmon_read,
	.read_string = lenovo_ec_hwmon_read_string,
	};

	static struct hwmon_chip_info lenovo_ec_chip_info = {
	.ops = &lenovo_ec_hwmon_ops,
	};

	static const struct dmi_system_id thinkstation_dmi_table[] = {
	{
	.ident = "LENOVO_PX",
	.driver_data = (void *)(long)LENOVO_PX,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30EU"),
	},
	},
	{
	.ident = "LENOVO_PX",
	.driver_data = (void *)(long)LENOVO_PX,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30EV"),
	},
	},
	{
	.ident = "LENOVO_P7",
	.driver_data = (void *)(long)LENOVO_P7,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30F2"),
	},
	},
	{
	.ident = "LENOVO_P7",
	.driver_data = (void *)(long)LENOVO_P7,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30F3"),
	},
	},
	{
	.ident = "LENOVO_P5",
	.driver_data = (void *)(long)LENOVO_P5,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30G9"),
	},
	},
	{
	.ident = "LENOVO_P5",
	.driver_data = (void *)(long)LENOVO_P5,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30GA"),
	},
	},
	{
	.ident = "LENOVO_P8",
	.driver_data = (void *)(long)LENOVO_P8,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30HH"),
	},
	},
	{
	.ident = "LENOVO_P8",
	.driver_data = (void *)(long)LENOVO_P8,
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_NAME, "30HJ"),
	},
	},
	{}
	};
	MODULE_DEVICE_TABLE(dmi, thinkstation_dmi_table);

	static int lenovo_ec_probe(struct platform_device *pdev)
	{
	struct device *hwdev;
	struct ec_sensors_data *ec_data;
	const struct hwmon_chip_info *chip_info;
	struct device *dev = &pdev->dev;
	const struct dmi_system_id *dmi_id;
	int app_id;

	ec_data = devm_kzalloc(dev, sizeof(struct ec_sensors_data), GFP_KERNEL);
	if (!ec_data)
	return -ENOMEM;

	if (!request_region(IO_REGION_START, IO_REGION_LENGTH, "LNV-WKS")) {
	pr_err(":request fail\n");
	return -EIO;
	}

	dev_set_drvdata(dev, ec_data);

	chip_info = &lenovo_ec_chip_info;

	mutex_init(&ec_data->mec_mutex);

	mutex_lock(&ec_data->mec_mutex);
	app_id = inb_p(MCHP_EMI0_APPLICATION_ID);
	if (app_id) /* check EMI Application ID Value */
	outb_p(app_id, MCHP_EMI0_APPLICATION_ID); /* set EMI Application ID to 0 */
	outw_p(MCHP_SING_IDX, MCHP_EMI0_EC_ADDRESS);
	mutex_unlock(&ec_data->mec_mutex);

	if ((inb_p(MCHP_EMI0_EC_DATA_BYTE0) != 'M') &&
	(inb_p(MCHP_EMI0_EC_DATA_BYTE1) != 'C') &&
	(inb_p(MCHP_EMI0_EC_DATA_BYTE2) != 'H') &&
	(inb_p(MCHP_EMI0_EC_DATA_BYTE3) != 'P')) {
	release_region(IO_REGION_START, IO_REGION_LENGTH);
	return -ENODEV;
	}

	dmi_id = dmi_first_match(thinkstation_dmi_table);

	switch ((long)dmi_id->driver_data) {
	case 0:
	ec_data->fan_labels = px_ec_fan_label;
	ec_data->temp_labels = lenovo_px_ec_temp_label;
	ec_data->fan_map = px_fan_map;
	ec_data->temp_map = px_temp_map;
	lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_px;
	break;
	case 1:
	ec_data->fan_labels = p7_ec_fan_label;
	ec_data->temp_labels = lenovo_gen_ec_temp_label;
	ec_data->fan_map = p7_fan_map;
	ec_data->temp_map = gen_temp_map;
	lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p7;
	break;
	case 2:
	ec_data->fan_labels = p5_ec_fan_label;
	ec_data->temp_labels = lenovo_gen_ec_temp_label;
	ec_data->fan_map = p5_fan_map;
	ec_data->temp_map = gen_temp_map;
	lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p5;
	break;
	case 3:
	ec_data->fan_labels = p8_ec_fan_label;
	ec_data->temp_labels = lenovo_gen_ec_temp_label;
	ec_data->fan_map = p8_fan_map;
	ec_data->temp_map = gen_temp_map;
	lenovo_ec_chip_info.info = lenovo_ec_hwmon_info_p8;
	break;
	default:
	release_region(IO_REGION_START, IO_REGION_LENGTH);
	return -ENODEV;
	}

	hwdev = devm_hwmon_device_register_with_info(dev, "lenovo_ec",
	ec_data,
	chip_info, NULL);

	return PTR_ERR_OR_ZERO(hwdev);
	}

	static struct platform_driver lenovo_ec_sensors_platform_driver = {
	.driver = {
	.name = "lenovo-ec-sensors",
	},
	.probe = lenovo_ec_probe,
	};

	static struct platform_device *lenovo_ec_sensors_platform_device;

	static int __init lenovo_ec_init(void)
	{
	if (!dmi_check_system(thinkstation_dmi_table))
	return -ENODEV;

	lenovo_ec_sensors_platform_device =
	platform_create_bundle(&lenovo_ec_sensors_platform_driver,
	lenovo_ec_probe, NULL, 0, NULL, 0);

	if (IS_ERR(lenovo_ec_sensors_platform_device)) {
	release_region(IO_REGION_START, IO_REGION_LENGTH);
	return PTR_ERR(lenovo_ec_sensors_platform_device);
	}

	return 0;
	}
	module_init(lenovo_ec_init);

	static void __exit lenovo_ec_exit(void)
	{
	release_region(IO_REGION_START, IO_REGION_LENGTH);
	platform_device_unregister(lenovo_ec_sensors_platform_device);
	platform_driver_unregister(&lenovo_ec_sensors_platform_driver);
	}
	module_exit(lenovo_ec_exit);

	MODULE_AUTHOR("David Ober <dober@lenovo.com>");
	MODULE_DESCRIPTION("HWMON driver for sensors accessible via EC in LENOVO motherboards");
	MODULE_LICENSE("GPL");