[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;
	struct thermal_trip trip;
	int ret, 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++) {

		ret = __thermal_zone_get_trip(tz, i, &trip);
		if (ret)
			goto out_cancel_nest;

		if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, trip.type) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, trip.temperature) ||
		    nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, trip.hysteresis))
			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);
}

void __init thermal_netlink_exit(void)
{
	genl_unregister_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;
7c3d5c20 DL	455	struct thermal_trip trip;
7c3d5c20 DL	456	int ret, i, id;
1ce50e7d DL	457
	458	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	459	return -EINVAL;
	460
	461	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	462
	463	tz = thermal_zone_get_by_id(id);
	464	if (!tz)
	465	return -EINVAL;
	466
	467	start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP);
	468	if (!start_trip)
	469	return -EMSGSIZE;
	470
	471	mutex_lock(&tz->lock);
	472
e5bfcd30	473	for (i = 0; i < tz->num_trips; i++) {
1ce50e7d	474
7c3d5c20 DL	475	ret = __thermal_zone_get_trip(tz, i, &trip);
	476	if (ret)
	477	goto out_cancel_nest;
1ce50e7d DL	478
1ce50e7d DL	479	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) \|\|
7c3d5c20 DL	480	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, trip.type) \|\|
	481	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, trip.temperature) \|\|
	482	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, trip.hysteresis))
1ce50e7d DL	483	goto out_cancel_nest;
	484	}
	485
	486	mutex_unlock(&tz->lock);
	487
	488	nla_nest_end(msg, start_trip);
	489
	490	return 0;
	491
	492	out_cancel_nest:
	493	mutex_unlock(&tz->lock);
	494
	495	return -EMSGSIZE;
	496	}
	497
	498	static int thermal_genl_cmd_tz_get_temp(struct param *p)
	499	{
	500	struct sk_buff *msg = p->msg;
	501	struct thermal_zone_device *tz;
	502	int temp, ret, id;
	503
	504	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	505	return -EINVAL;
	506
	507	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	508
	509	tz = thermal_zone_get_by_id(id);
	510	if (!tz)
	511	return -EINVAL;
	512
	513	ret = thermal_zone_get_temp(tz, &temp);
	514	if (ret)
	515	return ret;
	516
	517	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) \|\|
	518	nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TEMP, temp))
	519	return -EMSGSIZE;
	520
	521	return 0;
	522	}
	523
	524	static int thermal_genl_cmd_tz_get_gov(struct param *p)
	525	{
	526	struct sk_buff *msg = p->msg;
	527	struct thermal_zone_device *tz;
	528	int id, ret = 0;
	529
	530	if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
	531	return -EINVAL;
	532
	533	id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
	534
	535	tz = thermal_zone_get_by_id(id);
	536	if (!tz)
	537	return -EINVAL;
	538
	539	mutex_lock(&tz->lock);
	540
	541	if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) \|\|
	542	nla_put_string(msg, THERMAL_GENL_ATTR_TZ_GOV_NAME,
	543	tz->governor->name))
	544	ret = -EMSGSIZE;
	545
	546	mutex_unlock(&tz->lock);
