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/interrupt.h>
10 #include <linux/io.h>
11 #include <linux/of_irq.h>
12 #include <linux/of_platform.h>
13 #include <linux/platform_device.h>
14 #include <linux/remoteproc/qcom_rproc.h>
15 #include <linux/rpmsg.h>
16 
17 #include "qcom_common.h"
18 
19 static BLOCKING_NOTIFIER_HEAD(sysmon_notifiers);
20 
21 struct qcom_sysmon {
22 	struct rproc_subdev subdev;
23 	struct rproc *rproc;
24 
25 	int state;
26 	struct mutex state_lock;
27 
28 	struct list_head node;
29 
30 	const char *name;
31 
32 	int shutdown_irq;
33 	int ssctl_version;
34 	int ssctl_instance;
35 
36 	struct notifier_block nb;
37 
38 	struct device *dev;
39 
40 	struct rpmsg_endpoint *ept;
41 	struct completion comp;
42 	struct completion ind_comp;
43 	struct completion shutdown_comp;
44 	struct mutex lock;
45 
46 	bool ssr_ack;
47 	bool shutdown_acked;
48 
49 	struct qmi_handle qmi;
50 	struct sockaddr_qrtr ssctl;
51 };
52 
53 enum {
54 	SSCTL_SSR_EVENT_BEFORE_POWERUP,
55 	SSCTL_SSR_EVENT_AFTER_POWERUP,
56 	SSCTL_SSR_EVENT_BEFORE_SHUTDOWN,
57 	SSCTL_SSR_EVENT_AFTER_SHUTDOWN,
58 };
59 
60 static const char * const sysmon_state_string[] = {
61 	[SSCTL_SSR_EVENT_BEFORE_POWERUP]	= "before_powerup",
62 	[SSCTL_SSR_EVENT_AFTER_POWERUP]		= "after_powerup",
63 	[SSCTL_SSR_EVENT_BEFORE_SHUTDOWN]	= "before_shutdown",
64 	[SSCTL_SSR_EVENT_AFTER_SHUTDOWN]	= "after_shutdown",
65 };
66 
67 struct sysmon_event {
68 	const char *subsys_name;
69 	u32 ssr_event;
70 };
71 
72 static DEFINE_MUTEX(sysmon_lock);
73 static LIST_HEAD(sysmon_list);
74 
75 /**
76  * sysmon_send_event() - send notification of other remote's SSR event
77  * @sysmon:	sysmon context
78  * @event:	sysmon event context
79  */
80 static void sysmon_send_event(struct qcom_sysmon *sysmon,
81 			      const struct sysmon_event *event)
82 {
83 	char req[50];
84 	int len;
85 	int ret;
86 
87 	len = snprintf(req, sizeof(req), "ssr:%s:%s", event->subsys_name,
88 		       sysmon_state_string[event->ssr_event]);
89 	if (len >= sizeof(req))
90 		return;
91 
92 	mutex_lock(&sysmon->lock);
93 	reinit_completion(&sysmon->comp);
94 	sysmon->ssr_ack = false;
95 
96 	ret = rpmsg_send(sysmon->ept, req, len);
97 	if (ret < 0) {
98 		dev_err(sysmon->dev, "failed to send sysmon event\n");
99 		goto out_unlock;
100 	}
101 
102 	ret = wait_for_completion_timeout(&sysmon->comp,
103 					  msecs_to_jiffies(5000));
104 	if (!ret) {
105 		dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
106 		goto out_unlock;
107 	}
108 
109 	if (!sysmon->ssr_ack)
110 		dev_err(sysmon->dev, "unexpected response to sysmon event\n");
111 
112 out_unlock:
113 	mutex_unlock(&sysmon->lock);
114 }
115 
116 /**
117  * sysmon_request_shutdown() - request graceful shutdown of remote
118  * @sysmon:	sysmon context
119  *
120  * Return: boolean indicator of the remote processor acking the request
121  */
122 static bool sysmon_request_shutdown(struct qcom_sysmon *sysmon)
123 {
124 	char *req = "ssr:shutdown";
125 	bool acked = false;
126 	int ret;
127 
128 	mutex_lock(&sysmon->lock);
129 	reinit_completion(&sysmon->comp);
130 	sysmon->ssr_ack = false;
131 
132 	ret = rpmsg_send(sysmon->ept, req, strlen(req) + 1);
133 	if (ret < 0) {
134 		dev_err(sysmon->dev, "send sysmon shutdown request failed\n");
135 		goto out_unlock;
136 	}
137 
138 	ret = wait_for_completion_timeout(&sysmon->comp,
139 					  msecs_to_jiffies(5000));
140 	if (!ret) {
141 		dev_err(sysmon->dev, "timeout waiting for sysmon ack\n");
142 		goto out_unlock;
143 	}
144 
145 	if (!sysmon->ssr_ack)
146 		dev_err(sysmon->dev,
147 			"unexpected response to sysmon shutdown request\n");
148 	else
149 		acked = true;
150 
151 out_unlock:
152 	mutex_unlock(&sysmon->lock);
153 
154 	return acked;
155 }
156 
157 static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,
158 			   void *priv, u32 addr)
159 {
160 	struct qcom_sysmon *sysmon = priv;
161 	const char *ssr_ack = "ssr:ack";
162 	const int ssr_ack_len = strlen(ssr_ack) + 1;
163 
164 	if (!sysmon)
165 		return -EINVAL;
166 
167 	if (count >= ssr_ack_len && !memcmp(data, ssr_ack, ssr_ack_len))
168 		sysmon->ssr_ack = true;
169 
170 	complete(&sysmon->comp);
171 
172 	return 0;
173 }
174 
175 #define SSCTL_SHUTDOWN_REQ		0x21
176 #define SSCTL_SHUTDOWN_READY_IND	0x21
177 #define SSCTL_SUBSYS_EVENT_REQ		0x23
178 
179 #define SSCTL_MAX_MSG_LEN		7
180 
181 #define SSCTL_SUBSYS_NAME_LENGTH	15
182 
183 enum {
184 	SSCTL_SSR_EVENT_FORCED,
185 	SSCTL_SSR_EVENT_GRACEFUL,
186 };
187 
188 struct ssctl_shutdown_resp {
189 	struct qmi_response_type_v01 resp;
190 };
191 
192 static struct qmi_elem_info ssctl_shutdown_resp_ei[] = {
193 	{
194 		.data_type	= QMI_STRUCT,
195 		.elem_len	= 1,
196 		.elem_size	= sizeof(struct qmi_response_type_v01),
197 		.array_type	= NO_ARRAY,
198 		.tlv_type	= 0x02,
199 		.offset		= offsetof(struct ssctl_shutdown_resp, resp),
200 		.ei_array	= qmi_response_type_v01_ei,
201 	},
202 	{}
203 };
204 
205 struct ssctl_subsys_event_req {
206 	u8 subsys_name_len;
207 	char subsys_name[SSCTL_SUBSYS_NAME_LENGTH];
208 	u32 event;
209 	u8 evt_driven_valid;
210 	u32 evt_driven;
211 };
212 
213 static struct qmi_elem_info ssctl_subsys_event_req_ei[] = {
214 	{
215 		.data_type	= QMI_DATA_LEN,
216 		.elem_len	= 1,
217 		.elem_size	= sizeof(uint8_t),
218 		.array_type	= NO_ARRAY,
219 		.tlv_type	= 0x01,
220 		.offset		= offsetof(struct ssctl_subsys_event_req,
221 					   subsys_name_len),
222 		.ei_array	= NULL,
223 	},
224 	{
225 		.data_type	= QMI_UNSIGNED_1_BYTE,
226 		.elem_len	= SSCTL_SUBSYS_NAME_LENGTH,
227 		.elem_size	= sizeof(char),
228 		.array_type	= VAR_LEN_ARRAY,
229 		.tlv_type	= 0x01,
230 		.offset		= offsetof(struct ssctl_subsys_event_req,
231 					   subsys_name),
232 		.ei_array	= NULL,
233 	},
234 	{
235 		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
236 		.elem_len	= 1,
237 		.elem_size	= sizeof(uint32_t),
238 		.array_type	= NO_ARRAY,
239 		.tlv_type	= 0x02,
240 		.offset		= offsetof(struct ssctl_subsys_event_req,
241 					   event),
242 		.ei_array	= NULL,
243 	},
244 	{
245 		.data_type	= QMI_OPT_FLAG,
246 		.elem_len	= 1,
247 		.elem_size	= sizeof(uint8_t),
248 		.array_type	= NO_ARRAY,
249 		.tlv_type	= 0x10,
250 		.offset		= offsetof(struct ssctl_subsys_event_req,
251 					   evt_driven_valid),
252 		.ei_array	= NULL,
253 	},
254 	{
255 		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
256 		.elem_len	= 1,
257 		.elem_size	= sizeof(uint32_t),
258 		.array_type	= NO_ARRAY,
259 		.tlv_type	= 0x10,
260 		.offset		= offsetof(struct ssctl_subsys_event_req,
261 					   evt_driven),
262 		.ei_array	= NULL,
263 	},
264 	{}
265 };
266 
267 struct ssctl_subsys_event_resp {
268 	struct qmi_response_type_v01 resp;
269 };
270 
271 static struct qmi_elem_info ssctl_subsys_event_resp_ei[] = {
272 	{
273 		.data_type	= QMI_STRUCT,
274 		.elem_len	= 1,
275 		.elem_size	= sizeof(struct qmi_response_type_v01),
276 		.array_type	= NO_ARRAY,
277 		.tlv_type	= 0x02,
278 		.offset		= offsetof(struct ssctl_subsys_event_resp,
279 					   resp),
280 		.ei_array	= qmi_response_type_v01_ei,
281 	},
282 	{}
283 };
284 
285 static struct qmi_elem_info ssctl_shutdown_ind_ei[] = {
286 	{}
287 };
288 
289 static void sysmon_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
290 			  struct qmi_txn *txn, const void *data)
291 {
292 	struct qcom_sysmon *sysmon = container_of(qmi, struct qcom_sysmon, qmi);
293 
294 	complete(&sysmon->ind_comp);
295 }
296 
297 static const struct qmi_msg_handler qmi_indication_handler[] = {
298 	{
299 		.type = QMI_INDICATION,
300 		.msg_id = SSCTL_SHUTDOWN_READY_IND,
301 		.ei = ssctl_shutdown_ind_ei,
302 		.decoded_size = 0,
303 		.fn = sysmon_ind_cb
304 	},
305 	{}
306 };
307 
308 static bool ssctl_request_shutdown_wait(struct qcom_sysmon *sysmon)
309 {
310 	int ret;
311 
312 	ret = wait_for_completion_timeout(&sysmon->shutdown_comp, 10 * HZ);
313 	if (ret)
314 		return true;
315 
316 	ret = try_wait_for_completion(&sysmon->ind_comp);
317 	if (ret)
318 		return true;
319 
320 	dev_err(sysmon->dev, "timeout waiting for shutdown ack\n");
321 	return false;
322 }
323 
324 /**
325  * ssctl_request_shutdown() - request shutdown via SSCTL QMI service
326  * @sysmon:	sysmon context
327  *
328  * Return: boolean indicator of the remote processor acking the request
329  */
330 static bool ssctl_request_shutdown(struct qcom_sysmon *sysmon)
331 {
332 	struct ssctl_shutdown_resp resp;
333 	struct qmi_txn txn;
334 	bool acked = false;
335 	int ret;
336 
337 	reinit_completion(&sysmon->ind_comp);
338 	reinit_completion(&sysmon->shutdown_comp);
339 	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_shutdown_resp_ei, &resp);
340 	if (ret < 0) {
341 		dev_err(sysmon->dev, "failed to allocate QMI txn\n");
342 		return false;
343 	}
344 
345 	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
346 			       SSCTL_SHUTDOWN_REQ, 0, NULL, NULL);
347 	if (ret < 0) {
348 		dev_err(sysmon->dev, "failed to send shutdown request\n");
349 		qmi_txn_cancel(&txn);
350 		return false;
351 	}
352 
353 	ret = qmi_txn_wait(&txn, 5 * HZ);
354 	if (ret < 0) {
355 		dev_err(sysmon->dev, "timeout waiting for shutdown response\n");
356 	} else if (resp.resp.result) {
357 		dev_err(sysmon->dev, "shutdown request rejected\n");
358 	} else {
359 		dev_dbg(sysmon->dev, "shutdown request completed\n");
360 		acked = true;
361 	}
362 
363 	if (sysmon->shutdown_irq > 0)
364 		return ssctl_request_shutdown_wait(sysmon);
365 
366 	return acked;
367 }
368 
369 /**
370  * ssctl_send_event() - send notification of other remote's SSR event
371  * @sysmon:	sysmon context
372  * @event:	sysmon event context
373  */
374 static void ssctl_send_event(struct qcom_sysmon *sysmon,
375 			     const struct sysmon_event *event)
376 {
377 	struct ssctl_subsys_event_resp resp;
378 	struct ssctl_subsys_event_req req;
379 	struct qmi_txn txn;
380 	int ret;
381 
382 	memset(&resp, 0, sizeof(resp));
383 	ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_subsys_event_resp_ei, &resp);
384 	if (ret < 0) {
385 		dev_err(sysmon->dev, "failed to allocate QMI txn\n");
386 		return;
387 	}
388 
389 	memset(&req, 0, sizeof(req));
390 	strlcpy(req.subsys_name, event->subsys_name, sizeof(req.subsys_name));
391 	req.subsys_name_len = strlen(req.subsys_name);
392 	req.event = event->ssr_event;
393 	req.evt_driven_valid = true;
394 	req.evt_driven = SSCTL_SSR_EVENT_FORCED;
395 
396 	ret = qmi_send_request(&sysmon->qmi, &sysmon->ssctl, &txn,
397 			       SSCTL_SUBSYS_EVENT_REQ, 40,
398 			       ssctl_subsys_event_req_ei, &req);
399 	if (ret < 0) {
400 		dev_err(sysmon->dev, "failed to send subsystem event\n");
401 		qmi_txn_cancel(&txn);
402 		return;
403 	}
404 
405 	ret = qmi_txn_wait(&txn, 5 * HZ);
406 	if (ret < 0)
407 		dev_err(sysmon->dev, "timeout waiting for subsystem event response\n");
408 	else if (resp.resp.result)
409 		dev_err(sysmon->dev, "subsystem event rejected\n");
410 	else
411 		dev_dbg(sysmon->dev, "subsystem event accepted\n");
412 }
413 
414 /**
415  * ssctl_new_server() - QMI callback indicating a new service
416  * @qmi:	QMI handle
417  * @svc:	service information
418  *
419  * Return: 0 if we're interested in this service, -EINVAL otherwise.
420  */
421 static int ssctl_new_server(struct qmi_handle *qmi, struct qmi_service *svc)
422 {
423 	struct qcom_sysmon *sysmon = container_of(qmi, struct qcom_sysmon, qmi);
424 
425 	switch (svc->version) {
426 	case 1:
427 		if (svc->instance != 0)
428 			return -EINVAL;
429 		if (strcmp(sysmon->name, "modem"))
430 			return -EINVAL;
431 		break;
432 	case 2:
433 		if (svc->instance != sysmon->ssctl_instance)
434 			return -EINVAL;
435 		break;
436 	default:
437 		return -EINVAL;
438 	}
439 
440 	sysmon->ssctl_version = svc->version;
441 
442 	sysmon->ssctl.sq_family = AF_QIPCRTR;
443 	sysmon->ssctl.sq_node = svc->node;
444 	sysmon->ssctl.sq_port = svc->port;
445 
446 	svc->priv = sysmon;
447 
448 	return 0;
449 }
450 
451 /**
452  * ssctl_del_server() - QMI callback indicating that @svc is removed
453  * @qmi:	QMI handle
454  * @svc:	service information
455  */
456 static void ssctl_del_server(struct qmi_handle *qmi, struct qmi_service *svc)
457 {
458 	struct qcom_sysmon *sysmon = svc->priv;
459 
460 	sysmon->ssctl_version = 0;
461 }
462 
463 static const struct qmi_ops ssctl_ops = {
464 	.new_server = ssctl_new_server,
465 	.del_server = ssctl_del_server,
466 };
467 
468 static int sysmon_prepare(struct rproc_subdev *subdev)
469 {
470 	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,
471 						  subdev);
472 	struct sysmon_event event = {
473 		.subsys_name = sysmon->name,
474 		.ssr_event = SSCTL_SSR_EVENT_BEFORE_POWERUP
475 	};
476 
477 	mutex_lock(&sysmon->state_lock);
478 	sysmon->state = SSCTL_SSR_EVENT_BEFORE_POWERUP;
479 	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);
480 	mutex_unlock(&sysmon->state_lock);
481 
482 	return 0;
483 }
484 
485 /**
486  * sysmon_start() - start callback for the sysmon remoteproc subdevice
487  * @subdev:	instance of the sysmon subdevice
488  *
489  * Inform all the listners of sysmon notifications that the rproc associated
490  * to @subdev has booted up. The rproc that booted up also needs to know
491  * which rprocs are already up and running, so send start notifications
492  * on behalf of all the online rprocs.
493  */
494 static int sysmon_start(struct rproc_subdev *subdev)
495 {
496 	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,
497 						  subdev);
498 	struct qcom_sysmon *target;
499 	struct sysmon_event event = {
500 		.subsys_name = sysmon->name,
501 		.ssr_event = SSCTL_SSR_EVENT_AFTER_POWERUP
502 	};
503 
504 	mutex_lock(&sysmon->state_lock);
505 	sysmon->state = SSCTL_SSR_EVENT_AFTER_POWERUP;
506 	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);
507 	mutex_unlock(&sysmon->state_lock);
508 
509 	mutex_lock(&sysmon_lock);
510 	list_for_each_entry(target, &sysmon_list, node) {
511 		if (target == sysmon)
512 			continue;
513 
514 		mutex_lock(&target->state_lock);
515 		event.subsys_name = target->name;
516 		event.ssr_event = target->state;
517 
518 		if (sysmon->ssctl_version == 2)
519 			ssctl_send_event(sysmon, &event);
520 		else if (sysmon->ept)
521 			sysmon_send_event(sysmon, &event);
522 		mutex_unlock(&target->state_lock);
523 	}
524 	mutex_unlock(&sysmon_lock);
525 
526 	return 0;
527 }
528 
529 static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)
530 {
531 	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev);
532 	struct sysmon_event event = {
533 		.subsys_name = sysmon->name,
534 		.ssr_event = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN
535 	};
536 
537 	sysmon->shutdown_acked = false;
538 
539 	mutex_lock(&sysmon->state_lock);
540 	sysmon->state = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN;
541 	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);
542 	mutex_unlock(&sysmon->state_lock);
543 
544 	/* Don't request graceful shutdown if we've crashed */
545 	if (crashed)
546 		return;
547 
548 	if (sysmon->ssctl_version)
549 		sysmon->shutdown_acked = ssctl_request_shutdown(sysmon);
550 	else if (sysmon->ept)
551 		sysmon->shutdown_acked = sysmon_request_shutdown(sysmon);
552 }
553 
554 static void sysmon_unprepare(struct rproc_subdev *subdev)
555 {
556 	struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,
557 						  subdev);
558 	struct sysmon_event event = {
559 		.subsys_name = sysmon->name,
560 		.ssr_event = SSCTL_SSR_EVENT_AFTER_SHUTDOWN
561 	};
562 
563 	mutex_lock(&sysmon->state_lock);
564 	sysmon->state = SSCTL_SSR_EVENT_AFTER_SHUTDOWN;
565 	blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);
566 	mutex_unlock(&sysmon->state_lock);
567 }
568 
569 /**
570  * sysmon_notify() - notify sysmon target of another's SSR
571  * @nb:		notifier_block associated with sysmon instance
572  * @event:	unused
573  * @data:	SSR identifier of the remote that is going down
574  */
575 static int sysmon_notify(struct notifier_block *nb, unsigned long event,
576 			 void *data)
577 {
578 	struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);
579 	struct sysmon_event *sysmon_event = data;
580 
581 	/* Skip non-running rprocs and the originating instance */
582 	if (sysmon->state != SSCTL_SSR_EVENT_AFTER_POWERUP ||
583 	    !strcmp(sysmon_event->subsys_name, sysmon->name)) {
584 		dev_dbg(sysmon->dev, "not notifying %s\n", sysmon->name);
585 		return NOTIFY_DONE;
586 	}
587 
588 	/* Only SSCTL version 2 supports SSR events */
589 	if (sysmon->ssctl_version == 2)
590 		ssctl_send_event(sysmon, sysmon_event);
591 	else if (sysmon->ept)
592 		sysmon_send_event(sysmon, sysmon_event);
593 
594 	return NOTIFY_DONE;
595 }
596 
597 static irqreturn_t sysmon_shutdown_interrupt(int irq, void *data)
598 {
599 	struct qcom_sysmon *sysmon = data;
600 
601 	complete(&sysmon->shutdown_comp);
602 
603 	return IRQ_HANDLED;
604 }
605 
606 /**
607  * qcom_add_sysmon_subdev() - create a sysmon subdev for the given remoteproc
608  * @rproc:	rproc context to associate the subdev with
609  * @name:	name of this subdev, to use in SSR
610  * @ssctl_instance: instance id of the ssctl QMI service
611  *
612  * Return: A new qcom_sysmon object, or NULL on failure
613  */
614 struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,
615 					   const char *name,
616 					   int ssctl_instance)
617 {
618 	struct qcom_sysmon *sysmon;
619 	int ret;
620 
621 	sysmon = kzalloc(sizeof(*sysmon), GFP_KERNEL);
622 	if (!sysmon)
623 		return ERR_PTR(-ENOMEM);
624 
625 	sysmon->dev = rproc->dev.parent;
626 	sysmon->rproc = rproc;
627 
628 	sysmon->name = name;
629 	sysmon->ssctl_instance = ssctl_instance;
630 
631 	init_completion(&sysmon->comp);
632 	init_completion(&sysmon->ind_comp);
633 	init_completion(&sysmon->shutdown_comp);
634 	mutex_init(&sysmon->lock);
635 	mutex_init(&sysmon->state_lock);
636 
637 	sysmon->shutdown_irq = of_irq_get_byname(sysmon->dev->of_node,
638 						 "shutdown-ack");
639 	if (sysmon->shutdown_irq < 0) {
640 		if (sysmon->shutdown_irq != -ENODATA) {
641 			dev_err(sysmon->dev,
642 				"failed to retrieve shutdown-ack IRQ\n");
643 			return ERR_PTR(sysmon->shutdown_irq);
644 		}
645 	} else {
646 		ret = devm_request_threaded_irq(sysmon->dev,
647 						sysmon->shutdown_irq,
648 						NULL, sysmon_shutdown_interrupt,
649 						IRQF_TRIGGER_RISING | IRQF_ONESHOT,
650 						"q6v5 shutdown-ack", sysmon);
651 		if (ret) {
652 			dev_err(sysmon->dev,
653 				"failed to acquire shutdown-ack IRQ\n");
654 			return ERR_PTR(ret);
655 		}
656 	}
657 
658 	ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops,
659 			      qmi_indication_handler);
660 	if (ret < 0) {
661 		dev_err(sysmon->dev, "failed to initialize qmi handle\n");
662 		kfree(sysmon);
663 		return ERR_PTR(ret);
664 	}
665 
666 	qmi_add_lookup(&sysmon->qmi, 43, 0, 0);
667 
668 	sysmon->subdev.prepare = sysmon_prepare;
669 	sysmon->subdev.start = sysmon_start;
670 	sysmon->subdev.stop = sysmon_stop;
671 	sysmon->subdev.unprepare = sysmon_unprepare;
672 
673 	rproc_add_subdev(rproc, &sysmon->subdev);
674 
675 	sysmon->nb.notifier_call = sysmon_notify;
676 	blocking_notifier_chain_register(&sysmon_notifiers, &sysmon->nb);
677 
678 	mutex_lock(&sysmon_lock);
679 	list_add(&sysmon->node, &sysmon_list);
680 	mutex_unlock(&sysmon_lock);
681 
682 	return sysmon;
683 }
684 EXPORT_SYMBOL_GPL(qcom_add_sysmon_subdev);
685 
686 /**
687  * qcom_remove_sysmon_subdev() - release a qcom_sysmon
688  * @sysmon:	sysmon context, as retrieved by qcom_add_sysmon_subdev()
689  */
690 void qcom_remove_sysmon_subdev(struct qcom_sysmon *sysmon)
691 {
692 	if (!sysmon)
693 		return;
694 
695 	mutex_lock(&sysmon_lock);
696 	list_del(&sysmon->node);
697 	mutex_unlock(&sysmon_lock);
698 
699 	blocking_notifier_chain_unregister(&sysmon_notifiers, &sysmon->nb);
700 
701 	rproc_remove_subdev(sysmon->rproc, &sysmon->subdev);
702 
703 	qmi_handle_release(&sysmon->qmi);
704 
705 	kfree(sysmon);
706 }
707 EXPORT_SYMBOL_GPL(qcom_remove_sysmon_subdev);
708 
709 /**
710  * qcom_sysmon_shutdown_acked() - query the success of the last shutdown
711  * @sysmon:	sysmon context
712  *
713  * When sysmon is used to request a graceful shutdown of the remote processor
714  * this can be used by the remoteproc driver to query the success, in order to
715  * know if it should fall back to other means of requesting a shutdown.
716  *
717  * Return: boolean indicator of the success of the last shutdown request
718  */
719 bool qcom_sysmon_shutdown_acked(struct qcom_sysmon *sysmon)
720 {
721 	return sysmon && sysmon->shutdown_acked;
722 }
723 EXPORT_SYMBOL_GPL(qcom_sysmon_shutdown_acked);
724 
725 /**
726  * sysmon_probe() - probe sys_mon channel
727  * @rpdev:	rpmsg device handle
728  *
729  * Find the sysmon context associated with the ancestor remoteproc and assign
730  * this rpmsg device with said sysmon context.
731  *
732  * Return: 0 on success, negative errno on failure.
733  */
734 static int sysmon_probe(struct rpmsg_device *rpdev)
735 {
736 	struct qcom_sysmon *sysmon;
737 	struct rproc *rproc;
738 
739 	rproc = rproc_get_by_child(&rpdev->dev);
740 	if (!rproc) {
741 		dev_err(&rpdev->dev, "sysmon device not child of rproc\n");
742 		return -EINVAL;
743 	}
744 
745 	mutex_lock(&sysmon_lock);
746 	list_for_each_entry(sysmon, &sysmon_list, node) {
747 		if (sysmon->rproc == rproc)
748 			goto found;
749 	}
750 	mutex_unlock(&sysmon_lock);
751 
752 	dev_err(&rpdev->dev, "no sysmon associated with parent rproc\n");
753 
754 	return -EINVAL;
755 
756 found:
757 	mutex_unlock(&sysmon_lock);
758 
759 	rpdev->ept->priv = sysmon;
760 	sysmon->ept = rpdev->ept;
761 
762 	return 0;
763 }
764 
765 /**
766  * sysmon_remove() - sys_mon channel remove handler
767  * @rpdev:	rpmsg device handle
768  *
769  * Disassociate the rpmsg device with the sysmon instance.
770  */
771 static void sysmon_remove(struct rpmsg_device *rpdev)
772 {
773 	struct qcom_sysmon *sysmon = rpdev->ept->priv;
774 
775 	sysmon->ept = NULL;
776 }
777 
778 static const struct rpmsg_device_id sysmon_match[] = {
779 	{ "sys_mon" },
780 	{}
781 };
782 
783 static struct rpmsg_driver sysmon_driver = {
784 	.probe = sysmon_probe,
785 	.remove = sysmon_remove,
786 	.callback = sysmon_callback,
787 	.id_table = sysmon_match,
788 	.drv = {
789 		.name = "qcom_sysmon",
790 	},
791 };
792 
793 module_rpmsg_driver(sysmon_driver);
794 
795 MODULE_DESCRIPTION("Qualcomm sysmon driver");
796 MODULE_LICENSE("GPL v2");
797