[linux-block.git] / drivers / thermal / thermal_netlink.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright 2020 Linaro Limited
 *
 * Author: Daniel Lezcano <daniel.lezcano@linaro.org>
 *
 * Generic netlink for thermal management framework
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <net/genetlink.h>
#include <uapi/linux/thermal.h>

#include "thermal_core.h"

static const struct genl_multicast_group thermal_genl_mcgrps[] = {
	{ .name = THERMAL_GENL_SAMPLING_GROUP_NAME, },
	{ .name = THERMAL_GENL_EVENT_GROUP_NAME,  },
};

static const struct nla_policy thermal_genl_policy[THERMAL_GENL_ATTR_MAX + 1] = {
	/* Thermal zone */
	[THERMAL_GENL_ATTR_TZ]			= { .type = NLA_NESTED },
	[THERMAL_GENL_ATTR_TZ_ID]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_TEMP]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_TRIP]		= { .type = NLA_NESTED },
	[THERMAL_GENL_ATTR_TZ_TRIP_ID]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_TRIP_HYST]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_MODE]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_CDEV_WEIGHT]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_TZ_NAME]		= { .type = NLA_STRING,
						    .len = THERMAL_NAME_LENGTH },
	/* Governor(s) */
	[THERMAL_GENL_ATTR_TZ_GOV]		= { .type = NLA_NESTED },
	[THERMAL_GENL_ATTR_TZ_GOV_NAME]		= { .type = NLA_STRING,
						    .len = THERMAL_NAME_LENGTH },
	/* Cooling devices */
	[THERMAL_GENL_ATTR_CDEV]		= { .type = NLA_NESTED },
	[THERMAL_GENL_ATTR_CDEV_ID]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_CDEV_CUR_STATE]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_CDEV_MAX_STATE]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_CDEV_NAME]		= { .type = NLA_STRING,
						    .len = THERMAL_NAME_LENGTH },
	/* CPU capabilities */
	[THERMAL_GENL_ATTR_CPU_CAPABILITY]		= { .type = NLA_NESTED },
	[THERMAL_GENL_ATTR_CPU_CAPABILITY_ID]		= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE]	= { .type = NLA_U32 },
	[THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY]	= { .type = NLA_U32 },
};

struct param {
	struct nlattr **attrs;
	struct sk_buff *msg;
	const char *name;
	int tz_id;
	int cdev_id;
	int trip_id;
	int trip_temp;
	int trip_type;
	int trip_hyst;
	int temp;
	int cdev_state;
	int cdev_max_state;
	struct thermal_genl_cpu_caps *cpu_capabilities;
	int cpu_capabilities_count;
};

typedef int (*cb_t)(struct param *);

static struct genl_family thermal_gnl_family;

/************************** Sampling encoding *******************************/

int thermal_genl_sampling_temp(int id, int temp)
{
	struct sk_buff *skb;
	void *hdr;

	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

	hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0,
			  THERMAL_GENL_SAMPLING_TEMP);
	if (!hdr)
		goto out_free;

	if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_ID, id))
		goto out_cancel;

	if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_TEMP, temp))
		goto out_cancel;

	genlmsg_end(skb, hdr);

	genlmsg_multicast(&thermal_gnl_family, skb, 0, 0, GFP_KERNEL);

	return 0;
out_cancel:
	genlmsg_cancel(skb, hdr);
out_free:
	nlmsg_free(skb);

	return -EMSGSIZE;
}

/**************************** Event encoding *********************************/

static int thermal_genl_event_tz_create(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
	    nla_put_string(p->msg, THERMAL_GENL_ATTR_TZ_NAME, p->name))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_tz(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_tz_trip_up(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TEMP, p->temp))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_tz_trip_add(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, p->trip_type) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, p->trip_temp) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, p->trip_hyst))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_tz_trip_delete(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_cdev_add(struct param *p)
{
	if (nla_put_string(p->msg, THERMAL_GENL_ATTR_CDEV_NAME,
			   p->name) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
			p->cdev_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_MAX_STATE,
			p->cdev_max_state))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_cdev_delete(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, p->cdev_id))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_cdev_state_update(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
			p->cdev_id) ||
	    nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_CUR_STATE,
			p->cdev_state))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_gov_change(struct param *p)
{
	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
	    nla_put_string(p->msg, THERMAL_GENL_ATTR_GOV_NAME, p->name))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_event_cpu_capability_change(struct param *p)
{
	struct thermal_genl_cpu_caps *cpu_cap = p->cpu_capabilities;
	struct sk_buff *msg = p->msg;
	struct nlattr *start_cap;
	int i;

	start_cap = nla_nest_start(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY);
	if (!start_cap)
		return -EMSGSIZE;

	for (i = 0; i < p->cpu_capabilities_count; ++i) {
		if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_ID,
				cpu_cap->cpu))
			goto out_cancel_nest;

		if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE,
				cpu_cap->performance))
			goto out_cancel_nest;

		if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY,
				cpu_cap->efficiency))
			goto out_cancel_nest;

		++cpu_cap;
	}

	nla_nest_end(msg, start_cap);

	return 0;
out_cancel_nest:
	nla_nest_cancel(msg, start_cap);

	return -EMSGSIZE;
}

int thermal_genl_event_tz_delete(struct param *p)
	__attribute__((alias("thermal_genl_event_tz")));

int thermal_genl_event_tz_enable(struct param *p)
	__attribute__((alias("thermal_genl_event_tz")));

int thermal_genl_event_tz_disable(struct param *p)
	__attribute__((alias("thermal_genl_event_tz")));

