[linux-2.6-block.git] / drivers / remoteproc / qcom_sysmon.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2017, Linaro Ltd.
 */
#include <linux/firmware.h>
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/notifier.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/remoteproc/qcom_rproc.h>
#include <linux/rpmsg.h>

#include "qcom_common.h"

static BLOCKING_NOTIFIER_HEAD(sysmon_notifiers);

struct qcom_sysmon {
	struct rproc_subdev subdev;
	struct rproc *rproc;

	struct list_head node;

	const char *name;

	int ssctl_version;
	int ssctl_instance;

	struct notifier_block nb;

	struct device *dev;

	struct rpmsg_endpoint *ept;
	struct completion comp;
	struct mutex lock;

	bool ssr_ack;

	struct qmi_handle qmi;
	struct sockaddr_qrtr ssctl;
};

static DEFINE_MUTEX(sysmon_lock);
static LIST_HEAD(sysmon_list);

/**
 * sysmon_send_event() - send notification of other remote's SSR event
 * @sysmon:	sysmon context
 * @name:	other remote's name
 */
static void sysmon_send_event(struct qcom_sysmon *sysmon, const char *name)
{
	char req[50];
	int len;
	int ret;

	len = snprintf(req, sizeof(req), "ssr:%s:before_shutdown", name);
	if (len >= sizeof(req))
		return;

	mutex_lock(&sysmon->lock);
	reinit_completion(&sysmon->comp);
	sysmon->ssr_ack = false;

	ret = rpmsg_send(sysmon->ept, req, len);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to send sysmon event\n");
		goto out_unlock;
	}

	ret = wait_for_completion_timeout(&sysmon->comp,
					  msecs_to_jiffies(5000));
	if (!ret) {
		dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
		goto out_unlock;
	}

	if (!sysmon->ssr_ack)
		dev_err(sysmon->dev, "unexpected response to sysmon event\n");

out_unlock:
	mutex_unlock(&sysmon->lock);
}

/**
 * sysmon_request_shutdown() - request graceful shutdown of remote
 * @sysmon:	sysmon context
 */
static void sysmon_request_shutdown(struct qcom_sysmon *sysmon)
{
	char *req = "ssr:shutdown";
	int ret;

	mutex_lock(&sysmon->lock);
	reinit_completion(&sysmon->comp);
	sysmon->ssr_ack = false;

	ret = rpmsg_send(sysmon->ept, req, strlen(req) + 1);
	if (ret < 0) {
		dev_err(sysmon->dev, "send sysmon shutdown request failed\n");
		goto out_unlock;
	}

	ret = wait_for_completion_timeout(&sysmon->comp,
					  msecs_to_jiffies(5000));
	if (!ret) {
		dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
		goto out_unlock;
	}

	if (!sysmon->ssr_ack)
		dev_err(sysmon->dev,
			"unexpected response to sysmon shutdown request\n");

out_unlock:
	mutex_unlock(&sysmon->lock);
}

static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,
			   void *priv, u32 addr)
{
	struct qcom_sysmon *sysmon = priv;
	const char *ssr_ack = "ssr:ack";
	const int ssr_ack_len = strlen(ssr_ack) + 1;

	if (!sysmon)
		return -EINVAL;

	if (count >= ssr_ack_len && !memcmp(data, ssr_ack, ssr_ack_len))
		sysmon->ssr_ack = true;

	complete(&sysmon->comp);

	return 0;
}

#define SSCTL_SHUTDOWN_REQ		0x21
#define SSCTL_SUBSYS_EVENT_REQ		0x23

#define SSCTL_MAX_MSG_LEN		7

#define SSCTL_SUBSYS_NAME_LENGTH	15

enum {
	SSCTL_SSR_EVENT_BEFORE_POWERUP,
	SSCTL_SSR_EVENT_AFTER_POWERUP,
	SSCTL_SSR_EVENT_BEFORE_SHUTDOWN,
	SSCTL_SSR_EVENT_AFTER_SHUTDOWN,
};

enum {
	SSCTL_SSR_EVENT_FORCED,
	SSCTL_SSR_EVENT_GRACEFUL,
};

struct ssctl_shutdown_resp {
	struct qmi_response_type_v01 resp;
};

static struct qmi_elem_info ssctl_shutdown_resp_ei[] = {
	{
		.data_type	= QMI_STRUCT,
		.elem_len	= 1,
		.elem_size	= sizeof(struct qmi_response_type_v01),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x02,
		.offset		= offsetof(struct ssctl_shutdown_resp, resp),
		.ei_array	= qmi_response_type_v01_ei,
	},
	{}
};

