[linux-2.6-block.git] / drivers / hwmon / ibmpex.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * A hwmon driver for the IBM PowerExecutive temperature/power sensors
 * Copyright (C) 2007 IBM
 *
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 */

#include <linux/ipmi.h>
#include <linux/module.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/err.h>

#define REFRESH_INTERVAL	(2 * HZ)
#define DRVNAME			"ibmpex"

#define PEX_GET_VERSION		1
#define PEX_GET_SENSOR_COUNT	2
#define PEX_GET_SENSOR_NAME	3
#define PEX_RESET_HIGH_LOW	4
#define PEX_GET_SENSOR_DATA	6

#define PEX_NET_FUNCTION	0x3A
#define PEX_COMMAND		0x3C

static inline u16 extract_value(const char *data, int offset)
{
	return be16_to_cpup((__be16 *)&data[offset]);
}

#define TEMP_SENSOR		1
#define POWER_SENSOR		2

#define PEX_SENSOR_TYPE_LEN	3
static u8 const power_sensor_sig[] = {0x70, 0x77, 0x72};
static u8 const temp_sensor_sig[]  = {0x74, 0x65, 0x6D};

#define PEX_MULT_LEN		2
static u8 const watt_sensor_sig[]  = {0x41, 0x43};

#define PEX_NUM_SENSOR_FUNCS	3
static const char * const sensor_name_suffixes[] = {
	"",
	"_lowest",
	"_highest"
};

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data);
static void ibmpex_register_bmc(int iface, struct device *dev);
static void ibmpex_bmc_gone(int iface);

struct ibmpex_sensor_data {
	int			in_use;
	s16			values[PEX_NUM_SENSOR_FUNCS];
	int			multiplier;

	struct sensor_device_attribute_2	attr[PEX_NUM_SENSOR_FUNCS];
};

struct ibmpex_bmc_data {
	struct list_head	list;
	struct device		*hwmon_dev;
	struct device		*bmc_device;
	struct mutex		lock;
	bool			valid;
	unsigned long		last_updated;	/* In jiffies */

	struct ipmi_addr	address;
	struct completion	read_complete;
	struct ipmi_user	*user;
	int			interface;

	struct kernel_ipmi_msg	tx_message;
	unsigned char		tx_msg_data[IPMI_MAX_MSG_LENGTH];
	long			tx_msgid;

	unsigned char		rx_msg_data[IPMI_MAX_MSG_LENGTH];
	unsigned long		rx_msg_len;
	unsigned char		rx_result;
	int			rx_recv_type;

	unsigned char		sensor_major;
	unsigned char		sensor_minor;

	unsigned char		num_sensors;
	struct ibmpex_sensor_data	*sensors;
};

struct ibmpex_driver_data {
	struct list_head	bmc_data;
	struct ipmi_smi_watcher	bmc_events;
	struct ipmi_user_hndl	ipmi_hndlrs;
};

static struct ibmpex_driver_data driver_data = {
	.bmc_data = LIST_HEAD_INIT(driver_data.bmc_data),
	.bmc_events = {
		.owner = THIS_MODULE,
		.new_smi = ibmpex_register_bmc,
		.smi_gone = ibmpex_bmc_gone,
	},
	.ipmi_hndlrs = {
		.ipmi_recv_hndl = ibmpex_msg_handler,
	},
};

static int ibmpex_send_message(struct ibmpex_bmc_data *data)
{
	int err;

	err = ipmi_validate_addr(&data->address, sizeof(data->address));
	if (err)
		goto out;

	data->tx_msgid++;
	err = ipmi_request_settime(data->user, &data->address, data->tx_msgid,
				   &data->tx_message, data, 0, 0, 0);
	if (err)
		goto out1;

	return 0;
out1:
	dev_err(data->bmc_device, "request_settime=%x\n", err);
	return err;
out:
	dev_err(data->bmc_device, "validate_addr=%x\n", err);
	return err;
}

static int ibmpex_ver_check(struct ibmpex_bmc_data *data)
{
	data->tx_msg_data[0] = PEX_GET_VERSION;
	data->tx_message.data_len = 1;
	ibmpex_send_message(data);

	wait_for_completion(&data->read_complete);

	if (data->rx_result || data->rx_msg_len != 6)
		return -ENOENT;

	data->sensor_major = data->rx_msg_data[0];
	data->sensor_minor = data->rx_msg_data[1];

	dev_info(data->bmc_device,
		 "Found BMC with sensor interface v%d.%d %d-%02d-%02d on interface %d\n",
		 data->sensor_major,
		 data->sensor_minor,
		 extract_value(data->rx_msg_data, 2),
		 data->rx_msg_data[4],
		 data->rx_msg_data[5],
		 data->interface);

	return 0;
}

static int ibmpex_query_sensor_count(struct ibmpex_bmc_data *data)
{
	data->tx_msg_data[0] = PEX_GET_SENSOR_COUNT;
	data->tx_message.data_len = 1;
	ibmpex_send_message(data);

	wait_for_completion(&data->read_complete);

	if (data->rx_result || data->rx_msg_len != 1)
		return -ENOENT;

	return data->rx_msg_data[0];
}