int thermal_genl_event_tz_trip_down(struct param *p)
	__attribute__((alias("thermal_genl_event_tz_trip_up")));

int thermal_genl_event_tz_trip_change(struct param *p)
	__attribute__((alias("thermal_genl_event_tz_trip_add")));

static cb_t event_cb[] = {
	[THERMAL_GENL_EVENT_TZ_CREATE]		= thermal_genl_event_tz_create,
	[THERMAL_GENL_EVENT_TZ_DELETE]		= thermal_genl_event_tz_delete,
	[THERMAL_GENL_EVENT_TZ_ENABLE]		= thermal_genl_event_tz_enable,
	[THERMAL_GENL_EVENT_TZ_DISABLE]		= thermal_genl_event_tz_disable,
	[THERMAL_GENL_EVENT_TZ_TRIP_UP]		= thermal_genl_event_tz_trip_up,
	[THERMAL_GENL_EVENT_TZ_TRIP_DOWN]	= thermal_genl_event_tz_trip_down,
	[THERMAL_GENL_EVENT_TZ_TRIP_CHANGE]	= thermal_genl_event_tz_trip_change,
	[THERMAL_GENL_EVENT_TZ_TRIP_ADD]	= thermal_genl_event_tz_trip_add,
	[THERMAL_GENL_EVENT_TZ_TRIP_DELETE]	= thermal_genl_event_tz_trip_delete,
	[THERMAL_GENL_EVENT_CDEV_ADD]		= thermal_genl_event_cdev_add,
	[THERMAL_GENL_EVENT_CDEV_DELETE]	= thermal_genl_event_cdev_delete,
	[THERMAL_GENL_EVENT_CDEV_STATE_UPDATE]	= thermal_genl_event_cdev_state_update,
	[THERMAL_GENL_EVENT_TZ_GOV_CHANGE]	= thermal_genl_event_gov_change,
	[THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE] = thermal_genl_event_cpu_capability_change,
};

/*
 * Generic netlink event encoding
 */
static int thermal_genl_send_event(enum thermal_genl_event event,
				   struct param *p)
{
	struct sk_buff *msg;
	int ret = -EMSGSIZE;
	void *hdr;

	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;
	p->msg = msg;

	hdr = genlmsg_put(msg, 0, 0, &thermal_gnl_family, 0, event);
	if (!hdr)
		goto out_free_msg;

	ret = event_cb[event](p);
	if (ret)
		goto out_cancel_msg;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(&thermal_gnl_family, msg, 0, 1, GFP_KERNEL);

	return 0;

out_cancel_msg:
	genlmsg_cancel(msg, hdr);
out_free_msg:
	nlmsg_free(msg);

	return ret;
}

int thermal_notify_tz_create(int tz_id, const char *name)
{
	struct param p = { .tz_id = tz_id, .name = name };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_CREATE, &p);
}

int thermal_notify_tz_delete(int tz_id)
{
	struct param p = { .tz_id = tz_id };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DELETE, &p);
}

int thermal_notify_tz_enable(int tz_id)
{
	struct param p = { .tz_id = tz_id };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_ENABLE, &p);
}

int thermal_notify_tz_disable(int tz_id)
{
	struct param p = { .tz_id = tz_id };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DISABLE, &p);
}

int thermal_notify_tz_trip_down(int tz_id, int trip_id, int temp)
{
	struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DOWN, &p);
}

int thermal_notify_tz_trip_up(int tz_id, int trip_id, int temp)
{
	struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_UP, &p);
}

int thermal_notify_tz_trip_add(int tz_id, int trip_id, int trip_type,
			       int trip_temp, int trip_hyst)
{
	struct param p = { .tz_id = tz_id, .trip_id = trip_id,
			   .trip_type = trip_type, .trip_temp = trip_temp,
			   .trip_hyst = trip_hyst };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_ADD, &p);
}

int thermal_notify_tz_trip_delete(int tz_id, int trip_id)
{
	struct param p = { .tz_id = tz_id, .trip_id = trip_id };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DELETE, &p);
}

int thermal_notify_tz_trip_change(int tz_id, int trip_id, int trip_type,
				  int trip_temp, int trip_hyst)
{
	struct param p = { .tz_id = tz_id, .trip_id = trip_id,
			   .trip_type = trip_type, .trip_temp = trip_temp,
			   .trip_hyst = trip_hyst };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_CHANGE, &p);
}

int thermal_notify_cdev_state_update(int cdev_id, int cdev_state)
{
	struct param p = { .cdev_id = cdev_id, .cdev_state = cdev_state };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_STATE_UPDATE, &p);
}

int thermal_notify_cdev_add(int cdev_id, const char *name, int cdev_max_state)
{
	struct param p = { .cdev_id = cdev_id, .name = name,
			   .cdev_max_state = cdev_max_state };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_ADD, &p);
}

int thermal_notify_cdev_delete(int cdev_id)
{
	struct param p = { .cdev_id = cdev_id };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_DELETE, &p);
}

int thermal_notify_tz_gov_change(int tz_id, const char *name)
{
	struct param p = { .tz_id = tz_id, .name = name };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_GOV_CHANGE, &p);
}

int thermal_genl_cpu_capability_event(int count,
				      struct thermal_genl_cpu_caps *caps)
{
	struct param p = { .cpu_capabilities_count = count, .cpu_capabilities = caps };

	return thermal_genl_send_event(THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE, &p);
}
EXPORT_SYMBOL_GPL(thermal_genl_cpu_capability_event);

/*************************** Command encoding ********************************/