struct ssctl_subsys_event_req {
	u8 subsys_name_len;
	char subsys_name[SSCTL_SUBSYS_NAME_LENGTH];
	u32 event;
	u8 evt_driven_valid;
	u32 evt_driven;
};

static struct qmi_elem_info ssctl_subsys_event_req_ei[] = {
	{
		.data_type	= QMI_DATA_LEN,
		.elem_len	= 1,
		.elem_size	= sizeof(uint8_t),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x01,
		.offset		= offsetof(struct ssctl_subsys_event_req,
					   subsys_name_len),
		.ei_array	= NULL,
	},
	{
		.data_type	= QMI_UNSIGNED_1_BYTE,
		.elem_len	= SSCTL_SUBSYS_NAME_LENGTH,
		.elem_size	= sizeof(char),
		.array_type	= VAR_LEN_ARRAY,
		.tlv_type	= 0x01,
		.offset		= offsetof(struct ssctl_subsys_event_req,
					   subsys_name),
		.ei_array	= NULL,
	},
	{
		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
		.elem_len	= 1,
		.elem_size	= sizeof(uint32_t),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x02,
		.offset		= offsetof(struct ssctl_subsys_event_req,
					   event),
		.ei_array	= NULL,
	},
	{
		.data_type	= QMI_OPT_FLAG,
		.elem_len	= 1,
		.elem_size	= sizeof(uint8_t),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x10,
		.offset		= offsetof(struct ssctl_subsys_event_req,
					   evt_driven_valid),
		.ei_array	= NULL,
	},
	{
		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
		.elem_len	= 1,
		.elem_size	= sizeof(uint32_t),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x10,
		.offset		= offsetof(struct ssctl_subsys_event_req,
					   evt_driven),
		.ei_array	= NULL,
	},
	{}
};

struct ssctl_subsys_event_resp {
	struct qmi_response_type_v01 resp;
};

static struct qmi_elem_info ssctl_subsys_event_resp_ei[] = {
	{
		.data_type	= QMI_STRUCT,
		.elem_len	= 1,
		.elem_size	= sizeof(struct qmi_response_type_v01),
		.array_type	= NO_ARRAY,
		.tlv_type	= 0x02,
		.offset		= offsetof(struct ssctl_subsys_event_resp,
					   resp),
		.ei_array	= qmi_response_type_v01_ei,
	},
	{}
};

/**
 * ssctl_request_shutdown() - request shutdown via SSCTL QMI service
 * @sysmon:	sysmon context
 */
static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)
{
	struct ssctl_shutdown_resp resp;
	struct qmi_txn txn;
	int ret;

	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_shutdown_resp_ei, &resp);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to allocate QMI txn\n");
		return;
	}

	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
			       SSCTL_SHUTDOWN_REQ, 0, NULL, NULL);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to send shutdown request\n");
		qmi_txn_cancel(&txn);
		return;
	}

	ret = qmi_txn_wait(&txn, 5 * HZ);
	if (ret < 0)
		dev_err(sysmon->dev, "failed receiving QMI response\n");
	else if (resp.resp.result)
		dev_err(sysmon->dev, "shutdown request failed\n");
	else
		dev_dbg(sysmon->dev, "shutdown request completed\n");
}

/**
 * ssctl_send_event() - send notification of other remote's SSR event
 * @sysmon:	sysmon context
 * @name:	other remote's name
 */
static void ssctl_send_event(struct qcom_sysmon *sysmon, const char *name)
{
	struct ssctl_subsys_event_resp resp;
	struct ssctl_subsys_event_req req;
	struct qmi_txn txn;
	int ret;

	memset(&resp, 0, sizeof(resp));
	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_subsys_event_resp_ei, &resp);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to allocate QMI txn\n");
		return;
	}

	memset(&req, 0, sizeof(req));
	strlcpy(req.subsys_name, name, sizeof(req.subsys_name));
	req.subsys_name_len = strlen(req.subsys_name);
	req.event = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN;
	req.evt_driven_valid = true;
	req.evt_driven = SSCTL_SSR_EVENT_FORCED;

	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
			       SSCTL_SUBSYS_EVENT_REQ, 40,
			       ssctl_subsys_event_req_ei, &req);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to send shutdown request\n");
		qmi_txn_cancel(&txn);
		return;
	}

	ret = qmi_txn_wait(&txn, 5 * HZ);
	if (ret < 0)
		dev_err(sysmon->dev, "failed receiving QMI response\n");
	else if (resp.resp.result)
		dev_err(sysmon->dev, "ssr event send failed\n");
	else
		dev_dbg(sysmon->dev, "ssr event send completed\n");
}

