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"); 657