Commit c10e753d authored by Eddie James's avatar Eddie James Committed by Guenter Roeck
Browse files

hwmon (occ): Add sensor types and versions 



Add structures to define all sensor types and versions. Add sysfs show
and store functions for each sensor type. Add a method to construct the
"set user power cap" command and send it to the OCC. Add rate limit to
polling the OCC (in case user-space reads our hwmon entries rapidly).

Signed-off-by: default avatarEddie James <eajames@linux.ibm.com>
Signed-off-by: default avatarGuenter Roeck <linux@roeck-us.net>
parent aa195fe4

drivers/hwmon/occ/common.c

+621 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <linux/device.h>

#include <linux/hwmon-sysfs.h>

#include <linux/jiffies.h>

#include <linux/kernel.h>

#include <linux/math64.h>

#include <linux/mutex.h>

#include <asm/unaligned.h>



#include "common.h"



#define EXTN_FLAG_SENSOR_ID		BIT(7)



#define OCC_UPDATE_FREQUENCY		msecs_to_jiffies(1000)



#define OCC_TEMP_SENSOR_FAULT		0xFF



#define OCC_FRU_TYPE_VRM		3



/* OCC sensor type and version definitions */



struct temp_sensor_1 {

	u16 sensor_id;

	u16 value;

} __packed;



struct temp_sensor_2 {

	u32 sensor_id;

	u8 fru_type;

	u8 value;

} __packed;



struct freq_sensor_1 {

	u16 sensor_id;

	u16 value;

} __packed;



struct freq_sensor_2 {

	u32 sensor_id;

	u16 value;

} __packed;



struct power_sensor_1 {

	u16 sensor_id;

	u32 update_tag;

	u32 accumulator;

	u16 value;

} __packed;



struct power_sensor_2 {

	u32 sensor_id;

	u8 function_id;

	u8 apss_channel;

	u16 reserved;

	u32 update_tag;

	u64 accumulator;

	u16 value;

} __packed;



struct power_sensor_data {

	u16 value;

	u32 update_tag;

	u64 accumulator;

} __packed;



struct power_sensor_data_and_time {

	u16 update_time;

	u16 value;

	u32 update_tag;

	u64 accumulator;

} __packed;



struct power_sensor_a0 {

	u32 sensor_id;

	struct power_sensor_data_and_time system;

	u32 reserved;

	struct power_sensor_data_and_time proc;

	struct power_sensor_data vdd;

	struct power_sensor_data vdn;

} __packed;



struct caps_sensor_2 {

	u16 cap;

	u16 system_power;

	u16 n_cap;

	u16 max;

	u16 min;

	u16 user;

	u8 user_source;

} __packed;



struct caps_sensor_3 {

	u16 cap;

	u16 system_power;

	u16 n_cap;

	u16 max;

	u16 hard_min;

	u16 soft_min;

	u16 user;

	u8 user_source;

} __packed;



struct extended_sensor {

	union {

		u8 name[4];

		u32 sensor_id;

	};

	u8 flags;

	u8 reserved;

	u8 data[6];

} __packed;



static int occ_poll(struct occ *occ)

{

	u16 checksum = occ->poll_cmd_data + 1;
@@ -20,9 +126,521 @@ static int occ_poll(struct occ *occ) 
	cmd[6] = checksum & 0xFF;	/* checksum lsb */

	cmd[7] = 0;



	/* mutex should already be locked if necessary */

	return occ->send_cmd(occ, cmd);

}



static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap)

{

	int rc;

	u8 cmd[8];

	u16 checksum = 0x24;

	__be16 user_power_cap_be = cpu_to_be16(user_power_cap);



	cmd[0] = 0;

	cmd[1] = 0x22;

	cmd[2] = 0;

	cmd[3] = 2;



	memcpy(&cmd[4], &user_power_cap_be, 2);



	checksum += cmd[4] + cmd[5];

	cmd[6] = checksum >> 8;

	cmd[7] = checksum & 0xFF;



	rc = mutex_lock_interruptible(&occ->lock);

	if (rc)

		return rc;



	rc = occ->send_cmd(occ, cmd);



	mutex_unlock(&occ->lock);



	return rc;

}