/**
 * ssctl_new_server() - QMI callback indicating a new service
 * @qmi:	QMI handle
 * @svc:	service information
 *
 * Return: 0 if we're interested in this service, -EINVAL otherwise.
 */
static int ssctl_new_server(struct qmi_handle *qmi, struct qmi_service *svc)
{
	struct qcom_sysmon *sysmon = container_of(qmi, struct qcom_sysmon, qmi);

	switch (svc->version) {
	case 1:
		if (svc->instance != 0)
			return -EINVAL;
		if (strcmp(sysmon->name, "modem"))
			return -EINVAL;
		break;
	case 2:
		if (svc->instance != sysmon->ssctl_instance)
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	};

	sysmon->ssctl_version = svc->version;

	sysmon->ssctl.sq_family = AF_QIPCRTR;
	sysmon->ssctl.sq_node = svc->node;
	sysmon->ssctl.sq_port = svc->port;

	svc->priv = sysmon;

	return 0;
}

/**
 * ssctl_del_server() - QMI callback indicating that @svc is removed
 * @qmi:	QMI handle
 * @svc:	service information
 */
static void ssctl_del_server(struct qmi_handle *qmi, struct qmi_service *svc)
{
	struct qcom_sysmon *sysmon = svc->priv;

	sysmon->ssctl_version = 0;
}

static const struct qmi_ops ssctl_ops = {
	.new_server = ssctl_new_server,
	.del_server = ssctl_del_server,
};

static int sysmon_start(struct rproc_subdev *subdev)
{
	return 0;
}

static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)
{
	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev);

	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)sysmon->name);

	/* Don't request graceful shutdown if we've crashed */
	if (crashed)
		return;

	if (sysmon->ssctl_version)
		ssctl_request_shutdown(sysmon);
	else if (sysmon->ept)
		sysmon_request_shutdown(sysmon);
}

/**
 * sysmon_notify() - notify sysmon target of another's SSR
 * @nb:		notifier_block associated with sysmon instance
 * @event:	unused
 * @data:	SSR identifier of the remote that is going down
 */
static int sysmon_notify(struct notifier_block *nb, unsigned long event,
			 void *data)
{
	struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);
	struct rproc *rproc = sysmon->rproc;
	const char *ssr_name = data;

	/* Skip non-running rprocs and the originating instance */
	if (rproc->state != RPROC_RUNNING || !strcmp(data, sysmon->name)) {
		dev_dbg(sysmon->dev, "not notifying %s\n", sysmon->name);
		return NOTIFY_DONE;
	}

	/* Only SSCTL version 2 supports SSR events */
	if (sysmon->ssctl_version == 2)
		ssctl_send_event(sysmon, ssr_name);
	else if (sysmon->ept)
		sysmon_send_event(sysmon, ssr_name);

	return NOTIFY_DONE;
}

/**
 * qcom_add_sysmon_subdev() - create a sysmon subdev for the given remoteproc
 * @rproc:	rproc context to associate the subdev with
 * @name:	name of this subdev, to use in SSR
 * @ssctl_instance: instance id of the ssctl QMI service
 *
 * Return: A new qcom_sysmon object, or NULL on failure
 */
struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,
					   const char *name,
					   int ssctl_instance)
{
	struct qcom_sysmon *sysmon;
	int ret;

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

	sysmon->dev = rproc->dev.parent;
	sysmon->rproc = rproc;

	sysmon->name = name;
	sysmon->ssctl_instance = ssctl_instance;

	init_completion(&sysmon->comp);
	mutex_init(&sysmon->lock);

	ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops, NULL);
	if (ret < 0) {
		dev_err(sysmon->dev, "failed to initialize qmi handle\n");
		kfree(sysmon);
		return NULL;
	}

	qmi_add_lookup(&sysmon->qmi, 43, 0, 0);

	sysmon->subdev.start = sysmon_start;
	sysmon->subdev.stop = sysmon_stop;

	rproc_add_subdev(rproc, &sysmon->subdev);

	sysmon->nb.notifier_call = sysmon_notify;
	blocking_notifier_chain_register(&sysmon_notifiers, &sysmon->nb);

	mutex_lock(&sysmon_lock);
	list_add(&sysmon->node, &sysmon_list);
	mutex_unlock(&sysmon_lock);

	return sysmon;
}
EXPORT_SYMBOL_GPL(qcom_add_sysmon_subdev);