static int __thermal_genl_cmd_tz_get_id(struct thermal_zone_device *tz,
					void *data)
{
	struct sk_buff *msg = data;

	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, tz->id) ||
	    nla_put_string(msg, THERMAL_GENL_ATTR_TZ_NAME, tz->type))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_cmd_tz_get_id(struct param *p)
{
	struct sk_buff *msg = p->msg;
	struct nlattr *start_tz;
	int ret;

	start_tz = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ);
	if (!start_tz)
		return -EMSGSIZE;

	ret = for_each_thermal_zone(__thermal_genl_cmd_tz_get_id, msg);
	if (ret)
		goto out_cancel_nest;

	nla_nest_end(msg, start_tz);

	return 0;

out_cancel_nest:
	nla_nest_cancel(msg, start_tz);

	return ret;
}

static int thermal_genl_cmd_tz_get_trip(struct param *p)
{
	struct sk_buff *msg = p->msg;
	struct thermal_zone_device *tz;
	struct nlattr *start_trip;
	int i, id;

	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
		return -EINVAL;

	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);

	tz = thermal_zone_get_by_id(id);
	if (!tz)
		return -EINVAL;

	start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP);
	if (!start_trip)
		return -EMSGSIZE;

	mutex_lock(&tz->lock);

	for (i = 0; i < tz->num_trips; i++) {

		enum thermal_trip_type type;
		int temp, hyst = 0;

		tz->ops->get_trip_type(tz, i, &type);
		tz->ops->get_trip_temp(tz, i, &temp);
		if (tz->ops->get_trip_hyst)
			tz->ops->get_trip_hyst(tz, i, &hyst);

		if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, type) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, temp) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, hyst))
			goto out_cancel_nest;
	}

	mutex_unlock(&tz->lock);

	nla_nest_end(msg, start_trip);

	return 0;

out_cancel_nest:
	mutex_unlock(&tz->lock);

	return -EMSGSIZE;
}

static int thermal_genl_cmd_tz_get_temp(struct param *p)
{
	struct sk_buff *msg = p->msg;
	struct thermal_zone_device *tz;
	int temp, ret, id;

	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
		return -EINVAL;

	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);

	tz = thermal_zone_get_by_id(id);
	if (!tz)
		return -EINVAL;

	ret = thermal_zone_get_temp(tz, &temp);
	if (ret)
		return ret;

	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) ||
	    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TEMP, temp))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_cmd_tz_get_gov(struct param *p)
{
	struct sk_buff *msg = p->msg;
	struct thermal_zone_device *tz;
	int id, ret = 0;

	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
		return -EINVAL;

	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);

	tz = thermal_zone_get_by_id(id);
	if (!tz)
		return -EINVAL;

	mutex_lock(&tz->lock);

	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) ||
	    nla_put_string(msg, THERMAL_GENL_ATTR_TZ_GOV_NAME,
			   tz->governor->name))
		ret = -EMSGSIZE;

	mutex_unlock(&tz->lock);

	return ret;
}

static int __thermal_genl_cmd_cdev_get(struct thermal_cooling_device *cdev,
				       void *data)
{
	struct sk_buff *msg = data;

	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CDEV_ID, cdev->id))
		return -EMSGSIZE;

	if (nla_put_string(msg, THERMAL_GENL_ATTR_CDEV_NAME, cdev->type))
		return -EMSGSIZE;

	return 0;
}

static int thermal_genl_cmd_cdev_get(struct param *p)
{
	struct sk_buff *msg = p->msg;
	struct nlattr *start_cdev;
	int ret;

	start_cdev = nla_nest_start(msg, THERMAL_GENL_ATTR_CDEV);
	if (!start_cdev)
		return -EMSGSIZE;

	ret = for_each_thermal_cooling_device(__thermal_genl_cmd_cdev_get, msg);
	if (ret)
		goto out_cancel_nest;

	nla_nest_end(msg, start_cdev);

	return 0;
out_cancel_nest:
	nla_nest_cancel(msg, start_cdev);

	return ret;
}

static cb_t cmd_cb[] = {
	[THERMAL_GENL_CMD_TZ_GET_ID]	= thermal_genl_cmd_tz_get_id,
	[THERMAL_GENL_CMD_TZ_GET_TRIP]	= thermal_genl_cmd_tz_get_trip,
	[THERMAL_GENL_CMD_TZ_GET_TEMP]	= thermal_genl_cmd_tz_get_temp,
	[THERMAL_GENL_CMD_TZ_GET_GOV]	= thermal_genl_cmd_tz_get_gov,
	[THERMAL_GENL_CMD_CDEV_GET]	= thermal_genl_cmd_cdev_get,
};

static int thermal_genl_cmd_dumpit(struct sk_buff *skb,
				   struct netlink_callback *cb)
{
	struct param p = { .msg = skb };
	const struct genl_dumpit_info *info = genl_dumpit_info(cb);
	int cmd = info->op.cmd;
	int ret;
	void *hdr;

	hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, cmd);
	if (!hdr)
		return -EMSGSIZE;

	ret = cmd_cb[cmd](&p);
	if (ret)
		goto out_cancel_msg;

	genlmsg_end(skb, hdr);

	return 0;

out_cancel_msg:
	genlmsg_cancel(skb, hdr);

	return ret;
}

static int thermal_genl_cmd_doit(struct sk_buff *skb,
				 struct genl_info *info)
{
	struct param p = { .attrs = info->attrs };
	struct sk_buff *msg;
	void *hdr;
	int cmd = info->genlhdr->cmd;
	int ret = -EMSGSIZE;

	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;
	p.msg = msg;

	hdr = genlmsg_put_reply(msg, info, &thermal_gnl_family, 0, cmd);
	if (!hdr)
		goto out_free_msg;