static int occ_update_response(struct occ *occ)

{

	int rc = mutex_lock_interruptible(&occ->lock);



	if (rc)

		return rc;



	/* limit the maximum rate of polling the OCC */

	if (time_after(jiffies, occ->last_update + OCC_UPDATE_FREQUENCY)) {

		rc = occ_poll(occ);

		occ->last_update = jiffies;

	}



	mutex_unlock(&occ->lock);

	return rc;

}



static ssize_t occ_show_temp_1(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	int rc;

	u32 val = 0;

	struct temp_sensor_1 *temp;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		val = get_unaligned_be16(&temp->sensor_id);

		break;

	case 1:

		val = get_unaligned_be16(&temp->value) * 1000;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%u\n", val);

}



static ssize_t occ_show_temp_2(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	int rc;

	u32 val = 0;

	struct temp_sensor_2 *temp;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		val = get_unaligned_be32(&temp->sensor_id);

		break;

	case 1:

		val = temp->value;

		if (val == OCC_TEMP_SENSOR_FAULT)

			return -EREMOTEIO;



		/*

		 * VRM doesn't return temperature, only alarm bit. This

		 * attribute maps to tempX_alarm instead of tempX_input for

		 * VRM

		 */

		if (temp->fru_type != OCC_FRU_TYPE_VRM) {

			/* sensor not ready */

			if (val == 0)

				return -EAGAIN;



			val *= 1000;

		}

		break;

	case 2:

		val = temp->fru_type;

		break;

	case 3:

		val = temp->value == OCC_TEMP_SENSOR_FAULT;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%u\n", val);

}



static ssize_t occ_show_freq_1(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	int rc;

	u16 val = 0;

	struct freq_sensor_1 *freq;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		val = get_unaligned_be16(&freq->sensor_id);

		break;

	case 1:

		val = get_unaligned_be16(&freq->value);

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%u\n", val);

}



static ssize_t occ_show_freq_2(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	int rc;

	u32 val = 0;

	struct freq_sensor_2 *freq;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		val = get_unaligned_be32(&freq->sensor_id);

		break;

	case 1:

		val = get_unaligned_be16(&freq->value);

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%u\n", val);

}



static ssize_t occ_show_power_1(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	int rc;

	u64 val = 0;

	struct power_sensor_1 *power;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		val = get_unaligned_be16(&power->sensor_id);

		break;

	case 1:

		val = get_unaligned_be32(&power->accumulator) /

			get_unaligned_be32(&power->update_tag);

		val *= 1000000ULL;

		break;

	case 2:

		val = get_unaligned_be32(&power->update_tag) *

			occ->powr_sample_time_us;

		break;

	case 3:

		val = get_unaligned_be16(&power->value) * 1000000ULL;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%llu\n", val);

}



static u64 occ_get_powr_avg(u64 *accum, u32 *samples)

{

	return div64_u64(get_unaligned_be64(accum) * 1000000ULL,

			 get_unaligned_be32(samples));

}



static ssize_t occ_show_power_2(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	int rc;

	u64 val = 0;

	struct power_sensor_2 *power;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		return snprintf(buf, PAGE_SIZE - 1, "%u_%u_%u\n",

				get_unaligned_be32(&power->sensor_id),

				power->function_id, power->apss_channel);

	case 1:

		val = occ_get_powr_avg(&power->accumulator,

				       &power->update_tag);

		break;

	case 2:

		val = get_unaligned_be32(&power->update_tag) *

			occ->powr_sample_time_us;

		break;

	case 3:

		val = get_unaligned_be16(&power->value) * 1000000ULL;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%llu\n", val);

}



static ssize_t occ_show_power_a0(struct device *dev,

				 struct device_attribute *attr, char *buf)

{

	int rc;

	u64 val = 0;