/**
 * qcom_remove_sysmon_subdev() - release a qcom_sysmon
 * @sysmon:	sysmon context, as retrieved by qcom_add_sysmon_subdev()
 */
void qcom_remove_sysmon_subdev(struct qcom_sysmon *sysmon)
{
	if (!sysmon)
		return;

	mutex_lock(&sysmon_lock);
	list_del(&sysmon->node);
	mutex_unlock(&sysmon_lock);

	blocking_notifier_chain_unregister(&sysmon_notifiers, &sysmon->nb);

	rproc_remove_subdev(sysmon->rproc, &sysmon->subdev);

	qmi_handle_release(&sysmon->qmi);

	kfree(sysmon);
}
EXPORT_SYMBOL_GPL(qcom_remove_sysmon_subdev);

/**
 * sysmon_probe() - probe sys_mon channel
 * @rpdev:	rpmsg device handle
 *
 * Find the sysmon context associated with the ancestor remoteproc and assign
 * this rpmsg device with said sysmon context.
 *
 * Return: 0 on success, negative errno on failure.
 */
static int sysmon_probe(struct rpmsg_device *rpdev)
{
	struct qcom_sysmon *sysmon;
	struct rproc *rproc;

	rproc = rproc_get_by_child(&rpdev->dev);
	if (!rproc) {
		dev_err(&rpdev->dev, "sysmon device not child of rproc\n");
		return -EINVAL;
	}

	mutex_lock(&sysmon_lock);
	list_for_each_entry(sysmon, &sysmon_list, node) {
		if (sysmon->rproc == rproc)
			goto found;
	}
	mutex_unlock(&sysmon_lock);

	dev_err(&rpdev->dev, "no sysmon associated with parent rproc\n");

	return -EINVAL;

found:
	mutex_unlock(&sysmon_lock);

	rpdev->ept->priv = sysmon;
	sysmon->ept = rpdev->ept;

	return 0;
}

/**
 * sysmon_remove() - sys_mon channel remove handler
 * @rpdev:	rpmsg device handle
 *
 * Disassociate the rpmsg device with the sysmon instance.
 */
static void sysmon_remove(struct rpmsg_device *rpdev)
{
	struct qcom_sysmon *sysmon = rpdev->ept->priv;

	sysmon->ept = NULL;
}

static const struct rpmsg_device_id sysmon_match[] = {
	{ "sys_mon" },
	{}
};

static struct rpmsg_driver sysmon_driver = {
	.probe = sysmon_probe,
	.remove = sysmon_remove,
	.callback = sysmon_callback,
	.id_table = sysmon_match,
	.drv = {
		.name = "qcom_sysmon",
	},
};

module_rpmsg_driver(sysmon_driver);

