// 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, 31, 32};

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",
	"PSU1",
	"PSU2",
};

static int p8_temp_map[] = {0, 1, 2, 8, 9, 13, 14, 15, 16, 17, 19, 20, 33};

static const char * const lenovo_p8_ec_temp_label[] = {
	"CPU1",
	"CPU_DIMM_BANK1",
	"CPU_DIMM_BANK2",
	"M2_Z2R",
	"M2_Z3R",
	"DIMM_RIGHT",
	"DIMM_LEFT",
	"PCI_Z1",
	"PCI_Z2",
	"PCI_Z3",
	"AMB",
	"REAR_VR",
	"PSU",
};

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

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",
	"PSU",
};

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_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_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_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_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_p8_ec_temp_label;
		ec_data->fan_map = p8_fan_map;
		ec_data->temp_map = p8_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");