static int ibmpex_query_sensor_name(struct ibmpex_bmc_data *data, int sensor)
{
	data->tx_msg_data[0] = PEX_GET_SENSOR_NAME;
	data->tx_msg_data[1] = sensor;
	data->tx_message.data_len = 2;
	ibmpex_send_message(data);

	wait_for_completion(&data->read_complete);

	if (data->rx_result || data->rx_msg_len < 1)
		return -ENOENT;

	return 0;
}

static int ibmpex_query_sensor_data(struct ibmpex_bmc_data *data, int sensor)
{
	data->tx_msg_data[0] = PEX_GET_SENSOR_DATA;
	data->tx_msg_data[1] = sensor;
	data->tx_message.data_len = 2;
	ibmpex_send_message(data);

	wait_for_completion(&data->read_complete);

	if (data->rx_result || data->rx_msg_len < 26) {
		dev_err(data->bmc_device, "Error reading sensor %d.\n",
			sensor);
		return -ENOENT;
	}

	return 0;
}

static int ibmpex_reset_high_low_data(struct ibmpex_bmc_data *data)
{
	data->tx_msg_data[0] = PEX_RESET_HIGH_LOW;
	data->tx_message.data_len = 1;
	ibmpex_send_message(data);

	wait_for_completion(&data->read_complete);

	return 0;
}

static void ibmpex_update_device(struct ibmpex_bmc_data *data)
{
	int i, err;

	mutex_lock(&data->lock);
	if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) &&
	    data->valid)
		goto out;

	for (i = 0; i < data->num_sensors; i++) {
		if (!data->sensors[i].in_use)
			continue;
		err = ibmpex_query_sensor_data(data, i);
		if (err)
			continue;
		data->sensors[i].values[0] =
			extract_value(data->rx_msg_data, 16);
		data->sensors[i].values[1] =
			extract_value(data->rx_msg_data, 18);
		data->sensors[i].values[2] =
			extract_value(data->rx_msg_data, 20);
	}

	data->last_updated = jiffies;
	data->valid = true;

out:
	mutex_unlock(&data->lock);
}

static struct ibmpex_bmc_data *get_bmc_data(int iface)
{
	struct ibmpex_bmc_data *p, *next;

	list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)
		if (p->interface == iface)
			return p;

	return NULL;
}

static DEVICE_STRING_ATTR_RO(name, 0444, DRVNAME);

static ssize_t ibmpex_show_sensor(struct device *dev,
				  struct device_attribute *devattr,
				  char *buf)
{
	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
	struct ibmpex_bmc_data *data = dev_get_drvdata(dev);
	int mult = data->sensors[attr->index].multiplier;
	ibmpex_update_device(data);

	return sprintf(buf, "%d\n",
		       data->sensors[attr->index].values[attr->nr] * mult);
}

static ssize_t ibmpex_high_low_store(struct device *dev,
				     struct device_attribute *devattr,
				     const char *buf, size_t count)
{
	struct ibmpex_bmc_data *data = dev_get_drvdata(dev);

	ibmpex_reset_high_low_data(data);

	return count;
}

static SENSOR_DEVICE_ATTR_WO(reset_high_low, ibmpex_high_low, 0);

static int is_power_sensor(const char *sensor_id, int len)
{
	if (len < PEX_SENSOR_TYPE_LEN)
		return 0;

	if (!memcmp(sensor_id, power_sensor_sig, PEX_SENSOR_TYPE_LEN))
		return 1;
	return 0;
}

static int is_temp_sensor(const char *sensor_id, int len)
{
	if (len < PEX_SENSOR_TYPE_LEN)
		return 0;

	if (!memcmp(sensor_id, temp_sensor_sig, PEX_SENSOR_TYPE_LEN))
		return 1;
	return 0;
}

static int power_sensor_multiplier(struct ibmpex_bmc_data *data,
				   const char *sensor_id, int len)
{
	int i;

	if (data->sensor_major == 2)
		return 1000000;

	for (i = PEX_SENSOR_TYPE_LEN; i < len - 1; i++)
		if (!memcmp(&sensor_id[i], watt_sensor_sig, PEX_MULT_LEN))
			return 1000000;

	return 100000;
}

static int create_sensor(struct ibmpex_bmc_data *data, int type,
			 int counter, int sensor, int func)
{
	int err;
	char *n;

	n = kmalloc(32, GFP_KERNEL);
	if (!n)
		return -ENOMEM;

	if (type == TEMP_SENSOR)
		sprintf(n, "temp%d_input%s",
			counter, sensor_name_suffixes[func]);
	else if (type == POWER_SENSOR)
		sprintf(n, "power%d_average%s",
			counter, sensor_name_suffixes[func]);

	sysfs_attr_init(&data->sensors[sensor].attr[func].dev_attr.attr);
	data->sensors[sensor].attr[func].dev_attr.attr.name = n;
	data->sensors[sensor].attr[func].dev_attr.attr.mode = 0444;
	data->sensors[sensor].attr[func].dev_attr.show = ibmpex_show_sensor;
	data->sensors[sensor].attr[func].index = sensor;
	data->sensors[sensor].attr[func].nr = func;

	err = device_create_file(data->bmc_device,
				 &data->sensors[sensor].attr[func].dev_attr);
	if (err) {
		data->sensors[sensor].attr[func].dev_attr.attr.name = NULL;
		kfree(n);
		return err;
	}

	return 0;
}

