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