	ret = cmd_cb[cmd](&p);
	if (ret)
		goto out_cancel_msg;

	genlmsg_end(msg, hdr);

	return genlmsg_reply(msg, info);

out_cancel_msg:
	genlmsg_cancel(msg, hdr);
out_free_msg:
	nlmsg_free(msg);

	return ret;
}

static const struct genl_small_ops thermal_genl_ops[] = {
	{
		.cmd = THERMAL_GENL_CMD_TZ_GET_ID,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.dumpit = thermal_genl_cmd_dumpit,
	},
	{
		.cmd = THERMAL_GENL_CMD_TZ_GET_TRIP,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.doit = thermal_genl_cmd_doit,
	},
	{
		.cmd = THERMAL_GENL_CMD_TZ_GET_TEMP,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.doit = thermal_genl_cmd_doit,
	},
	{
		.cmd = THERMAL_GENL_CMD_TZ_GET_GOV,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.doit = thermal_genl_cmd_doit,
	},
	{
		.cmd = THERMAL_GENL_CMD_CDEV_GET,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.dumpit = thermal_genl_cmd_dumpit,
	},
};

static struct genl_family thermal_gnl_family __ro_after_init = {
	.hdrsize	= 0,
	.name		= THERMAL_GENL_FAMILY_NAME,
	.version	= THERMAL_GENL_VERSION,
	.maxattr	= THERMAL_GENL_ATTR_MAX,
	.policy		= thermal_genl_policy,
	.small_ops	= thermal_genl_ops,
	.n_small_ops	= ARRAY_SIZE(thermal_genl_ops),
	.resv_start_op	= THERMAL_GENL_CMD_CDEV_GET + 1,
	.mcgrps		= thermal_genl_mcgrps,
	.n_mcgrps	= ARRAY_SIZE(thermal_genl_mcgrps),
};

int __init thermal_netlink_init(void)
{
	return genl_register_family(&thermal_gnl_family);
}
Commit	Line	Data
1ce50e7d DL	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright 2020 Linaro Limited
	4	*
	5	* Author: Daniel Lezcano <daniel.lezcano@linaro.org>
	6	*
	7	* Generic netlink for thermal management framework
	8	*/
	9	#include <linux/module.h>
	10	#include <linux/kernel.h>
	11	#include <net/genetlink.h>
	12	#include <uapi/linux/thermal.h>
	13
	14	#include "thermal_core.h"
	15
	16	static const struct genl_multicast_group thermal_genl_mcgrps[] = {
	17	{ .name = THERMAL_GENL_SAMPLING_GROUP_NAME, },
	18	{ .name = THERMAL_GENL_EVENT_GROUP_NAME, },
	19	};
	20
	21	static const struct nla_policy thermal_genl_policy[THERMAL_GENL_ATTR_MAX + 1] = {
	22	/* Thermal zone */
	23	[THERMAL_GENL_ATTR_TZ] = { .type = NLA_NESTED },
	24	[THERMAL_GENL_ATTR_TZ_ID] = { .type = NLA_U32 },
	25	[THERMAL_GENL_ATTR_TZ_TEMP] = { .type = NLA_U32 },
	26	[THERMAL_GENL_ATTR_TZ_TRIP] = { .type = NLA_NESTED },
	27	[THERMAL_GENL_ATTR_TZ_TRIP_ID] = { .type = NLA_U32 },
	28	[THERMAL_GENL_ATTR_TZ_TRIP_TEMP] = { .type = NLA_U32 },
	29	[THERMAL_GENL_ATTR_TZ_TRIP_TYPE] = { .type = NLA_U32 },
	30	[THERMAL_GENL_ATTR_TZ_TRIP_HYST] = { .type = NLA_U32 },
	31	[THERMAL_GENL_ATTR_TZ_MODE] = { .type = NLA_U32 },
	32	[THERMAL_GENL_ATTR_TZ_CDEV_WEIGHT] = { .type = NLA_U32 },
	33	[THERMAL_GENL_ATTR_TZ_NAME] = { .type = NLA_STRING,
	34	.len = THERMAL_NAME_LENGTH },
	35	/* Governor(s) */
	36	[THERMAL_GENL_ATTR_TZ_GOV] = { .type = NLA_NESTED },
	37	[THERMAL_GENL_ATTR_TZ_GOV_NAME] = { .type = NLA_STRING,
	38	.len = THERMAL_NAME_LENGTH },
	39	/* Cooling devices */
	40	[THERMAL_GENL_ATTR_CDEV] = { .type = NLA_NESTED },
	41	[THERMAL_GENL_ATTR_CDEV_ID] = { .type = NLA_U32 },
	42	[THERMAL_GENL_ATTR_CDEV_CUR_STATE] = { .type = NLA_U32 },
	43	[THERMAL_GENL_ATTR_CDEV_MAX_STATE] = { .type = NLA_U32 },
	44	[THERMAL_GENL_ATTR_CDEV_NAME] = { .type = NLA_STRING,
	45	.len = THERMAL_NAME_LENGTH },
e4b1eb24 SP	46	/* CPU capabilities */
	47	[THERMAL_GENL_ATTR_CPU_CAPABILITY] = { .type = NLA_NESTED },
	48	[THERMAL_GENL_ATTR_CPU_CAPABILITY_ID] = { .type = NLA_U32 },
	49	[THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE] = { .type = NLA_U32 },
	50	[THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY] = { .type = NLA_U32 },
1ce50e7d DL	51	};
	52
	53	struct param {
	54	struct nlattr **attrs;
	55	struct sk_buff *msg;
	56	const char *name;
	57	int tz_id;
	58	int cdev_id;
	59	int trip_id;
	60	int trip_temp;
	61	int trip_type;
	62	int trip_hyst;
	63	int temp;
	64	int cdev_state;
	65	int cdev_max_state;
e4b1eb24 SP	66	struct thermal_genl_cpu_caps *cpu_capabilities;
e4b1eb24 SP	67	int cpu_capabilities_count;
1ce50e7d DL	68	};
	69
	70	typedef int (cb_t)(struct param );
	71
	72	static struct genl_family thermal_gnl_family;
	73
	74	/************************ Sampling encoding *****************************/
	75
	76	int thermal_genl_sampling_temp(int id, int temp)
	77	{
	78	struct sk_buff *skb;
	79	void *hdr;
	80
	81	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	82	if (!skb)
	83	return -ENOMEM;
	84
	85	hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0,
	86	THERMAL_GENL_SAMPLING_TEMP);
	87	if (!hdr)