static int ibmpex_find_sensors(struct ibmpex_bmc_data *data)
{
	int i, j, err;
	int sensor_type;
	int sensor_counter;
	int num_power = 0;
	int num_temp = 0;

	err = ibmpex_query_sensor_count(data);
	if (err <= 0)
		return -ENOENT;
	data->num_sensors = err;

	data->sensors = kcalloc(data->num_sensors, sizeof(*data->sensors),
				GFP_KERNEL);
	if (!data->sensors)
		return -ENOMEM;

	for (i = 0; i < data->num_sensors; i++) {
		err = ibmpex_query_sensor_name(data, i);
		if (err)
			continue;

		if (is_power_sensor(data->rx_msg_data, data->rx_msg_len)) {
			sensor_type = POWER_SENSOR;
			num_power++;
			sensor_counter = num_power;
			data->sensors[i].multiplier =
				power_sensor_multiplier(data,
							data->rx_msg_data,
							data->rx_msg_len);
		} else if (is_temp_sensor(data->rx_msg_data,
					  data->rx_msg_len)) {
			sensor_type = TEMP_SENSOR;
			num_temp++;
			sensor_counter = num_temp;
			data->sensors[i].multiplier = 1000;
		} else
			continue;

		data->sensors[i].in_use = 1;

		/* Create attributes */
		for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
			err = create_sensor(data, sensor_type, sensor_counter,
					    i, j);
			if (err)
				goto exit_remove;
		}
	}

	err = device_create_file(data->bmc_device,
			&sensor_dev_attr_reset_high_low.dev_attr);
	if (err)
		goto exit_remove;

	err = device_create_file(data->bmc_device, &dev_attr_name.attr);
	if (err)
		goto exit_remove;

	return 0;

exit_remove:
	device_remove_file(data->bmc_device,
			   &sensor_dev_attr_reset_high_low.dev_attr);
	device_remove_file(data->bmc_device, &dev_attr_name.attr);
	for (i = 0; i < data->num_sensors; i++)
		for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
			if (!data->sensors[i].attr[j].dev_attr.attr.name)
				continue;
			device_remove_file(data->bmc_device,
				&data->sensors[i].attr[j].dev_attr);
			kfree(data->sensors[i].attr[j].dev_attr.attr.name);
		}

	kfree(data->sensors);
	return err;
}

static void ibmpex_register_bmc(int iface, struct device *dev)
{
	struct ibmpex_bmc_data *data;
	int err;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return;

	data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	data->address.channel = IPMI_BMC_CHANNEL;
	data->address.data[0] = 0;
	data->interface = iface;
	data->bmc_device = dev;

	/* Create IPMI messaging interface user */
	err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs,
			       data, &data->user);
	if (err < 0) {
		dev_err(dev,
			"Unable to register user with IPMI interface %d\n",
			data->interface);
		goto out;
	}

	mutex_init(&data->lock);

	/* Initialize message */
	data->tx_msgid = 0;
	init_completion(&data->read_complete);
	data->tx_message.netfn = PEX_NET_FUNCTION;
	data->tx_message.cmd = PEX_COMMAND;
	data->tx_message.data = data->tx_msg_data;

	/* Does this BMC support PowerExecutive? */
	err = ibmpex_ver_check(data);
	if (err)
		goto out_user;

	/* Register the BMC as a HWMON class device */
	data->hwmon_dev = hwmon_device_register(data->bmc_device);

	if (IS_ERR(data->hwmon_dev)) {
		dev_err(data->bmc_device,
			"Unable to register hwmon device for IPMI interface %d\n",
			data->interface);
		goto out_user;
	}

	/* finally add the new bmc data to the bmc data list */
	dev_set_drvdata(dev, data);
	list_add_tail(&data->list, &driver_data.bmc_data);

	/* Now go find all the sensors */
	err = ibmpex_find_sensors(data);
	if (err) {
		dev_err(data->bmc_device, "Error %d finding sensors\n", err);
		goto out_register;
	}

	return;

out_register:
	list_del(&data->list);
	hwmon_device_unregister(data->hwmon_dev);
out_user:
	ipmi_destroy_user(data->user);
out:
	kfree(data);
}

static void ibmpex_bmc_delete(struct ibmpex_bmc_data *data)
{
	int i, j;

	device_remove_file(data->bmc_device,
			   &sensor_dev_attr_reset_high_low.dev_attr);
	device_remove_file(data->bmc_device, &dev_attr_name.attr);
	for (i = 0; i < data->num_sensors; i++)
		for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
			if (!data->sensors[i].attr[j].dev_attr.attr.name)
				continue;
			device_remove_file(data->bmc_device,
				&data->sensors[i].attr[j].dev_attr);
			kfree(data->sensors[i].attr[j].dev_attr.attr.name);
		}

	list_del(&data->list);
	dev_set_drvdata(data->bmc_device, NULL);
	hwmon_device_unregister(data->hwmon_dev);
	ipmi_destroy_user(data->user);
	kfree(data->sensors);
	kfree(data);
}

