811 lines · c
1// SPDX-License-Identifier: GPL-2.02/*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/platform_device.h>13#include <linux/remoteproc/qcom_rproc.h>14#include <linux/rpmsg.h>15 16#include "qcom_common.h"17 18static BLOCKING_NOTIFIER_HEAD(sysmon_notifiers);19 20struct qcom_sysmon {21 struct rproc_subdev subdev;22 struct rproc *rproc;23 24 int state;25 struct mutex state_lock;26 27 struct list_head node;28 29 const char *name;30 31 int shutdown_irq;32 int ssctl_version;33 int ssctl_instance;34 35 struct notifier_block nb;36 37 struct device *dev;38 39 struct rpmsg_endpoint *ept;40 struct completion comp;41 struct completion ind_comp;42 struct completion shutdown_comp;43 struct completion ssctl_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 53enum {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 60static 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 67struct sysmon_event {68 const char *subsys_name;69 u32 ssr_event;70};71 72static DEFINE_MUTEX(sysmon_lock);73static LIST_HEAD(sysmon_list);74 75/**76 * sysmon_send_event() - send notification of other remote's SSR event77 * @sysmon: sysmon context78 * @event: sysmon event context79 */80static 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 112out_unlock:113 mutex_unlock(&sysmon->lock);114}115 116/**117 * sysmon_request_shutdown() - request graceful shutdown of remote118 * @sysmon: sysmon context119 *120 * Return: boolean indicator of the remote processor acking the request121 */122static 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 else149 acked = true;150 151out_unlock:152 mutex_unlock(&sysmon->lock);153 154 return acked;155}156 157static 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 0x21176#define SSCTL_SHUTDOWN_READY_IND 0x21177#define SSCTL_SUBSYS_EVENT_REQ 0x23178 179#define SSCTL_MAX_MSG_LEN 7180 181#define SSCTL_SUBSYS_NAME_LENGTH 15182 183enum {184 SSCTL_SSR_EVENT_FORCED,185 SSCTL_SSR_EVENT_GRACEFUL,186};187 188struct ssctl_shutdown_resp {189 struct qmi_response_type_v01 resp;190};191 192static const 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 205struct 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 213static const 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 267struct ssctl_subsys_event_resp {268 struct qmi_response_type_v01 resp;269};270 271static const 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 285static const struct qmi_elem_info ssctl_shutdown_ind_ei[] = {286 {}287};288 289static 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 297static 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_cb304 },305 {}306};307 308static 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 service326 * @sysmon: sysmon context327 *328 * Return: boolean indicator of the remote processor acking the request329 */330static 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 event371 * @sysmon: sysmon context372 * @event: sysmon event context373 */374static 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 strscpy(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 else411 dev_dbg(sysmon->dev, "subsystem event accepted\n");412}413 414/**415 * ssctl_new_server() - QMI callback indicating a new service416 * @qmi: QMI handle417 * @svc: service information418 *419 * Return: 0 if we're interested in this service, -EINVAL otherwise.420 */421static 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 complete(&sysmon->ssctl_comp);449 450 return 0;451}452 453/**454 * ssctl_del_server() - QMI callback indicating that @svc is removed455 * @qmi: QMI handle456 * @svc: service information457 */458static void ssctl_del_server(struct qmi_handle *qmi, struct qmi_service *svc)459{460 struct qcom_sysmon *sysmon = svc->priv;461 462 sysmon->ssctl_version = 0;463}464 465static const struct qmi_ops ssctl_ops = {466 .new_server = ssctl_new_server,467 .del_server = ssctl_del_server,468};469 470static int sysmon_prepare(struct rproc_subdev *subdev)471{472 struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,473 subdev);474 struct sysmon_event event = {475 .subsys_name = sysmon->name,476 .ssr_event = SSCTL_SSR_EVENT_BEFORE_POWERUP477 };478 479 mutex_lock(&sysmon->state_lock);480 sysmon->state = SSCTL_SSR_EVENT_BEFORE_POWERUP;481 blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);482 mutex_unlock(&sysmon->state_lock);483 484 return 0;485}486 487/**488 * sysmon_start() - start callback for the sysmon remoteproc subdevice489 * @subdev: instance of the sysmon subdevice490 *491 * Inform all the listners of sysmon notifications that the rproc associated492 * to @subdev has booted up. The rproc that booted up also needs to know493 * which rprocs are already up and running, so send start notifications494 * on behalf of all the online rprocs.495 */496static int sysmon_start(struct rproc_subdev *subdev)497{498 struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,499 subdev);500 struct qcom_sysmon *target;501 struct sysmon_event event = {502 .subsys_name = sysmon->name,503 .ssr_event = SSCTL_SSR_EVENT_AFTER_POWERUP504 };505 506 reinit_completion(&sysmon->ssctl_comp);507 mutex_lock(&sysmon->state_lock);508 sysmon->state = SSCTL_SSR_EVENT_AFTER_POWERUP;509 blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);510 mutex_unlock(&sysmon->state_lock);511 512 mutex_lock(&sysmon_lock);513 list_for_each_entry(target, &sysmon_list, node) {514 mutex_lock(&target->state_lock);515 if (target == sysmon || target->state != SSCTL_SSR_EVENT_AFTER_POWERUP) {516 mutex_unlock(&target->state_lock);517 continue;518 }519 520 event.subsys_name = target->name;521 event.ssr_event = target->state;522 523 if (sysmon->ssctl_version == 2)524 ssctl_send_event(sysmon, &event);525 else if (sysmon->ept)526 sysmon_send_event(sysmon, &event);527 mutex_unlock(&target->state_lock);528 }529 mutex_unlock(&sysmon_lock);530 531 return 0;532}533 534static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)535{536 struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev);537 struct sysmon_event event = {538 .subsys_name = sysmon->name,539 .ssr_event = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN540 };541 542 sysmon->shutdown_acked = false;543 544 mutex_lock(&sysmon->state_lock);545 sysmon->state = SSCTL_SSR_EVENT_BEFORE_SHUTDOWN;546 blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);547 mutex_unlock(&sysmon->state_lock);548 549 /* Don't request graceful shutdown if we've crashed */550 if (crashed)551 return;552 553 if (sysmon->ssctl_instance) {554 if (!wait_for_completion_timeout(&sysmon->ssctl_comp, HZ / 2))555 dev_err(sysmon->dev, "timeout waiting for ssctl service\n");556 }557 558 if (sysmon->ssctl_version)559 sysmon->shutdown_acked = ssctl_request_shutdown(sysmon);560 else if (sysmon->ept)561 sysmon->shutdown_acked = sysmon_request_shutdown(sysmon);562}563 564static void sysmon_unprepare(struct rproc_subdev *subdev)565{566 struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon,567 subdev);568 struct sysmon_event event = {569 .subsys_name = sysmon->name,570 .ssr_event = SSCTL_SSR_EVENT_AFTER_SHUTDOWN571 };572 573 mutex_lock(&sysmon->state_lock);574 sysmon->state = SSCTL_SSR_EVENT_AFTER_SHUTDOWN;575 blocking_notifier_call_chain(&sysmon_notifiers, 0, (void *)&event);576 mutex_unlock(&sysmon->state_lock);577}578 579/**580 * sysmon_notify() - notify sysmon target of another's SSR581 * @nb: notifier_block associated with sysmon instance582 * @event: unused583 * @data: SSR identifier of the remote that is going down584 */585static int sysmon_notify(struct notifier_block *nb, unsigned long event,586 void *data)587{588 struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);589 struct sysmon_event *sysmon_event = data;590 591 /* Skip non-running rprocs and the originating instance */592 if (sysmon->state != SSCTL_SSR_EVENT_AFTER_POWERUP ||593 !strcmp(sysmon_event->subsys_name, sysmon->name)) {594 dev_dbg(sysmon->dev, "not notifying %s\n", sysmon->name);595 return NOTIFY_DONE;596 }597 598 /* Only SSCTL version 2 supports SSR events */599 if (sysmon->ssctl_version == 2)600 ssctl_send_event(sysmon, sysmon_event);601 else if (sysmon->ept)602 sysmon_send_event(sysmon, sysmon_event);603 604 return NOTIFY_DONE;605}606 607static irqreturn_t sysmon_shutdown_interrupt(int irq, void *data)608{609 struct qcom_sysmon *sysmon = data;610 611 complete(&sysmon->shutdown_comp);612 613 return IRQ_HANDLED;614}615 616/**617 * qcom_add_sysmon_subdev() - create a sysmon subdev for the given remoteproc618 * @rproc: rproc context to associate the subdev with619 * @name: name of this subdev, to use in SSR620 * @ssctl_instance: instance id of the ssctl QMI service621 *622 * Return: A new qcom_sysmon object, or NULL on failure623 */624struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,625 const char *name,626 int ssctl_instance)627{628 struct qcom_sysmon *sysmon;629 int ret;630 631 sysmon = kzalloc(sizeof(*sysmon), GFP_KERNEL);632 if (!sysmon)633 return ERR_PTR(-ENOMEM);634 635 sysmon->dev = rproc->dev.parent;636 sysmon->rproc = rproc;637 638 sysmon->name = name;639 sysmon->ssctl_instance = ssctl_instance;640 641 init_completion(&sysmon->comp);642 init_completion(&sysmon->ind_comp);643 init_completion(&sysmon->shutdown_comp);644 init_completion(&sysmon->ssctl_comp);645 mutex_init(&sysmon->lock);646 mutex_init(&sysmon->state_lock);647 648 sysmon->shutdown_irq = of_irq_get_byname(sysmon->dev->of_node,649 "shutdown-ack");650 if (sysmon->shutdown_irq < 0) {651 if (sysmon->shutdown_irq != -ENODATA) {652 dev_err(sysmon->dev,653 "failed to retrieve shutdown-ack IRQ\n");654 ret = sysmon->shutdown_irq;655 kfree(sysmon);656 return ERR_PTR(ret);657 }658 } else {659 ret = devm_request_threaded_irq(sysmon->dev,660 sysmon->shutdown_irq,661 NULL, sysmon_shutdown_interrupt,662 IRQF_TRIGGER_RISING | IRQF_ONESHOT,663 "q6v5 shutdown-ack", sysmon);664 if (ret) {665 dev_err(sysmon->dev,666 "failed to acquire shutdown-ack IRQ\n");667 kfree(sysmon);668 return ERR_PTR(ret);669 }670 }671 672 ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops,673 qmi_indication_handler);674 if (ret < 0) {675 dev_err(sysmon->dev, "failed to initialize qmi handle\n");676 kfree(sysmon);677 return ERR_PTR(ret);678 }679 680 qmi_add_lookup(&sysmon->qmi, 43, 0, 0);681 682 sysmon->subdev.prepare = sysmon_prepare;683 sysmon->subdev.start = sysmon_start;684 sysmon->subdev.stop = sysmon_stop;685 sysmon->subdev.unprepare = sysmon_unprepare;686 687 rproc_add_subdev(rproc, &sysmon->subdev);688 689 sysmon->nb.notifier_call = sysmon_notify;690 blocking_notifier_chain_register(&sysmon_notifiers, &sysmon->nb);691 692 mutex_lock(&sysmon_lock);693 list_add(&sysmon->node, &sysmon_list);694 mutex_unlock(&sysmon_lock);695 696 return sysmon;697}698EXPORT_SYMBOL_GPL(qcom_add_sysmon_subdev);699 700/**701 * qcom_remove_sysmon_subdev() - release a qcom_sysmon702 * @sysmon: sysmon context, as retrieved by qcom_add_sysmon_subdev()703 */704void qcom_remove_sysmon_subdev(struct qcom_sysmon *sysmon)705{706 if (!sysmon)707 return;708 709 mutex_lock(&sysmon_lock);710 list_del(&sysmon->node);711 mutex_unlock(&sysmon_lock);712 713 blocking_notifier_chain_unregister(&sysmon_notifiers, &sysmon->nb);714 715 rproc_remove_subdev(sysmon->rproc, &sysmon->subdev);716 717 qmi_handle_release(&sysmon->qmi);718 719 kfree(sysmon);720}721EXPORT_SYMBOL_GPL(qcom_remove_sysmon_subdev);722 723/**724 * qcom_sysmon_shutdown_acked() - query the success of the last shutdown725 * @sysmon: sysmon context726 *727 * When sysmon is used to request a graceful shutdown of the remote processor728 * this can be used by the remoteproc driver to query the success, in order to729 * know if it should fall back to other means of requesting a shutdown.730 *731 * Return: boolean indicator of the success of the last shutdown request732 */733bool qcom_sysmon_shutdown_acked(struct qcom_sysmon *sysmon)734{735 return sysmon && sysmon->shutdown_acked;736}737EXPORT_SYMBOL_GPL(qcom_sysmon_shutdown_acked);738 739/**740 * sysmon_probe() - probe sys_mon channel741 * @rpdev: rpmsg device handle742 *743 * Find the sysmon context associated with the ancestor remoteproc and assign744 * this rpmsg device with said sysmon context.745 *746 * Return: 0 on success, negative errno on failure.747 */748static int sysmon_probe(struct rpmsg_device *rpdev)749{750 struct qcom_sysmon *sysmon;751 struct rproc *rproc;752 753 rproc = rproc_get_by_child(&rpdev->dev);754 if (!rproc) {755 dev_err(&rpdev->dev, "sysmon device not child of rproc\n");756 return -EINVAL;757 }758 759 mutex_lock(&sysmon_lock);760 list_for_each_entry(sysmon, &sysmon_list, node) {761 if (sysmon->rproc == rproc)762 goto found;763 }764 mutex_unlock(&sysmon_lock);765 766 dev_err(&rpdev->dev, "no sysmon associated with parent rproc\n");767 768 return -EINVAL;769 770found:771 mutex_unlock(&sysmon_lock);772 773 rpdev->ept->priv = sysmon;774 sysmon->ept = rpdev->ept;775 776 return 0;777}778 779/**780 * sysmon_remove() - sys_mon channel remove handler781 * @rpdev: rpmsg device handle782 *783 * Disassociate the rpmsg device with the sysmon instance.784 */785static void sysmon_remove(struct rpmsg_device *rpdev)786{787 struct qcom_sysmon *sysmon = rpdev->ept->priv;788 789 sysmon->ept = NULL;790}791 792static const struct rpmsg_device_id sysmon_match[] = {793 { "sys_mon" },794 {}795};796 797static struct rpmsg_driver sysmon_driver = {798 .probe = sysmon_probe,799 .remove = sysmon_remove,800 .callback = sysmon_callback,801 .id_table = sysmon_match,802 .drv = {803 .name = "qcom_sysmon",804 },805};806 807module_rpmsg_driver(sysmon_driver);808 809MODULE_DESCRIPTION("Qualcomm sysmon driver");810MODULE_LICENSE("GPL v2");811