48b45859	88	goto out_free;
1ce50e7d DL	89
	90	if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_ID, id))
	91	goto out_cancel;
	92
	93	if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_TEMP, temp))
	94	goto out_cancel;
	95
	96	genlmsg_end(skb, hdr);
	97
	98	genlmsg_multicast(&thermal_gnl_family, skb, 0, 0, GFP_KERNEL);
	99
	100	return 0;
	101	out_cancel:
	102	genlmsg_cancel(skb, hdr);
48b45859	103	out_free:
1ce50e7d DL	104	nlmsg_free(skb);
	105
	106	return -EMSGSIZE;
	107	}
	108
	109	/************************** Event encoding *******************************/
	110
	111	static int thermal_genl_event_tz_create(struct param *p)
	112	{
	113	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) \|\|
	114	nla_put_string(p->msg, THERMAL_GENL_ATTR_TZ_NAME, p->name))
	115	return -EMSGSIZE;
	116
	117	return 0;
	118	}
	119
	120	static int thermal_genl_event_tz(struct param *p)
	121	{
	122	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id))
	123	return -EMSGSIZE;
	124
	125	return 0;
	126	}
	127
	128	static int thermal_genl_event_tz_trip_up(struct param *p)
	129	{
	130	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) \|\|
fc656fa1 DL	131	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) \|\|
fc656fa1 DL	132	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TEMP, p->temp))
1ce50e7d DL	133	return -EMSGSIZE;
	134
	135	return 0;
	136	}
	137
	138	static int thermal_genl_event_tz_trip_add(struct param *p)
	139	{
	140	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) \|\|
	141	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) \|\|
	142	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, p->trip_type) \|\|
	143	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, p->trip_temp) \|\|
	144	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, p->trip_hyst))
	145	return -EMSGSIZE;
	146
	147	return 0;
	148	}
	149
	150	static int thermal_genl_event_tz_trip_delete(struct param *p)
	151	{
	152	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) \|\|
	153	nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id))
	154	return -EMSGSIZE;
	155
	156	return 0;
	157	}
	158
	159	static int thermal_genl_event_cdev_add(struct param *p)
	160	{
	161	if (nla_put_string(p->msg, THERMAL_GENL_ATTR_CDEV_NAME,
	162	p->name) \|\|
	163	nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
	164	p->cdev_id) \|\|
	165	nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_MAX_STATE,
	166	p->cdev_max_state))
	167	return -EMSGSIZE;
	168
	169	return 0;
	170	}
	171
	172	static int thermal_genl_event_cdev_delete(struct param *p)
	173	{
	174	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, p->cdev_id))
	175	return -EMSGSIZE;
	176
	177	return 0;
	178	}
	179
	180	static int thermal_genl_event_cdev_state_update(struct param *p)
	181	{
	182	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
	183	p->cdev_id) \|\|
	184	nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_CUR_STATE,
	185	p->cdev_state))
	186	return -EMSGSIZE;
	187
	188	return 0;
	189	}
	190
	191	static int thermal_genl_event_gov_change(struct param *p)
	192	{
	193	if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) \|\|
	194	nla_put_string(p->msg, THERMAL_GENL_ATTR_GOV_NAME, p->name))
	195	return -EMSGSIZE;
	196
197	return 0;
198	}
199
e4b1eb24 SP	200	static int thermal_genl_event_cpu_capability_change(struct param *p)
	201	{
	202	struct thermal_genl_cpu_caps *cpu_cap = p->cpu_capabilities;
	203	struct sk_buff *msg = p->msg;
	204	struct nlattr *start_cap;
	205	int i;
	206
	207	start_cap = nla_nest_start(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY);
	208	if (!start_cap)
	209	return -EMSGSIZE;
	210
	211	for (i = 0; i < p->cpu_capabilities_count; ++i) {
	212	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_ID,
	213	cpu_cap->cpu))
	214	goto out_cancel_nest;
	215
	216	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE,
	217	cpu_cap->performance))
	218	goto out_cancel_nest;
	219
	220	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY,
	221	cpu_cap->efficiency))
	222	goto out_cancel_nest;
	223
	224	++cpu_cap;
	225	}
	226
	227	nla_nest_end(msg, start_cap);
	228
	229	return 0;
	230	out_cancel_nest:
	231	nla_nest_cancel(msg, start_cap);
	232
	233	return -EMSGSIZE;
	234	}
	235