static void ibmpex_bmc_gone(int iface)
{
	struct ibmpex_bmc_data *data = get_bmc_data(iface);

	if (!data)
		return;

	ibmpex_bmc_delete(data);
}

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data)
{
	struct ibmpex_bmc_data *data = user_msg_data;

	if (msg->msgid != data->tx_msgid) {
		dev_err(data->bmc_device,
			"Mismatch between received msgid (%02x) and transmitted msgid (%02x)!\n",
			(int)msg->msgid,
			(int)data->tx_msgid);
		ipmi_free_recv_msg(msg);
		return;
	}

	data->rx_recv_type = msg->recv_type;
	if (msg->msg.data_len > 0)
		data->rx_result = msg->msg.data[0];
	else
		data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE;

	if (msg->msg.data_len > 1) {
		data->rx_msg_len = msg->msg.data_len - 1;
		memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len);
	} else
		data->rx_msg_len = 0;

	ipmi_free_recv_msg(msg);
	complete(&data->read_complete);
}

static int __init ibmpex_init(void)
{
	return ipmi_smi_watcher_register(&driver_data.bmc_events);
}

static void __exit ibmpex_exit(void)
{
	struct ibmpex_bmc_data *p, *next;

	ipmi_smi_watcher_unregister(&driver_data.bmc_events);
	list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)
		ibmpex_bmc_delete(p);
}

MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
MODULE_DESCRIPTION("IBM PowerExecutive power/temperature sensor driver");
MODULE_LICENSE("GPL");

module_init(ibmpex_init);
module_exit(ibmpex_exit);

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");
MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");
MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");
MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");
MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
57c7c3a0 DW	2	/*
	3	* A hwmon driver for the IBM PowerExecutive temperature/power sensors
	4	* Copyright (C) 2007 IBM
	5	*
5407e051	6	* Author: Darrick J. Wong <darrick.wong@oracle.com>
57c7c3a0 DW	7	*/
	8
	9	#include <linux/ipmi.h>
	10	#include <linux/module.h>
	11	#include <linux/hwmon.h>
	12	#include <linux/hwmon-sysfs.h>
	13	#include <linux/jiffies.h>
	14	#include <linux/mutex.h>
5a0e3ad6	15	#include <linux/slab.h>
fa845740	16	#include <linux/err.h>
57c7c3a0 DW	17
	18	#define REFRESH_INTERVAL (2 * HZ)
	19	#define DRVNAME "ibmpex"
	20
	21	#define PEX_GET_VERSION 1
	22	#define PEX_GET_SENSOR_COUNT 2
	23	#define PEX_GET_SENSOR_NAME 3
	24	#define PEX_RESET_HIGH_LOW 4
	25	#define PEX_GET_SENSOR_DATA 6
	26
	27	#define PEX_NET_FUNCTION 0x3A
	28	#define PEX_COMMAND 0x3C
	29
	30	static inline u16 extract_value(const char *data, int offset)
	31	{
29041b4b	32	return be16_to_cpup((__be16 *)&data[offset]);
57c7c3a0 DW	33	}
	34
	35	#define TEMP_SENSOR 1
	36	#define POWER_SENSOR 2
	37
	38	#define PEX_SENSOR_TYPE_LEN 3
	39	static u8 const power_sensor_sig[] = {0x70, 0x77, 0x72};
	40	static u8 const temp_sensor_sig[] = {0x74, 0x65, 0x6D};
	41
	42	#define PEX_MULT_LEN 2
	43	static u8 const watt_sensor_sig[] = {0x41, 0x43};
	44
	45	#define PEX_NUM_SENSOR_FUNCS 3