MODULE_DESCRIPTION("Qualcomm sysmon driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1fb82ee8 BA	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2017, Linaro Ltd.
	4	*/
	5	#include <linux/firmware.h>
	6	#include <linux/module.h>
	7	#include <linux/notifier.h>
	8	#include <linux/slab.h>
	9	#include <linux/io.h>
	10	#include <linux/notifier.h>
	11	#include <linux/of_platform.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/remoteproc/qcom_rproc.h>
	14	#include <linux/rpmsg.h>
	15
	16	#include "qcom_common.h"
	17
	18	static BLOCKING_NOTIFIER_HEAD(sysmon_notifiers);
	19
	20	struct qcom_sysmon {
	21	struct rproc_subdev subdev;
	22	struct rproc *rproc;
	23
	24	struct list_head node;
	25
	26	const char *name;
	27
	28	int ssctl_version;
	29	int ssctl_instance;
	30
	31	struct notifier_block nb;
	32
	33	struct device *dev;
	34
	35	struct rpmsg_endpoint *ept;
	36	struct completion comp;
	37	struct mutex lock;
	38
	39	bool ssr_ack;
	40
	41	struct qmi_handle qmi;
	42	struct sockaddr_qrtr ssctl;
	43	};
	44
	45	static DEFINE_MUTEX(sysmon_lock);
	46	static LIST_HEAD(sysmon_list);
	47
	48	/**
	49	* sysmon_send_event() - send notification of other remote's SSR event
	50	* @sysmon: sysmon context
	51	* @name: other remote's name
	52	*/
	53	static void sysmon_send_event(struct qcom_sysmon sysmon, const char name)
	54	{
	55	char req[50];
	56	int len;
	57	int ret;
	58
	59	len = snprintf(req, sizeof(req), "ssr:%s:before_shutdown", name);
	60	if (len >= sizeof(req))
	61	return;
	62
	63	mutex_lock(&sysmon->lock);
	64	reinit_completion(&sysmon->comp);
65	sysmon->ssr_ack = false;
66
67	ret = rpmsg_send(sysmon->ept, req, len);
68	if (ret < 0) {
69	dev_err(sysmon->dev, "failed to send sysmon event\n");
70	goto out_unlock;
71	}
72
73	ret = wait_for_completion_timeout(&sysmon->comp,
74	msecs_to_jiffies(5000));
75	if (!ret) {
76	dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
77	goto out_unlock;
78	}
79
80	if (!sysmon->ssr_ack)
81	dev_err(sysmon->dev, "unexpected response to sysmon event\n");
82
83	out_unlock:
84	mutex_unlock(&sysmon->lock);
85	}
86
87	/**
88	* sysmon_request_shutdown() - request graceful shutdown of remote
89	* @sysmon: sysmon context
90	*/
91	static void sysmon_request_shutdown(struct qcom_sysmon *sysmon)
92	{
93	char *req = "ssr:shutdown";
94	int ret;
95
96	mutex_lock(&sysmon->lock);
97	reinit_completion(&sysmon->comp);
98	sysmon->ssr_ack = false;
99
100	ret = rpmsg_send(sysmon->ept, req, strlen(req) + 1);
101	if (ret < 0) {
102	dev_err(sysmon->dev, "send sysmon shutdown request failed\n");
103	goto out_unlock;
104	}
105
106	ret = wait_for_completion_timeout(&sysmon->comp,
107	msecs_to_jiffies(5000));
108	if (!ret) {
109	dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
110	goto out_unlock;
111	}
112
113	if (!sysmon->ssr_ack)
114	dev_err(sysmon->dev,
115	"unexpected response to sysmon shutdown request\n");
116
117	out_unlock:
118	mutex_unlock(&sysmon->lock);
119	}
120
121	static int sysmon_callback(struct rpmsg_device rpdev, void data, int count,
122	void *priv, u32 addr)
123	{
124	struct qcom_sysmon *sysmon = priv;
125	const char *ssr_ack = "ssr:ack";
126	const int ssr_ack_len = strlen(ssr_ack) + 1;
127
128	if (!sysmon)
129	return -EINVAL;
130
131	if (count >= ssr_ack_len && !memcmp(data, ssr_ack, ssr_ack_len))
132	sysmon->ssr_ack = true;
133
134	complete(&sysmon->comp);
135
136	return 0;
137	}
138
139	#define SSCTL_SHUTDOWN_REQ 0x21
140	#define SSCTL_SUBSYS_EVENT_REQ 0x23
141
142	#define SSCTL_MAX_MSG_LEN 7
143
144	#define SSCTL_SUBSYS_NAME_LENGTH 15
145
146	enum {
147	SSCTL_SSR_EVENT_BEFORE_POWERUP,
148	SSCTL_SSR_EVENT_AFTER_POWERUP,
149	SSCTL_SSR_EVENT_BEFORE_SHUTDOWN,
150	SSCTL_SSR_EVENT_AFTER_SHUTDOWN,
151	};
152
153	enum {
154	SSCTL_SSR_EVENT_FORCED,
155	SSCTL_SSR_EVENT_GRACEFUL,
156	};
157
158	struct ssctl_shutdown_resp {
159	struct qmi_response_type_v01 resp;
160	};
161
162	static struct qmi_elem_info ssctl_shutdown_resp_ei[] = {
163	{
164	.data_type = QMI_STRUCT,
165	.elem_len = 1,
166	.elem_size = sizeof(struct qmi_response_type_v01),
167	.array_type = NO_ARRAY,
168	.tlv_type = 0x02,
169	.offset = offsetof(struct ssctl_shutdown_resp, resp),
170	.ei_array = qmi_response_type_v01_ei,
171	},
172	{}
173	};
174
175	struct ssctl_subsys_event_req {
176	u8 subsys_name_len;
177	char subsys_name[SSCTL_SUBSYS_NAME_LENGTH];
178	u32 event;
179	u8 evt_driven_valid;
180	u32 evt_driven;
181	};
182
183	static struct qmi_elem_info ssctl_subsys_event_req_ei[] = {
184	{
185	.data_type = QMI_DATA_LEN,
186	.elem_len = 1,
187	.elem_size = sizeof(uint8_t),
188	.array_type = NO_ARRAY,
189	.tlv_type = 0x01,
190	.offset = offsetof(struct ssctl_subsys_event_req,
191	subsys_name_len),
192	.ei_array = NULL,
193	},
194	{
195	.data_type = QMI_UNSIGNED_1_BYTE,
196	.elem_len = SSCTL_SUBSYS_NAME_LENGTH,
197	.elem_size = sizeof(char),
198	.array_type = VAR_LEN_ARRAY,
199	.tlv_type = 0x01,
200	.offset = offsetof(struct ssctl_subsys_event_req,
201	subsys_name),
202	.ei_array = NULL,
203	},
204	{
205	.data_type = QMI_SIGNED_4_BYTE_ENUM,
206	.elem_len = 1,
207	.elem_size = sizeof(uint32_t),
208	.array_type = NO_ARRAY,
209	.tlv_type = 0x02,
210	.offset = offsetof(struct ssctl_subsys_event_req,
211	event),
212	.ei_array = NULL,
213	},
214	{
215	.data_type = QMI_OPT_FLAG,
216	.elem_len = 1,
217	.elem_size = sizeof(uint8_t),
218	.array_type = NO_ARRAY,
219	.tlv_type = 0x10,
220	.offset = offsetof(struct ssctl_subsys_event_req,
221	evt_driven_valid),
222	.ei_array = NULL,
223	},
224	{
225	.data_type = QMI_SIGNED_4_BYTE_ENUM,
226	.elem_len = 1,
227	.elem_size = sizeof(uint32_t),
228	.array_type = NO_ARRAY,
229	.tlv_type = 0x10,
230	.offset = offsetof(struct ssctl_subsys_event_req,
231	evt_driven),
232	.ei_array = NULL,
233	},
234	{}
235	};
236
237	struct ssctl_subsys_event_resp {
238	struct qmi_response_type_v01 resp;
239	};
240
241	static struct qmi_elem_info ssctl_subsys_event_resp_ei[] = {
242	{
243	.data_type = QMI_STRUCT,
244	.elem_len = 1,
245	.elem_size = sizeof(struct qmi_response_type_v01),
246	.array_type = NO_ARRAY,
247	.tlv_type = 0x02,
248	.offset = offsetof(struct ssctl_subsys_event_resp,
249	resp),
250	.ei_array = qmi_response_type_v01_ei,
251	},
252	{}
253	};
254
255	/**
256	* ssctl_request_shutdown() - request shutdown via SSCTL QMI service
257	* @sysmon: sysmon context
258	*/
259	static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)
260	{
261	struct ssctl_shutdown_resp resp;
262	struct qmi_txn txn;
263	int ret;
264
265	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_shutdown_resp_ei, &resp);
266	if (ret < 0) {
267	dev_err(sysmon->dev, "failed to allocate QMI txn\n");
268	return;
269	}
270
271	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
272	SSCTL_SHUTDOWN_REQ, 0, NULL, NULL);
273	if (ret < 0) {
274	dev_err(sysmon->dev, "failed to send shutdown request\n");
275	qmi_txn_cancel(&txn);
276	return;
277	}
278
279	ret = qmi_txn_wait(&txn, 5 * HZ);
280	if (ret < 0)
281	dev_err(sysmon->dev, "failed receiving QMI response\n");
282	else if (resp.resp.result)
283	dev_err(sysmon->dev, "shutdown request failed\n");
284	else
285	dev_dbg(sysmon->dev, "shutdown request completed\n");
286	}
287
288	/**
289	* ssctl_send_event() - send notification of other remote's SSR event
290	* @sysmon: sysmon context
291	* @name: other remote's name
292	*/
293	static void ssctl_send_event(struct qcom_sysmon sysmon, const char name)
294	{
295	struct ssctl_subsys_event_resp resp;
296	struct ssctl_subsys_event_req req;
297	struct qmi_txn txn;
298	int ret;
299
300	memset(&resp, 0, sizeof(resp));
301	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_subsys_event_resp_ei, &resp);
302	if (ret < 0) {
303	dev_err(sysmon->dev, "failed to allocate QMI txn\n");
304	return;
305	}
306
307	memset(&req, 0, sizeof(req));
308	strlcpy(req.subsys_name, name, sizeof(req.subsys_name));
309	req.subsys_name_len = strlen(req.subsys_name);
310	req.event = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN;
311	req.evt_driven_valid = true;
312	req.evt_driven = SSCTL_SSR_EVENT_FORCED;
313
314	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
315	SSCTL_SUBSYS_EVENT_REQ, 40,
316	ssctl_subsys_event_req_ei, &req);
317	if (ret < 0) {
318	dev_err(sysmon->dev, "failed to send shutdown request\n");
319	qmi_txn_cancel(&txn);
320	return;
321	}
322
323	ret = qmi_txn_wait(&txn, 5 * HZ);
324	if (ret < 0)
325	dev_err(sysmon->dev, "failed receiving QMI response\n");
326	else if (resp.resp.result)
327	dev_err(sysmon->dev, "ssr event send failed\n");
328	else
329	dev_dbg(sysmon->dev, "ssr event send completed\n");
330	}
331
332	/**
333	* ssctl_new_server() - QMI callback indicating a new service
334	* @qmi: QMI handle
335	* @svc: service information
336	*
337	* Return: 0 if we're interested in this service, -EINVAL otherwise.
338	*/
339	static int ssctl_new_server(struct qmi_handle qmi, struct qmi_service svc)
340	{
341	struct qcom_sysmon *sysmon = container_of(qmi, struct qcom_sysmon, qmi);
342
343	switch (svc->version) {
344	case 1:
345	if (svc->instance != 0)
346	return -EINVAL;
347	if (strcmp(sysmon->name, "modem"))
348	return -EINVAL;
349	break;
350	case 2:
351	if (svc->instance != sysmon->ssctl_instance)
352	return -EINVAL;
353	break;
354	default:
355	return -EINVAL;
356	};
357
358	sysmon->ssctl_version = svc->version;
359
360	sysmon->ssctl.sq_family = AF_QIPCRTR;
361	sysmon->ssctl.sq_node = svc->node;
362	sysmon->ssctl.sq_port = svc->port;
363
364	svc->priv = sysmon;
365
366	return 0;
367	}
368
369	/**
370	* ssctl_del_server() - QMI callback indicating that @svc is removed
371	* @qmi: QMI handle
372	* @svc: service information
373	*/
374	static void ssctl_del_server(struct qmi_handle qmi, struct qmi_service svc)
375	{
376	struct qcom_sysmon *sysmon = svc->priv;
377
378	sysmon->ssctl_version = 0;
379	}
380
381	static const struct qmi_ops ssctl_ops = {
382	.new_server = ssctl_new_server,
383	.del_server = ssctl_del_server,
384	};
385
386	static int sysmon_start(struct rproc_subdev *subdev)
387	{
388	return 0;
389	}
390
391	static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)
392	{
393	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev);
394
395	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)sysmon->name);
396
397	/* Don't request graceful shutdown if we've crashed */
398	if (crashed)
399	return;
400
401	if (sysmon->ssctl_version)
402	ssctl_request_shutdown(sysmon);
403	else if (sysmon->ept)
404	sysmon_request_shutdown(sysmon);
405	}
406
407	/**
408	* sysmon_notify() - notify sysmon target of another's SSR
409	* @nb: notifier_block associated with sysmon instance
410	* @event: unused
411	* @data: SSR identifier of the remote that is going down
412	*/
413	static int sysmon_notify(struct notifier_block *nb, unsigned long event,
414	void *data)
415	{
416	struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);
417	struct rproc *rproc = sysmon->rproc;
418	const char *ssr_name = data;
419
420	/* Skip non-running rprocs and the originating instance */
421	if (rproc->state != RPROC_RUNNING \|\| !strcmp(data, sysmon->name)) {
422	dev_dbg(sysmon->dev, "not notifying %s\n", sysmon->name);
423	return NOTIFY_DONE;
424	}
425
426	/* Only SSCTL version 2 supports SSR events */
427	if (sysmon->ssctl_version == 2)
428	ssctl_send_event(sysmon, ssr_name);
429	else if (sysmon->ept)
430	sysmon_send_event(sysmon, ssr_name);
431
432	return NOTIFY_DONE;
433	}
434
435	/**
436	* qcom_add_sysmon_subdev() - create a sysmon subdev for the given remoteproc
437	* @rproc: rproc context to associate the subdev with
438	* @name: name of this subdev, to use in SSR
439	* @ssctl_instance: instance id of the ssctl QMI service
440	*
441	* Return: A new qcom_sysmon object, or NULL on failure
442	*/
443	struct qcom_sysmon qcom_add_sysmon_subdev(struct rproc rproc,
444	const char *name,
445	int ssctl_instance)
446	{
447	struct qcom_sysmon *sysmon;
448	int ret;
449
450	sysmon = kzalloc(sizeof(*sysmon), GFP_KERNEL);
451	if (!sysmon)
452	return NULL;
453
454	sysmon->dev = rproc->dev.parent;
455	sysmon->rproc = rproc;
456
457	sysmon->name = name;
458	sysmon->ssctl_instance = ssctl_instance;
459
460	init_completion(&sysmon->comp);
461	mutex_init(&sysmon->lock);
462
463	ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops, NULL);
464	if (ret < 0) {
465	dev_err(sysmon->dev, "failed to initialize qmi handle\n");
466	kfree(sysmon);
467	return NULL;
468	}
469
470	qmi_add_lookup(&sysmon->qmi, 43, 0, 0);
471
4902676f BA	472	sysmon->subdev.start = sysmon_start;
	473	sysmon->subdev.stop = sysmon_stop;
	474
	475	rproc_add_subdev(rproc, &sysmon->subdev);