	struct power_sensor_a0 *power;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		return snprintf(buf, PAGE_SIZE - 1, "%u_system\n",

				get_unaligned_be32(&power->sensor_id));

	case 1:

		val = occ_get_powr_avg(&power->system.accumulator,

				       &power->system.update_tag);

		break;

	case 2:

		val = get_unaligned_be32(&power->system.update_tag) *

			occ->powr_sample_time_us;

		break;

	case 3:

		val = get_unaligned_be16(&power->system.value) * 1000000ULL;

		break;

	case 4:

		return snprintf(buf, PAGE_SIZE - 1, "%u_proc\n",

				get_unaligned_be32(&power->sensor_id));

	case 5:

		val = occ_get_powr_avg(&power->proc.accumulator,

				       &power->proc.update_tag);

		break;

	case 6:

		val = get_unaligned_be32(&power->proc.update_tag) *

			occ->powr_sample_time_us;

		break;

	case 7:

		val = get_unaligned_be16(&power->proc.value) * 1000000ULL;

		break;

	case 8:

		return snprintf(buf, PAGE_SIZE - 1, "%u_vdd\n",

				get_unaligned_be32(&power->sensor_id));

	case 9:

		val = occ_get_powr_avg(&power->vdd.accumulator,

				       &power->vdd.update_tag);

		break;

	case 10:

		val = get_unaligned_be32(&power->vdd.update_tag) *

			occ->powr_sample_time_us;

		break;

	case 11:

		val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;

		break;

	case 12:

		return snprintf(buf, PAGE_SIZE - 1, "%u_vdn\n",

				get_unaligned_be32(&power->sensor_id));

	case 13:

		val = occ_get_powr_avg(&power->vdn.accumulator,

				       &power->vdn.update_tag);

		break;

	case 14:

		val = get_unaligned_be32(&power->vdn.update_tag) *

			occ->powr_sample_time_us;

		break;

	case 15:

		val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%llu\n", val);

}



static ssize_t occ_show_caps_1_2(struct device *dev,

				 struct device_attribute *attr, char *buf)

{

	int rc;

	u64 val = 0;

	struct caps_sensor_2 *caps;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		return snprintf(buf, PAGE_SIZE - 1, "system\n");

	case 1:

		val = get_unaligned_be16(&caps->cap) * 1000000ULL;

		break;

	case 2:

		val = get_unaligned_be16(&caps->system_power) * 1000000ULL;

		break;

	case 3:

		val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;

		break;

	case 4:

		val = get_unaligned_be16(&caps->max) * 1000000ULL;

		break;

	case 5:

		val = get_unaligned_be16(&caps->min) * 1000000ULL;

		break;

	case 6:

		val = get_unaligned_be16(&caps->user) * 1000000ULL;

		break;

	case 7:

		if (occ->sensors.caps.version == 1)

			return -EINVAL;



		val = caps->user_source;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%llu\n", val);

}



static ssize_t occ_show_caps_3(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	int rc;

	u64 val = 0;

	struct caps_sensor_3 *caps;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;



	switch (sattr->nr) {

	case 0:

		return snprintf(buf, PAGE_SIZE - 1, "system\n");

	case 1:

		val = get_unaligned_be16(&caps->cap) * 1000000ULL;

		break;

	case 2:

		val = get_unaligned_be16(&caps->system_power) * 1000000ULL;

		break;

	case 3:

		val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;

		break;

	case 4:

		val = get_unaligned_be16(&caps->max) * 1000000ULL;

		break;

	case 5:

		val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;

		break;

	case 6:

		val = get_unaligned_be16(&caps->user) * 1000000ULL;

		break;

	case 7:

		val = caps->user_source;

		break;

	default:

		return -EINVAL;

	}



	return snprintf(buf, PAGE_SIZE - 1, "%llu\n", val);

}



static ssize_t occ_store_caps_user(struct device *dev,

				   struct device_attribute *attr,

				   const char *buf, size_t count)