a0fc74d4 RV	46	static const char * const sensor_name_suffixes[] = {
	47	"",
	48	"_lowest",
	49	"_highest"
57c7c3a0 DW	50	};
	51
	52	static void ibmpex_msg_handler(struct ipmi_recv_msg msg, void user_msg_data);
	53	static void ibmpex_register_bmc(int iface, struct device *dev);
	54	static void ibmpex_bmc_gone(int iface);
	55
	56	struct ibmpex_sensor_data {
	57	int in_use;
	58	s16 values[PEX_NUM_SENSOR_FUNCS];
	59	int multiplier;
	60
	61	struct sensor_device_attribute_2 attr[PEX_NUM_SENSOR_FUNCS];
	62	};
	63
	64	struct ibmpex_bmc_data {
	65	struct list_head list;
	66	struct device *hwmon_dev;
	67	struct device *bmc_device;
	68	struct mutex lock;
952a11ca	69	bool valid;
57c7c3a0 DW	70	unsigned long last_updated; /* In jiffies */
	71
	72	struct ipmi_addr address;
	73	struct completion read_complete;
3f901c86	74	struct ipmi_user *user;
57c7c3a0 DW	75	int interface;
	76
	77	struct kernel_ipmi_msg tx_message;
	78	unsigned char tx_msg_data[IPMI_MAX_MSG_LENGTH];
	79	long tx_msgid;
	80
	81	unsigned char rx_msg_data[IPMI_MAX_MSG_LENGTH];
	82	unsigned long rx_msg_len;
	83	unsigned char rx_result;
	84	int rx_recv_type;
	85
	86	unsigned char sensor_major;
	87	unsigned char sensor_minor;
	88
	89	unsigned char num_sensors;
	90	struct ibmpex_sensor_data *sensors;
	91	};
	92
	93	struct ibmpex_driver_data {
	94	struct list_head bmc_data;
	95	struct ipmi_smi_watcher bmc_events;
	96	struct ipmi_user_hndl ipmi_hndlrs;
	97	};
	98
	99	static struct ibmpex_driver_data driver_data = {
	100	.bmc_data = LIST_HEAD_INIT(driver_data.bmc_data),
	101	.bmc_events = {
	102	.owner = THIS_MODULE,
	103	.new_smi = ibmpex_register_bmc,
	104	.smi_gone = ibmpex_bmc_gone,
	105	},
	106	.ipmi_hndlrs = {
	107	.ipmi_recv_hndl = ibmpex_msg_handler,
	108	},
	109	};
	110
	111	static int ibmpex_send_message(struct ibmpex_bmc_data *data)
	112	{
	113	int err;
	114
	115	err = ipmi_validate_addr(&data->address, sizeof(data->address));
	116	if (err)
	117	goto out;
	118
	119	data->tx_msgid++;
	120	err = ipmi_request_settime(data->user, &data->address, data->tx_msgid,
	121	&data->tx_message, data, 0, 0, 0);
	122	if (err)
	123	goto out1;
	124
	125	return 0;
	126	out1:
2ecb044e	127	dev_err(data->bmc_device, "request_settime=%x\n", err);
57c7c3a0 DW	128	return err;
57c7c3a0 DW	129	out:
2ecb044e	130	dev_err(data->bmc_device, "validate_addr=%x\n", err);
57c7c3a0 DW	131	return err;
	132	}
	133
	134	static int ibmpex_ver_check(struct ibmpex_bmc_data *data)
	135	{
	136	data->tx_msg_data[0] = PEX_GET_VERSION;
	137	data->tx_message.data_len = 1;
	138	ibmpex_send_message(data);
	139
	140	wait_for_completion(&data->read_complete);
	141
	142	if (data->rx_result \|\| data->rx_msg_len != 6)
	143	return -ENOENT;
	144
	145	data->sensor_major = data->rx_msg_data[0];
	146	data->sensor_minor = data->rx_msg_data[1];
	147
b55f3757 GR	148	dev_info(data->bmc_device,
b55f3757 GR	149	"Found BMC with sensor interface v%d.%d %d-%02d-%02d on interface %d\n",
2ecb044e DW	150	data->sensor_major,
	151	data->sensor_minor,
	152	extract_value(data->rx_msg_data, 2),
	153	data->rx_msg_data[4],
	154	data->rx_msg_data[5],
	155	data->interface);
57c7c3a0 DW	156
	157	return 0;
	158	}
	159
	160	static int ibmpex_query_sensor_count(struct ibmpex_bmc_data *data)
	161	{
	162	data->tx_msg_data[0] = PEX_GET_SENSOR_COUNT;
	163	data->tx_message.data_len = 1;
	164	ibmpex_send_message(data);
	165
	166	wait_for_completion(&data->read_complete);
	167
	168	if (data->rx_result \|\| data->rx_msg_len != 1)
	169	return -ENOENT;
	170
	171	return data->rx_msg_data[0];
	172	}
	173
	174	static int ibmpex_query_sensor_name(struct ibmpex_bmc_data *data, int sensor)
	175	{
	176	data->tx_msg_data[0] = PEX_GET_SENSOR_NAME;
	177	data->tx_msg_data[1] = sensor;
	178	data->tx_message.data_len = 2;
	179	ibmpex_send_message(data);
	180
	181	wait_for_completion(&data->read_complete);
	182
	183	if (data->rx_result \|\| data->rx_msg_len < 1)
	184	return -ENOENT;
	185
	186	return 0;
	187	}
	188
	189	static int ibmpex_query_sensor_data(struct ibmpex_bmc_data *data, int sensor)
	190	{
	191	data->tx_msg_data[0] = PEX_GET_SENSOR_DATA;
	192	data->tx_msg_data[1] = sensor;
	193	data->tx_message.data_len = 2;
	194	ibmpex_send_message(data);
	195
	196	wait_for_completion(&data->read_complete);
	197
	198	if (data->rx_result \|\| data->rx_msg_len < 26) {
2ecb044e DW	199	dev_err(data->bmc_device, "Error reading sensor %d.\n",
2ecb044e DW	200	sensor);
57c7c3a0 DW	201	return -ENOENT;
	202	}
	203
	204	return 0;
	205	}
	206
	207	static int ibmpex_reset_high_low_data(struct ibmpex_bmc_data *data)
	208	{
	209	data->tx_msg_data[0] = PEX_RESET_HIGH_LOW;
	210	data->tx_message.data_len = 1;
	211	ibmpex_send_message(data);
	212
	213	wait_for_completion(&data->read_complete);
	214
	215	return 0;
	216	}
	217
	218	static void ibmpex_update_device(struct ibmpex_bmc_data *data)
	219	{
	220	int i, err;
	221
	222	mutex_lock(&data->lock);
	223	if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) &&
	224	data->valid)
	225	goto out;
	226
	227	for (i = 0; i < data->num_sensors; i++) {
	228	if (!data->sensors[i].in_use)
	229	continue;
	230	err = ibmpex_query_sensor_data(data, i);
	231	if (err)
	232	continue;
	233	data->sensors[i].values[0] =
	234	extract_value(data->rx_msg_data, 16);
	235	data->sensors[i].values[1] =
	236	extract_value(data->rx_msg_data, 18);
	237	data->sensors[i].values[2] =
	238	extract_value(data->rx_msg_data, 20);
	239	}
	240
	241	data->last_updated = jiffies;