1fb82ee8 BA	476
	477	sysmon->nb.notifier_call = sysmon_notify;
	478	blocking_notifier_chain_register(&sysmon_notifiers, &sysmon->nb);
	479
	480	mutex_lock(&sysmon_lock);
	481	list_add(&sysmon->node, &sysmon_list);
	482	mutex_unlock(&sysmon_lock);
	483
	484	return sysmon;
	485	}
	486	EXPORT_SYMBOL_GPL(qcom_add_sysmon_subdev);
	487
	488	/**
	489	* qcom_remove_sysmon_subdev() - release a qcom_sysmon
	490	* @sysmon: sysmon context, as retrieved by qcom_add_sysmon_subdev()
	491	*/
	492	void qcom_remove_sysmon_subdev(struct qcom_sysmon *sysmon)
	493	{
	494	if (!sysmon)
	495	return;
	496
	497	mutex_lock(&sysmon_lock);
	498	list_del(&sysmon->node);
	499	mutex_unlock(&sysmon_lock);
	500
	501	blocking_notifier_chain_unregister(&sysmon_notifiers, &sysmon->nb);
	502
	503	rproc_remove_subdev(sysmon->rproc, &sysmon->subdev);
	504
	505	qmi_handle_release(&sysmon->qmi);
	506
	507	kfree(sysmon);
	508	}
	509	EXPORT_SYMBOL_GPL(qcom_remove_sysmon_subdev);
	510
	511	/**
	512	* sysmon_probe() - probe sys_mon channel
	513	* @rpdev: rpmsg device handle
	514	*
	515	* Find the sysmon context associated with the ancestor remoteproc and assign
	516	* this rpmsg device with said sysmon context.
	517	*
	518	* Return: 0 on success, negative errno on failure.
	519	*/
	520	static int sysmon_probe(struct rpmsg_device *rpdev)
	521	{
	522	struct qcom_sysmon *sysmon;
	523	struct rproc *rproc;
	524
	525	rproc = rproc_get_by_child(&rpdev->dev);
	526	if (!rproc) {
	527	dev_err(&rpdev->dev, "sysmon device not child of rproc\n");
	528	return -EINVAL;
	529	}
	530
	531	mutex_lock(&sysmon_lock);
	532	list_for_each_entry(sysmon, &sysmon_list, node) {
	533	if (sysmon->rproc == rproc)
	534	goto found;
	535	}
	536	mutex_unlock(&sysmon_lock);
	537
	538	dev_err(&rpdev->dev, "no sysmon associated with parent rproc\n");
	539
540	return -EINVAL;
541
542	found:
543	mutex_unlock(&sysmon_lock);
544
545	rpdev->ept->priv = sysmon;
546	sysmon->ept = rpdev->ept;
547
548	return 0;
549	}
550
551	/**
552	* sysmon_remove() - sys_mon channel remove handler
553	* @rpdev: rpmsg device handle
554	*
555	* Disassociate the rpmsg device with the sysmon instance.
556	*/
557	static void sysmon_remove(struct rpmsg_device *rpdev)
558	{
559	struct qcom_sysmon *sysmon = rpdev->ept->priv;
560
561	sysmon->ept = NULL;
562	}
563
564	static const struct rpmsg_device_id sysmon_match[] = {
565	{ "sys_mon" },
566	{}
567	};
568
569	static struct rpmsg_driver sysmon_driver = {
570	.probe = sysmon_probe,
571	.remove = sysmon_remove,
572	.callback = sysmon_callback,
573	.id_table = sysmon_match,
574	.drv = {
575	.name = "qcom_sysmon",
576	},
577	};
578
579	module_rpmsg_driver(sysmon_driver);
580
581	MODULE_DESCRIPTION("Qualcomm sysmon driver");
582	MODULE_LICENSE("GPL v2");