{

	int rc;

	u16 user_power_cap;

	unsigned long long value;

	struct occ *occ = dev_get_drvdata(dev);



	rc = kstrtoull(buf, 0, &value);

	if (rc)

		return rc;



	user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */



	rc = occ_set_user_power_cap(occ, user_power_cap);

	if (rc)

		return rc;



	return count;

}



static ssize_t occ_show_extended(struct device *dev,

				 struct device_attribute *attr, char *buf)

{

	int rc;

	struct extended_sensor *extn;

	struct occ *occ = dev_get_drvdata(dev);

	struct occ_sensors *sensors = &occ->sensors;

	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);



	rc = occ_update_response(occ);

	if (rc)

		return rc;



	extn = ((struct extended_sensor *)sensors->extended.data) +

		sattr->index;



	switch (sattr->nr) {

	case 0:

		if (extn->flags & EXTN_FLAG_SENSOR_ID)

			rc = snprintf(buf, PAGE_SIZE - 1, "%u",

				      get_unaligned_be32(&extn->sensor_id));

		else

			rc = snprintf(buf, PAGE_SIZE - 1, "%02x%02x%02x%02x\n",

				      extn->name[0], extn->name[1],

				      extn->name[2], extn->name[3]);

		break;

	case 1:

		rc = snprintf(buf, PAGE_SIZE - 1, "%02x\n", extn->flags);

		break;

	case 2:

		rc = snprintf(buf, PAGE_SIZE - 1, "%02x%02x%02x%02x%02x%02x\n",

			      extn->data[0], extn->data[1], extn->data[2],

			      extn->data[3], extn->data[4], extn->data[5]);

		break;

	default:

		return -EINVAL;

	}



	return rc;

}



/* only need to do this once at startup, as OCC won't change sensors on us */

static void occ_parse_poll_response(struct occ *occ)

{
@@ -85,6 +703,9 @@ int occ_setup(struct occ *occ, const char *name) 
{

	int rc;



	mutex_init(&occ->lock);



	/* no need to lock */

	rc = occ_poll(occ);

	if (rc == -ESHUTDOWN) {

		dev_info(occ->bus_dev, "host is not ready\n");

drivers/hwmon/occ/common.h

+6 −0
Original line number Diff line number Diff line
@@ -3,6 +3,8 @@ 
#ifndef OCC_COMMON_H

#define OCC_COMMON_H



#include <linux/mutex.h>



struct device;



#define OCC_RESP_DATA_BYTES		4089
@@ -80,8 +82,12 @@ struct occ { 
	struct occ_response resp;

	struct occ_sensors sensors;



	int powr_sample_time_us;	/* average power sample time */

	u8 poll_cmd_data;		/* to perform OCC poll command */

	int (*send_cmd)(struct occ *occ, u8 *cmd);



	unsigned long last_update;

	struct mutex lock;		/* lock OCC access */

};



int occ_setup(struct occ *occ, const char *name);

drivers/hwmon/occ/p8_i2c.c

+1 −0
Original line number Diff line number Diff line
@@ -216,6 +216,7 @@ static int p8_i2c_occ_probe(struct i2c_client *client, 
	occ->bus_dev = &client->dev;

	dev_set_drvdata(&client->dev, occ);



	occ->powr_sample_time_us = 250;

	occ->poll_cmd_data = 0x10;		/* P8 OCC poll data */

	occ->send_cmd = p8_i2c_occ_send_cmd;

drivers/hwmon/occ/p9_sbe.c

+1 −0
Original line number Diff line number Diff line
@@ -69,6 +69,7 @@ static int p9_sbe_occ_probe(struct platform_device *pdev) 
	occ->bus_dev = &pdev->dev;

	platform_set_drvdata(pdev, occ);



	occ->powr_sample_time_us = 500;

	occ->poll_cmd_data = 0x20;		/* P9 OCC poll data */

	occ->send_cmd = p9_sbe_occ_send_cmd;

CRA Git | Maintained and supported by SUSTech CRA and CCSE