952a11ca	242	data->valid = true;
57c7c3a0 DW	243
	244	out:
	245	mutex_unlock(&data->lock);
	246	}
	247
	248	static struct ibmpex_bmc_data *get_bmc_data(int iface)
	249	{
	250	struct ibmpex_bmc_data p, next;
	251
	252	list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)
	253	if (p->interface == iface)
	254	return p;
	255
	256	return NULL;
	257	}
	258
aa1fd9cd	259	static DEVICE_STRING_ATTR_RO(name, 0444, DRVNAME);
57c7c3a0 DW	260
	261	static ssize_t ibmpex_show_sensor(struct device *dev,
	262	struct device_attribute *devattr,
	263	char *buf)
	264	{
	265	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
	266	struct ibmpex_bmc_data *data = dev_get_drvdata(dev);
	267	int mult = data->sensors[attr->index].multiplier;
	268	ibmpex_update_device(data);
	269
	270	return sprintf(buf, "%d\n",
	271	data->sensors[attr->index].values[attr->nr] * mult);
	272	}
	273
09cb4161	274	static ssize_t ibmpex_high_low_store(struct device *dev,
57c7c3a0	275	struct device_attribute *devattr,
09cb4161	276	const char *buf, size_t count)
57c7c3a0 DW	277	{
	278	struct ibmpex_bmc_data *data = dev_get_drvdata(dev);
	279
	280	ibmpex_reset_high_low_data(data);
	281
	282	return count;
	283	}
	284
09cb4161	285	static SENSOR_DEVICE_ATTR_WO(reset_high_low, ibmpex_high_low, 0);
57c7c3a0 DW	286
	287	static int is_power_sensor(const char *sensor_id, int len)
	288	{
	289	if (len < PEX_SENSOR_TYPE_LEN)
	290	return 0;
	291
	292	if (!memcmp(sensor_id, power_sensor_sig, PEX_SENSOR_TYPE_LEN))
	293	return 1;
	294	return 0;
	295	}
	296
	297	static int is_temp_sensor(const char *sensor_id, int len)
	298	{
	299	if (len < PEX_SENSOR_TYPE_LEN)
	300	return 0;
	301
	302	if (!memcmp(sensor_id, temp_sensor_sig, PEX_SENSOR_TYPE_LEN))
	303	return 1;
	304	return 0;
	305	}
	306