1ce50e7d DL	236	int thermal_genl_event_tz_delete(struct param *p)
	237	__attribute__((alias("thermal_genl_event_tz")));
	238
	239	int thermal_genl_event_tz_enable(struct param *p)
	240	__attribute__((alias("thermal_genl_event_tz")));
	241
	242	int thermal_genl_event_tz_disable(struct param *p)
	243	__attribute__((alias("thermal_genl_event_tz")));
	244
	245	int thermal_genl_event_tz_trip_down(struct param *p)
	246	__attribute__((alias("thermal_genl_event_tz_trip_up")));
	247
	248	int thermal_genl_event_tz_trip_change(struct param *p)
	249	__attribute__((alias("thermal_genl_event_tz_trip_add")));
	250
	251	static cb_t event_cb[] = {
	252	[THERMAL_GENL_EVENT_TZ_CREATE] = thermal_genl_event_tz_create,
	253	[THERMAL_GENL_EVENT_TZ_DELETE] = thermal_genl_event_tz_delete,
	254	[THERMAL_GENL_EVENT_TZ_ENABLE] = thermal_genl_event_tz_enable,
	255	[THERMAL_GENL_EVENT_TZ_DISABLE] = thermal_genl_event_tz_disable,
	256	[THERMAL_GENL_EVENT_TZ_TRIP_UP] = thermal_genl_event_tz_trip_up,
	257	[THERMAL_GENL_EVENT_TZ_TRIP_DOWN] = thermal_genl_event_tz_trip_down,
	258	[THERMAL_GENL_EVENT_TZ_TRIP_CHANGE] = thermal_genl_event_tz_trip_change,
	259	[THERMAL_GENL_EVENT_TZ_TRIP_ADD] = thermal_genl_event_tz_trip_add,
	260	[THERMAL_GENL_EVENT_TZ_TRIP_DELETE] = thermal_genl_event_tz_trip_delete,
	261	[THERMAL_GENL_EVENT_CDEV_ADD] = thermal_genl_event_cdev_add,
	262	[THERMAL_GENL_EVENT_CDEV_DELETE] = thermal_genl_event_cdev_delete,
	263	[THERMAL_GENL_EVENT_CDEV_STATE_UPDATE] = thermal_genl_event_cdev_state_update,
	264	[THERMAL_GENL_EVENT_TZ_GOV_CHANGE] = thermal_genl_event_gov_change,
e4b1eb24	265	[THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE] = thermal_genl_event_cpu_capability_change,
1ce50e7d DL	266	};
	267
	268	/*
	269	* Generic netlink event encoding
	270	*/
	271	static int thermal_genl_send_event(enum thermal_genl_event event,
	272	struct param *p)
	273	{
	274	struct sk_buff *msg;
	275	int ret = -EMSGSIZE;
	276	void *hdr;
	277
	278	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	279	if (!msg)
	280	return -ENOMEM;
	281	p->msg = msg;
	282
	283	hdr = genlmsg_put(msg, 0, 0, &thermal_gnl_family, 0, event);
	284	if (!hdr)
	285	goto out_free_msg;
	286
	287	ret = event_cb[event](p);
	288	if (ret)
	289	goto out_cancel_msg;
	290
	291	genlmsg_end(msg, hdr);
	292
	293	genlmsg_multicast(&thermal_gnl_family, msg, 0, 1, GFP_KERNEL);
	294
	295	return 0;
	296
	297	out_cancel_msg:
	298	genlmsg_cancel(msg, hdr);
	299	out_free_msg:
	300	nlmsg_free(msg);
	301
	302	return ret;
	303	}
	304
	305	int thermal_notify_tz_create(int tz_id, const char *name)
	306	{
	307	struct param p = { .tz_id = tz_id, .name = name };
	308
	309	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_CREATE, &p);
	310	}
	311
	312	int thermal_notify_tz_delete(int tz_id)
	313	{
	314	struct param p = { .tz_id = tz_id };
	315
	316	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DELETE, &p);
	317	}
	318
	319	int thermal_notify_tz_enable(int tz_id)
	320	{
	321	struct param p = { .tz_id = tz_id };
	322
	323	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_ENABLE, &p);
	324	}
	325
	326	int thermal_notify_tz_disable(int tz_id)
	327	{
	328	struct param p = { .tz_id = tz_id };
	329
330	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DISABLE, &p);
331	}
332
fc656fa1	333	int thermal_notify_tz_trip_down(int tz_id, int trip_id, int temp)
1ce50e7d	334	{
fc656fa1	335	struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
1ce50e7d DL	336
	337	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DOWN, &p);
	338	}
	339
fc656fa1	340	int thermal_notify_tz_trip_up(int tz_id, int trip_id, int temp)
1ce50e7d	341	{
fc656fa1	342	struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
1ce50e7d DL	343
	344	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_UP, &p);
	345	}
	346
	347	int thermal_notify_tz_trip_add(int tz_id, int trip_id, int trip_type,
	348	int trip_temp, int trip_hyst)
	349	{
	350	struct param p = { .tz_id = tz_id, .trip_id = trip_id,
	351	.trip_type = trip_type, .trip_temp = trip_temp,
	352	.trip_hyst = trip_hyst };
	353
	354	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_ADD, &p);
	355	}
	356
	357	int thermal_notify_tz_trip_delete(int tz_id, int trip_id)
	358	{
	359	struct param p = { .tz_id = tz_id, .trip_id = trip_id };
	360
	361	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DELETE, &p);
	362	}
	363
	364	int thermal_notify_tz_trip_change(int tz_id, int trip_id, int trip_type,
	365	int trip_temp, int trip_hyst)
	366	{
	367	struct param p = { .tz_id = tz_id, .trip_id = trip_id,
	368	.trip_type = trip_type, .trip_temp = trip_temp,
	369	.trip_hyst = trip_hyst };
	370
	371	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_CHANGE, &p);
	372	}
	373
	374	int thermal_notify_cdev_state_update(int cdev_id, int cdev_state)
	375	{
	376	struct param p = { .cdev_id = cdev_id, .cdev_state = cdev_state };
	377
	378	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_STATE_UPDATE, &p);
	379	}
	380
	381	int thermal_notify_cdev_add(int cdev_id, const char *name, int cdev_max_state)
	382	{
	383	struct param p = { .cdev_id = cdev_id, .name = name,
	384	.cdev_max_state = cdev_max_state };
	385
	386	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_ADD, &p);
	387	}
	388
	389	int thermal_notify_cdev_delete(int cdev_id)
	390	{
	391	struct param p = { .cdev_id = cdev_id };
	392
	393	return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_DELETE, &p);
	394	}
	395
	396	int thermal_notify_tz_gov_change(int tz_id, const char *name)
	397	{
	398	struct param p = { .tz_id = tz_id, .name = name };
	399
	400	return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_GOV_CHANGE, &p);
	401	}
	402