547
548	return ret;
549	}
550
551	static int __thermal_genl_cmd_cdev_get(struct thermal_cooling_device *cdev,
552	void *data)
553	{
554	struct sk_buff *msg = data;
555
556	if (nla_put_u32(msg, THERMAL_GENL_ATTR_CDEV_ID, cdev->id))
557	return -EMSGSIZE;
558
559	if (nla_put_string(msg, THERMAL_GENL_ATTR_CDEV_NAME, cdev->type))
560	return -EMSGSIZE;
561
562	return 0;
563	}
564
565	static int thermal_genl_cmd_cdev_get(struct param *p)
566	{
567	struct sk_buff *msg = p->msg;
568	struct nlattr *start_cdev;
569	int ret;
570
571	start_cdev = nla_nest_start(msg, THERMAL_GENL_ATTR_CDEV);
572	if (!start_cdev)
573	return -EMSGSIZE;
574
575	ret = for_each_thermal_cooling_device(__thermal_genl_cmd_cdev_get, msg);
576	if (ret)
577	goto out_cancel_nest;
578
579	nla_nest_end(msg, start_cdev);
580
581	return 0;
582	out_cancel_nest:
583	nla_nest_cancel(msg, start_cdev);
584
585	return ret;
586	}
587
588	static cb_t cmd_cb[] = {
589	[THERMAL_GENL_CMD_TZ_GET_ID] = thermal_genl_cmd_tz_get_id,
590	[THERMAL_GENL_CMD_TZ_GET_TRIP] = thermal_genl_cmd_tz_get_trip,
591	[THERMAL_GENL_CMD_TZ_GET_TEMP] = thermal_genl_cmd_tz_get_temp,
592	[THERMAL_GENL_CMD_TZ_GET_GOV] = thermal_genl_cmd_tz_get_gov,
593	[THERMAL_GENL_CMD_CDEV_GET] = thermal_genl_cmd_cdev_get,
594	};
595
596	static int thermal_genl_cmd_dumpit(struct sk_buff *skb,
597	struct netlink_callback *cb)
598	{
599	struct param p = { .msg = skb };
600	const struct genl_dumpit_info *info = genl_dumpit_info(cb);
0b588afd	601	int cmd = info->op.cmd;
52674f56	602	int ret;
1ce50e7d DL	603	void *hdr;
	604
	605	hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, cmd);
	606	if (!hdr)
	607	return -EMSGSIZE;
	608
	609	ret = cmd_cb[cmd](&p);
	610	if (ret)
	611	goto out_cancel_msg;
	612
	613	genlmsg_end(skb, hdr);
	614
	615	return 0;
	616
	617	out_cancel_msg:
	618	genlmsg_cancel(skb, hdr);
	619
	620	return ret;
	621	}
	622
	623	static int thermal_genl_cmd_doit(struct sk_buff *skb,
	624	struct genl_info *info)
	625	{
	626	struct param p = { .attrs = info->attrs };
	627	struct sk_buff *msg;
	628	void *hdr;
	629	int cmd = info->genlhdr->cmd;
	630	int ret = -EMSGSIZE;
	631
	632	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	633	if (!msg)
	634	return -ENOMEM;
	635	p.msg = msg;
	636
	637	hdr = genlmsg_put_reply(msg, info, &thermal_gnl_family, 0, cmd);
	638	if (!hdr)
	639	goto out_free_msg;
	640
	641	ret = cmd_cb[cmd](&p);
	642	if (ret)
	643	goto out_cancel_msg;
	644
	645	genlmsg_end(msg, hdr);
	646
	647	return genlmsg_reply(msg, info);
	648
	649	out_cancel_msg:
	650	genlmsg_cancel(msg, hdr);
	651	out_free_msg:
	652	nlmsg_free(msg);
	653
	654	return ret;
	655	}
	656
66a9b928	657	static const struct genl_small_ops thermal_genl_ops[] = {
1ce50e7d DL	658	{
	659	.cmd = THERMAL_GENL_CMD_TZ_GET_ID,
	660	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	661	.dumpit = thermal_genl_cmd_dumpit,
	662	},
	663	{
	664	.cmd = THERMAL_GENL_CMD_TZ_GET_TRIP,
	665	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	666	.doit = thermal_genl_cmd_doit,
	667	},
	668	{
	669	.cmd = THERMAL_GENL_CMD_TZ_GET_TEMP,
	670	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	671	.doit = thermal_genl_cmd_doit,
	672	},
	673	{
	674	.cmd = THERMAL_GENL_CMD_TZ_GET_GOV,
	675	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	676	.doit = thermal_genl_cmd_doit,
	677	},
	678	{
	679	.cmd = THERMAL_GENL_CMD_CDEV_GET,
	680	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
	681	.dumpit = thermal_genl_cmd_dumpit,
	682	},
	683	};
	684
	685	static struct genl_family thermal_gnl_family __ro_after_init = {
	686	.hdrsize = 0,
	687	.name = THERMAL_GENL_FAMILY_NAME,
	688	.version = THERMAL_GENL_VERSION,
	689	.maxattr = THERMAL_GENL_ATTR_MAX,
	690	.policy = thermal_genl_policy,
66a9b928 JK	691	.small_ops = thermal_genl_ops,
66a9b928 JK	692	.n_small_ops = ARRAY_SIZE(thermal_genl_ops),
9c5d03d3	693	.resv_start_op = THERMAL_GENL_CMD_CDEV_GET + 1,
1ce50e7d DL	694	.mcgrps = thermal_genl_mcgrps,
	695	.n_mcgrps = ARRAY_SIZE(thermal_genl_mcgrps),
	696	};
	697
d2a89b52	698	int __init thermal_netlink_init(void)
1ce50e7d DL	699	{
	700	return genl_register_family(&thermal_gnl_family);
	701	}
58d1c9fd DL	702
	703	void __init thermal_netlink_exit(void)
	704	{
	705	genl_unregister_family(&thermal_gnl_family);
	706	}