df9cb033 DW	307	static int power_sensor_multiplier(struct ibmpex_bmc_data *data,
df9cb033 DW	308	const char *sensor_id, int len)
57c7c3a0 DW	309	{
	310	int i;
	311
df9cb033 DW	312	if (data->sensor_major == 2)
	313	return 1000000;
	314
57c7c3a0 DW	315	for (i = PEX_SENSOR_TYPE_LEN; i < len - 1; i++)
	316	if (!memcmp(&sensor_id[i], watt_sensor_sig, PEX_MULT_LEN))
	317	return 1000000;
	318
	319	return 100000;
	320	}
	321
	322	static int create_sensor(struct ibmpex_bmc_data *data, int type,
	323	int counter, int sensor, int func)
	324	{
	325	int err;
	326	char *n;
	327
	328	n = kmalloc(32, GFP_KERNEL);
	329	if (!n)
	330	return -ENOMEM;
	331
	332	if (type == TEMP_SENSOR)
a0fc74d4 RV	333	sprintf(n, "temp%d_input%s",
a0fc74d4 RV	334	counter, sensor_name_suffixes[func]);
57c7c3a0	335	else if (type == POWER_SENSOR)
a0fc74d4 RV	336	sprintf(n, "power%d_average%s",
a0fc74d4 RV	337	counter, sensor_name_suffixes[func]);
57c7c3a0	338
fb794e0f	339	sysfs_attr_init(&data->sensors[sensor].attr[func].dev_attr.attr);
57c7c3a0	340	data->sensors[sensor].attr[func].dev_attr.attr.name = n;
09cb4161	341	data->sensors[sensor].attr[func].dev_attr.attr.mode = 0444;
57c7c3a0 DW	342	data->sensors[sensor].attr[func].dev_attr.show = ibmpex_show_sensor;
	343	data->sensors[sensor].attr[func].index = sensor;
	344	data->sensors[sensor].attr[func].nr = func;
	345
	346	err = device_create_file(data->bmc_device,
	347	&data->sensors[sensor].attr[func].dev_attr);
	348	if (err) {
	349	data->sensors[sensor].attr[func].dev_attr.attr.name = NULL;
	350	kfree(n);
	351	return err;
	352	}
	353
	354	return 0;
	355	}
	356
	357	static int ibmpex_find_sensors(struct ibmpex_bmc_data *data)
	358	{
	359	int i, j, err;
	360	int sensor_type;
	361	int sensor_counter;
	362	int num_power = 0;
	363	int num_temp = 0;
	364
	365	err = ibmpex_query_sensor_count(data);
	366	if (err <= 0)
	367	return -ENOENT;
	368	data->num_sensors = err;
	369
6396bb22	370	data->sensors = kcalloc(data->num_sensors, sizeof(*data->sensors),
57c7c3a0 DW	371	GFP_KERNEL);
	372	if (!data->sensors)
	373	return -ENOMEM;
	374
	375	for (i = 0; i < data->num_sensors; i++) {
	376	err = ibmpex_query_sensor_name(data, i);
	377	if (err)
	378	continue;
	379
	380	if (is_power_sensor(data->rx_msg_data, data->rx_msg_len)) {
	381	sensor_type = POWER_SENSOR;
	382	num_power++;
	383	sensor_counter = num_power;
	384	data->sensors[i].multiplier =
df9cb033 DW	385	power_sensor_multiplier(data,
	386	data->rx_msg_data,
	387	data->rx_msg_len);
57c7c3a0 DW	388	} else if (is_temp_sensor(data->rx_msg_data,
	389	data->rx_msg_len)) {
	390	sensor_type = TEMP_SENSOR;
	391	num_temp++;
	392	sensor_counter = num_temp;
ffda6857	393	data->sensors[i].multiplier = 1000;
57c7c3a0 DW	394	} else
	395	continue;
	396
	397	data->sensors[i].in_use = 1;
	398
	399	/* Create attributes */
	400	for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
	401	err = create_sensor(data, sensor_type, sensor_counter,
	402	i, j);
	403	if (err)
	404	goto exit_remove;
	405	}
	406	}
	407
	408	err = device_create_file(data->bmc_device,
	409	&sensor_dev_attr_reset_high_low.dev_attr);
	410	if (err)
	411	goto exit_remove;
	412
aa1fd9cd	413	err = device_create_file(data->bmc_device, &dev_attr_name.attr);
57c7c3a0 DW	414	if (err)
	415	goto exit_remove;
	416
	417	return 0;
	418
	419	exit_remove:
	420	device_remove_file(data->bmc_device,
	421	&sensor_dev_attr_reset_high_low.dev_attr);
aa1fd9cd	422	device_remove_file(data->bmc_device, &dev_attr_name.attr);
57c7c3a0 DW	423	for (i = 0; i < data->num_sensors; i++)
	424	for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
	425	if (!data->sensors[i].attr[j].dev_attr.attr.name)
	426	continue;
	427	device_remove_file(data->bmc_device,
	428	&data->sensors[i].attr[j].dev_attr);
	429	kfree(data->sensors[i].attr[j].dev_attr.attr.name);
	430	}
	431
	432	kfree(data->sensors);
	433	return err;
	434	}
	435
	436	static void ibmpex_register_bmc(int iface, struct device *dev)
	437	{
	438	struct ibmpex_bmc_data *data;
	439	int err;
	440
	441	data = kzalloc(sizeof(*data), GFP_KERNEL);
6d33d304	442	if (!data)
57c7c3a0	443	return;
57c7c3a0 DW	444
	445	data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	446	data->address.channel = IPMI_BMC_CHANNEL;
	447	data->address.data[0] = 0;
	448	data->interface = iface;
	449	data->bmc_device = dev;
	450
	451	/* Create IPMI messaging interface user */
	452	err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs,
	453	data, &data->user);
	454	if (err < 0) {
b55f3757 GR	455	dev_err(dev,
	456	"Unable to register user with IPMI interface %d\n",
	457	data->interface);
57c7c3a0 DW	458	goto out;
	459	}
	460
	461	mutex_init(&data->lock);
	462
	463	/* Initialize message */
	464	data->tx_msgid = 0;
	465	init_completion(&data->read_complete);
	466	data->tx_message.netfn = PEX_NET_FUNCTION;
	467	data->tx_message.cmd = PEX_COMMAND;
	468	data->tx_message.data = data->tx_msg_data;
	469
	470	/* Does this BMC support PowerExecutive? */
	471	err = ibmpex_ver_check(data);
	472	if (err)
	473	goto out_user;
	474
	475	/* Register the BMC as a HWMON class device */
	476	data->hwmon_dev = hwmon_device_register(data->bmc_device);
	477
	478	if (IS_ERR(data->hwmon_dev)) {
b55f3757 GR	479	dev_err(data->bmc_device,
b55f3757 GR	480	"Unable to register hwmon device for IPMI interface %d\n",
2ecb044e	481	data->interface);
4cfdbe7f	482	goto out_user;
57c7c3a0 DW	483	}
	484
	485	/* finally add the new bmc data to the bmc data list */
	486	dev_set_drvdata(dev, data);
	487	list_add_tail(&data->list, &driver_data.bmc_data);
	488
	489	/* Now go find all the sensors */
	490	err = ibmpex_find_sensors(data);
	491	if (err) {
2ecb044e	492	dev_err(data->bmc_device, "Error %d finding sensors\n", err);
57c7c3a0 DW	493	goto out_register;
	494	}
	495
	496	return;
	497
	498	out_register:
e2a87785	499	list_del(&data->list);
57c7c3a0 DW	500	hwmon_device_unregister(data->hwmon_dev);
	501	out_user:
	502	ipmi_destroy_user(data->user);
	503	out:
	504	kfree(data);
	505	}
	506
	507	static void ibmpex_bmc_delete(struct ibmpex_bmc_data *data)
	508	{
	509	int i, j;
	510
	511	device_remove_file(data->bmc_device,
	512	&sensor_dev_attr_reset_high_low.dev_attr);
aa1fd9cd	513	device_remove_file(data->bmc_device, &dev_attr_name.attr);
57c7c3a0 DW	514	for (i = 0; i < data->num_sensors; i++)
	515	for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {
	516	if (!data->sensors[i].attr[j].dev_attr.attr.name)
	517	continue;
	518	device_remove_file(data->bmc_device,
	519	&data->sensors[i].attr[j].dev_attr);
	520	kfree(data->sensors[i].attr[j].dev_attr.attr.name);
	521	}
	522
	523	list_del(&data->list);
	524	dev_set_drvdata(data->bmc_device, NULL);
	525	hwmon_device_unregister(data->hwmon_dev);
	526	ipmi_destroy_user(data->user);
	527	kfree(data->sensors);
	528	kfree(data);
	529	}
	530
	531	static void ibmpex_bmc_gone(int iface)
	532	{
	533	struct ibmpex_bmc_data *data = get_bmc_data(iface);
	534
	535	if (!data)
	536	return;
	537
	538	ibmpex_bmc_delete(data);
	539	}
	540
	541	static void ibmpex_msg_handler(struct ipmi_recv_msg msg, void user_msg_data)
	542	{
554df454	543	struct ibmpex_bmc_data *data = user_msg_data;
57c7c3a0 DW	544
57c7c3a0 DW	545	if (msg->msgid != data->tx_msgid) {
b55f3757 GR	546	dev_err(data->bmc_device,
b55f3757 GR	547	"Mismatch between received msgid (%02x) and transmitted msgid (%02x)!\n",
2ecb044e DW	548	(int)msg->msgid,
2ecb044e DW	549	(int)data->tx_msgid);
57c7c3a0 DW	550	ipmi_free_recv_msg(msg);
	551	return;
	552	}
	553
	554	data->rx_recv_type = msg->recv_type;
	555	if (msg->msg.data_len > 0)
	556	data->rx_result = msg->msg.data[0];
	557	else
	558	data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE;
	559
	560	if (msg->msg.data_len > 1) {
	561	data->rx_msg_len = msg->msg.data_len - 1;
	562	memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len);
	563	} else
	564	data->rx_msg_len = 0;
	565
	566	ipmi_free_recv_msg(msg);
	567	complete(&data->read_complete);
	568	}
	569
	570	static int __init ibmpex_init(void)
	571	{
	572	return ipmi_smi_watcher_register(&driver_data.bmc_events);
	573	}
	574
	575	static void __exit ibmpex_exit(void)
	576	{
	577	struct ibmpex_bmc_data p, next;
	578
	579	ipmi_smi_watcher_unregister(&driver_data.bmc_events);
	580	list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)
	581	ibmpex_bmc_delete(p);
	582	}
	583
5407e051	584	MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
57c7c3a0 DW	585	MODULE_DESCRIPTION("IBM PowerExecutive power/temperature sensor driver");
	586	MODULE_LICENSE("GPL");
	587
	588	module_init(ibmpex_init);
	589	module_exit(ibmpex_exit);
ff921361 DW	590
	591	MODULE_ALIAS("dmi:bvnIBM::pnIBMSystemx3350-");
	592	MODULE_ALIAS("dmi:bvnIBM::pnIBMSystemx3550-");
	593	MODULE_ALIAS("dmi:bvnIBM::pnIBMSystemx3650-");
	594	MODULE_ALIAS("dmi:bvnIBM::pnIBMSystemx3655-");
	595	MODULE_ALIAS("dmi:bvnIBM::pnIBMSystemx3755-");