e4b1eb24 SP	403	int thermal_genl_cpu_capability_event(int count,
	404	struct thermal_genl_cpu_caps *caps)
	405	{
	406	struct param p = { .cpu_capabilities_count = count, .cpu_capabilities = caps };
	407
	408	return thermal_genl_send_event(THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE, &p);
	409	}
	410	EXPORT_SYMBOL_GPL(thermal_genl_cpu_capability_event);
	411
1ce50e7d DL	412	/************************* Command encoding ******************************/
	413
	414	static int __thermal_genl_cmd_tz_get_id(struct thermal_zone_device *tz,
	415	void *data)
	416	{
	417	struct sk_buff *msg = data;
	418
	419	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, tz->id) \|\|
	420	nla_put_string(msg, THERMAL_GENL_ATTR_TZ_NAME, tz->type))
	421	return -EMSGSIZE;
	422
	423	return 0;
	424	}
	425
	426	static int thermal_genl_cmd_tz_get_id(struct param *p)
	427	{
	428	struct sk_buff *msg = p->msg;
	429	struct nlattr *start_tz;
	430	int ret;
	431
	432	start_tz = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ);
	433	if (!start_tz)
	434	return -EMSGSIZE;
	435
	436	ret = for_each_thermal_zone(__thermal_genl_cmd_tz_get_id, msg);
	437	if (ret)
	438	goto out_cancel_nest;
	439
	440	nla_nest_end(msg, start_tz);
	441
	442	return 0;
	443
	444	out_cancel_nest:
	445	nla_nest_cancel(msg, start_tz);
	446
	447	return ret;
	448	}
	449
	450	static int thermal_genl_cmd_tz_get_trip(struct param *p)
	451	{
	452	struct sk_buff *msg = p->msg;
	453	struct thermal_zone_device *tz;
	454	struct nlattr *start_trip;
	455	int i, id;
	456
	457	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	458	return -EINVAL;
	459
	460	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	461
	462	tz = thermal_zone_get_by_id(id);
	463	if (!tz)
	464	return -EINVAL;
	465
	466	start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP);
	467	if (!start_trip)
	468	return -EMSGSIZE;
	469
	470	mutex_lock(&tz->lock);
	471
e5bfcd30	472	for (i = 0; i < tz->num_trips; i++) {
1ce50e7d DL	473
1ce50e7d DL	474	enum thermal_trip_type type;
5838a148	475	int temp, hyst = 0;
1ce50e7d DL	476
	477	tz->ops->get_trip_type(tz, i, &type);
	478	tz->ops->get_trip_temp(tz, i, &temp);
5838a148 NC	479	if (tz->ops->get_trip_hyst)
5838a148 NC	480	tz->ops->get_trip_hyst(tz, i, &hyst);
1ce50e7d DL	481
	482	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) \|\|
	483	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, type) \|\|
	484	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, temp) \|\|
	485	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, hyst))
	486	goto out_cancel_nest;
	487	}
	488
	489	mutex_unlock(&tz->lock);
	490
	491	nla_nest_end(msg, start_trip);
	492
	493	return 0;
	494
	495	out_cancel_nest:
	496	mutex_unlock(&tz->lock);
	497
	498	return -EMSGSIZE;
	499	}
	500
	501	static int thermal_genl_cmd_tz_get_temp(struct param *p)
	502	{
	503	struct sk_buff *msg = p->msg;
	504	struct thermal_zone_device *tz;
	505	int temp, ret, id;
	506
	507	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	508	return -EINVAL;
	509
	510	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	511
	512	tz = thermal_zone_get_by_id(id);
	513	if (!tz)
	514	return -EINVAL;
	515
	516	ret = thermal_zone_get_temp(tz, &temp);
	517	if (ret)
	518	return ret;
	519
	520	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) \|\|
	521	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TEMP, temp))
	522	return -EMSGSIZE;
	523
	524	return 0;
	525	}
	526
	527	static int thermal_genl_cmd_tz_get_gov(struct param *p)
	528	{
	529	struct sk_buff *msg = p->msg;
	530	struct thermal_zone_device *tz;
	531	int id, ret = 0;
	532
	533	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	534	return -EINVAL;
	535
	536	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	537
	538	tz = thermal_zone_get_by_id(id);
	539	if (!tz)
	540	return -EINVAL;
	541
	542	mutex_lock(&tz->lock);
	543
	544	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) \|\|
