drivers/remoteproc/qcom_sysmon.c

   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/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         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
  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 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
 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 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
 267 struct ssctl_subsys_event_resp {
 268         struct qmi_response_type_v01 resp;
 269 };
 270
 271 static 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
 285 static const 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         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         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         complete(&sysmon->ssctl_comp);
 449
 450         return 0;
 451 }
 452
 453 /**
 454  * ssctl_del_server() - QMI callback indicating that @svc is removed
 455  * @qmi:        QMI handle
 456  * @svc:        service information
 457  */
 458 static 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
 465 static const struct qmi_ops ssctl_ops = {
 466         .new_server = ssctl_new_server,
 467         .del_server = ssctl_del_server,
 468 };
 469
 470 static 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_POWERUP
 477         };
 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 subdevice
 489  * @subdev:     instance of the sysmon subdevice
 490  *
 491  * Inform all the listners of sysmon notifications that the rproc associated
 492  * to @subdev has booted up. The rproc that booted up also needs to know
 493  * which rprocs are already up and running, so send start notifications
 494  * on behalf of all the online rprocs.
 495  */
 496 static 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_POWERUP
 504         };
 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
 534 static 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_SHUTDOWN
 540         };
 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
 564 static 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_SHUTDOWN
 571         };
 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 SSR
 581  * @nb:         notifier_block associated with sysmon instance
 582  * @event:      unused
 583  * @data:       SSR identifier of the remote that is going down
 584  */
 585 static 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
 607 static 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 remoteproc
 618  * @rproc:      rproc context to associate the subdev with
 619  * @name:       name of this subdev, to use in SSR
 620  * @ssctl_instance: instance id of the ssctl QMI service
 621  *
 622  * Return: A new qcom_sysmon object, or NULL on failure
 623  */
 624 struct 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 }
 698 EXPORT_SYMBOL_GPL(qcom_add_sysmon_subdev);
 699
 700 /**
 701  * qcom_remove_sysmon_subdev() - release a qcom_sysmon
 702  * @sysmon:     sysmon context, as retrieved by qcom_add_sysmon_subdev()
 703  */
 704 void 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 }
 721 EXPORT_SYMBOL_GPL(qcom_remove_sysmon_subdev);
 722
 723 /**
 724  * qcom_sysmon_shutdown_acked() - query the success of the last shutdown
 725  * @sysmon:     sysmon context
 726  *
 727  * When sysmon is used to request a graceful shutdown of the remote processor
 728  * this can be used by the remoteproc driver to query the success, in order to
 729  * 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 request
 732  */
 733 bool qcom_sysmon_shutdown_acked(struct qcom_sysmon *sysmon)
 734 {
 735         return sysmon && sysmon->shutdown_acked;
 736 }
 737 EXPORT_SYMBOL_GPL(qcom_sysmon_shutdown_acked);
 738
 739 /**
 740  * sysmon_probe() - probe sys_mon channel
 741  * @rpdev:      rpmsg device handle
 742  *
 743  * Find the sysmon context associated with the ancestor remoteproc and assign
 744  * this rpmsg device with said sysmon context.
 745  *
 746  * Return: 0 on success, negative errno on failure.
 747  */
 748 static 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
 770 found:
 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 handler
 781  * @rpdev:      rpmsg device handle
 782  *
 783  * Disassociate the rpmsg device with the sysmon instance.
 784  */
 785 static void sysmon_remove(struct rpmsg_device *rpdev)
 786 {
 787         struct qcom_sysmon *sysmon = rpdev->ept->priv;
 788
 789         sysmon->ept = NULL;
 790 }
 791
 792 static const struct rpmsg_device_id sysmon_match[] = {
 793         { "sys_mon" },
 794         {}
 795 };
 796
 797 static 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
 807 module_rpmsg_driver(sysmon_driver);
 808
 809 MODULE_DESCRIPTION("Qualcomm sysmon driver");
 810 MODULE_LICENSE("GPL v2");