545	nla_put_string(msg, THERMAL_GENL_ATTR_TZ_GOV_NAME,
546	tz->governor->name))
547	ret = -EMSGSIZE;
548
549	mutex_unlock(&tz->lock);
550
551	return ret;
552	}
553
554	static int __thermal_genl_cmd_cdev_get(struct thermal_cooling_device *cdev,
555	void *data)
556	{
557	struct sk_buff *msg = data;
558
559	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CDEV_ID, cdev->id))
560	return -EMSGSIZE;
561
562	if (nla_put_string(msg, THERMAL_GENL_ATTR_CDEV_NAME, cdev->type))
563	return -EMSGSIZE;
564
565	return 0;
566	}
567
568	static int thermal_genl_cmd_cdev_get(struct param *p)
569	{
570	struct sk_buff *msg = p->msg;
571	struct nlattr *start_cdev;
572	int ret;
573
574	start_cdev = nla_nest_start(msg, THERMAL_GENL_ATTR_CDEV);
575	if (!start_cdev)
576	return -EMSGSIZE;
577
578	ret = for_each_thermal_cooling_device(__thermal_genl_cmd_cdev_get, msg);
579	if (ret)
580	goto out_cancel_nest;
581
582	nla_nest_end(msg, start_cdev);
583
584	return 0;
585	out_cancel_nest:
586	nla_nest_cancel(msg, start_cdev);
587
588	return ret;
589	}
590
591	static cb_t cmd_cb[] = {
592	[THERMAL_GENL_CMD_TZ_GET_ID] = thermal_genl_cmd_tz_get_id,
593	[THERMAL_GENL_CMD_TZ_GET_TRIP] = thermal_genl_cmd_tz_get_trip,
594	[THERMAL_GENL_CMD_TZ_GET_TEMP] = thermal_genl_cmd_tz_get_temp,
595	[THERMAL_GENL_CMD_TZ_GET_GOV] = thermal_genl_cmd_tz_get_gov,
596	[THERMAL_GENL_CMD_CDEV_GET] = thermal_genl_cmd_cdev_get,
597	};
598
599	static int thermal_genl_cmd_dumpit(struct sk_buff *skb,
600	struct netlink_callback *cb)
601	{
602	struct param p = { .msg = skb };
603	const struct genl_dumpit_info *info = genl_dumpit_info(cb);
0b588afd	604	int cmd = info->op.cmd;
52674f56	605	int ret;
1ce50e7d DL	606	void *hdr;
	607
	608	hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, cmd);
	609	if (!hdr)
	610	return -EMSGSIZE;
	611
	612	ret = cmd_cb[cmd](&p);
	613	if (ret)
	614	goto out_cancel_msg;
	615
	616	genlmsg_end(skb, hdr);
	617
	618	return 0;
	619
	620	out_cancel_msg:
	621	genlmsg_cancel(skb, hdr);
	622
	623	return ret;
	624	}
	625
	626	static int thermal_genl_cmd_doit(struct sk_buff *skb,
	627	struct genl_info *info)
	628	{
	629	struct param p = { .attrs = info->attrs };
	630	struct sk_buff *msg;
	631	void *hdr;
	632	int cmd = info->genlhdr->cmd;
	633	int ret = -EMSGSIZE;
	634
	635	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	636	if (!msg)
	637	return -ENOMEM;
	638	p.msg = msg;
	639
	640	hdr = genlmsg_put_reply(msg, info, &thermal_gnl_family, 0, cmd);
	641	if (!hdr)
	642	goto out_free_msg;
	643
	644	ret = cmd_cb[cmd](&p);
	645	if (ret)
	646	goto out_cancel_msg;
	647
	648	genlmsg_end(msg, hdr);
	649
	650	return genlmsg_reply(msg, info);
	651
	652	out_cancel_msg:
	653	genlmsg_cancel(msg, hdr);
	654	out_free_msg:
	655	nlmsg_free(msg);
	656
	657	return ret;
	658	}
	659
66a9b928	660	static const struct genl_small_ops thermal_genl_ops[] = {
1ce50e7d DL	661	{
	662	.cmd = THERMAL_GENL_CMD_TZ_GET_ID,
	663	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	664	.dumpit = thermal_genl_cmd_dumpit,
	665	},
	666	{
	667	.cmd = THERMAL_GENL_CMD_TZ_GET_TRIP,
	668	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	669	.doit = thermal_genl_cmd_doit,
	670	},
	671	{
	672	.cmd = THERMAL_GENL_CMD_TZ_GET_TEMP,
	673	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	674	.doit = thermal_genl_cmd_doit,
	675	},
	676	{
	677	.cmd = THERMAL_GENL_CMD_TZ_GET_GOV,
	678	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	679	.doit = thermal_genl_cmd_doit,
	680	},
	681	{
	682	.cmd = THERMAL_GENL_CMD_CDEV_GET,
	683	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	684	.dumpit = thermal_genl_cmd_dumpit,
	685	},
	686	};
	687
	688	static struct genl_family thermal_gnl_family __ro_after_init = {
	689	.hdrsize = 0,
	690	.name = THERMAL_GENL_FAMILY_NAME,
	691	.version = THERMAL_GENL_VERSION,
	692	.maxattr = THERMAL_GENL_ATTR_MAX,
	693	.policy = thermal_genl_policy,
66a9b928 JK	694	.small_ops = thermal_genl_ops,
66a9b928 JK	695	.n_small_ops = ARRAY_SIZE(thermal_genl_ops),
9c5d03d3	696	.resv_start_op = THERMAL_GENL_CMD_CDEV_GET + 1,
1ce50e7d DL	697	.mcgrps = thermal_genl_mcgrps,
	698	.n_mcgrps = ARRAY_SIZE(thermal_genl_mcgrps),
	699	};
	700
d2a89b52	701	int __init thermal_netlink_init(void)
1ce50e7d DL	702	{
	703	return genl_register_family(&thermal_gnl_family);
	704	}