Merge tag 'rpmsg-v6.12' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux

+1

drivers/rpmsg/Makefile

··· 4 4 obj-$(CONFIG_RPMSG_CTRL) += rpmsg_ctrl.o 5 5 obj-$(CONFIG_RPMSG_NS) += rpmsg_ns.o 6 6 obj-$(CONFIG_RPMSG_MTK_SCP) += mtk_rpmsg.o 7 + CFLAGS_qcom_glink_native.o := -I$(src) 7 8 qcom_glink-objs := qcom_glink_native.o qcom_glink_ssr.o 8 9 obj-$(CONFIG_RPMSG_QCOM_GLINK) += qcom_glink.o 9 10 obj-$(CONFIG_RPMSG_QCOM_GLINK_RPM) += qcom_glink_rpm.o

+135 -31

drivers/rpmsg/qcom_glink_native.c

··· 23 23 #include "rpmsg_internal.h" 24 24 #include "qcom_glink_native.h" 25 25 26 + #define CREATE_TRACE_POINTS 27 + #include "qcom_glink_trace.h" 28 + 26 29 #define GLINK_NAME_SIZE 32 27 30 #define GLINK_VERSION_1 1 28 31 ··· 33 30 #define RPM_GLINK_CID_MAX 65536 34 31 35 32 struct glink_msg { 36 - __le16 cmd; 37 - __le16 param1; 38 - __le32 param2; 33 + /* New members MUST be added within the __struct_group() macro below. */ 34 + __struct_group(glink_msg_hdr, hdr, __packed, 35 + __le16 cmd; 36 + __le16 param1; 37 + __le32 param2; 38 + ); 39 39 u8 data[]; 40 40 } __packed; 41 + static_assert(offsetof(struct glink_msg, data) == sizeof(struct glink_msg_hdr), 42 + "struct member likely outside of __struct_group()"); 41 43 42 44 /** 43 45 * struct glink_defer_cmd - deferred incoming control message ··· 56 48 struct glink_defer_cmd { 57 49 struct list_head node; 58 50 59 - struct glink_msg msg; 51 + struct glink_msg_hdr msg; 60 52 u8 data[]; 61 53 }; 62 54 ··· 86 78 /** 87 79 * struct qcom_glink - driver context, relates to one remote subsystem 88 80 * @dev: reference to the associated struct device 81 + * @label: identifier of the glink edge 89 82 * @rx_pipe: pipe object for receive FIFO 90 83 * @tx_pipe: pipe object for transmit FIFO 91 84 * @rx_work: worker for handling received control messages ··· 104 95 */ 105 96 struct qcom_glink { 106 97 struct device *dev; 98 + 99 + const char *label; 107 100 108 101 struct qcom_glink_pipe *rx_pipe; 109 102 struct qcom_glink_pipe *tx_pipe; ··· 403 392 msg.param1 = cpu_to_le16(GLINK_VERSION_1); 404 393 msg.param2 = cpu_to_le32(glink->features); 405 394 395 + trace_qcom_glink_cmd_version_tx(glink->label, GLINK_VERSION_1, glink->features); 396 + 406 397 return qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); 407 398 } 408 399 ··· 415 402 msg.cmd = cpu_to_le16(GLINK_CMD_VERSION_ACK); 416 403 msg.param1 = cpu_to_le16(GLINK_VERSION_1); 417 404 msg.param2 = cpu_to_le32(glink->features); 405 + 406 + trace_qcom_glink_cmd_version_ack_tx(glink->label, msg.param1, msg.param2); 418 407 419 408 qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); 420 409 } ··· 430 415 msg.param1 = cpu_to_le16(channel->rcid); 431 416 msg.param2 = cpu_to_le32(0); 432 417 418 + trace_qcom_glink_cmd_open_ack_tx(glink->label, channel->name, 419 + channel->lcid, channel->rcid); 420 + 433 421 qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); 434 422 } 435 423 ··· 442 424 struct glink_channel *channel; 443 425 unsigned long flags; 444 426 427 + qcom_glink_rx_advance(glink, ALIGN(sizeof(struct glink_msg), 8)); 428 + 445 429 spin_lock_irqsave(&glink->idr_lock, flags); 446 430 channel = idr_find(&glink->rcids, cid); 447 431 spin_unlock_irqrestore(&glink->idr_lock, flags); 432 + 433 + trace_qcom_glink_cmd_rx_intent_req_ack_rx(glink->label, 434 + channel ? channel->name : NULL, 435 + channel ? channel->lcid : 0, 436 + cid, granted); 448 437 if (!channel) { 449 438 dev_err(glink->dev, "unable to find channel\n"); 450 439 return; ··· 480 455 static int qcom_glink_send_open_req(struct qcom_glink *glink, 481 456 struct glink_channel *channel) 482 457 { 483 - struct { 484 - struct glink_msg msg; 485 - u8 name[GLINK_NAME_SIZE]; 486 - } __packed req; 458 + DEFINE_RAW_FLEX(struct glink_msg, req, data, GLINK_NAME_SIZE); 487 459 int name_len = strlen(channel->name) + 1; 488 - int req_len = ALIGN(sizeof(req.msg) + name_len, 8); 460 + int req_len = ALIGN(sizeof(*req) + name_len, 8); 489 461 int ret; 490 462 unsigned long flags; 491 463 ··· 498 476 499 477 channel->lcid = ret; 500 478 501 - req.msg.cmd = cpu_to_le16(GLINK_CMD_OPEN); 502 - req.msg.param1 = cpu_to_le16(channel->lcid); 503 - req.msg.param2 = cpu_to_le32(name_len); 504 - strcpy(req.name, channel->name); 479 + req->cmd = cpu_to_le16(GLINK_CMD_OPEN); 480 + req->param1 = cpu_to_le16(channel->lcid); 481 + req->param2 = cpu_to_le32(name_len); 482 + strcpy(req->data, channel->name); 505 483 506 - ret = qcom_glink_tx(glink, &req, req_len, NULL, 0, true); 484 + trace_qcom_glink_cmd_open_tx(glink->label, channel->name, 485 + channel->lcid, channel->rcid); 486 + 487 + ret = qcom_glink_tx(glink, req, req_len, NULL, 0, true); 507 488 if (ret) 508 489 goto remove_idr; 509 490 ··· 530 505 req.param1 = cpu_to_le16(channel->lcid); 531 506 req.param2 = 0; 532 507 508 + trace_qcom_glink_cmd_close_tx(glink->label, channel->name, 509 + channel->lcid, channel->rcid); 510 + 533 511 qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true); 534 512 } 535 513 536 514 static void qcom_glink_send_close_ack(struct qcom_glink *glink, 537 - unsigned int rcid) 515 + struct glink_channel *channel) 538 516 { 539 517 struct glink_msg req; 540 518 541 519 req.cmd = cpu_to_le16(GLINK_CMD_CLOSE_ACK); 542 - req.param1 = cpu_to_le16(rcid); 520 + req.param1 = cpu_to_le16(channel->rcid); 543 521 req.param2 = 0; 522 + 523 + trace_qcom_glink_cmd_close_ack_tx(glink->label, channel->name, 524 + channel->lcid, channel->rcid); 544 525 545 526 qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true); 546 527 } ··· 578 547 cmd.id = reuse ? GLINK_CMD_RX_DONE_W_REUSE : GLINK_CMD_RX_DONE; 579 548 cmd.lcid = cid; 580 549 cmd.liid = iid; 550 + 551 + trace_qcom_glink_cmd_rx_done_tx(glink->label, channel->name, 552 + channel->lcid, channel->rcid, cmd.liid, reuse); 581 553 582 554 qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true); 583 555 if (!reuse) { ··· 632 598 u32 version, 633 599 u32 features) 634 600 { 601 + trace_qcom_glink_cmd_version_rx(glink->label, version, features); 602 + 635 603 switch (version) { 636 604 case 0: 637 605 break; ··· 661 625 u32 version, 662 626 u32 features) 663 627 { 628 + trace_qcom_glink_cmd_version_ack_rx(glink->label, version, features); 629 + 664 630 switch (version) { 665 631 case 0: 666 632 /* Version negotiation failed */ ··· 693 655 bool granted) 694 656 { 695 657 struct glink_msg msg; 658 + 659 + trace_qcom_glink_cmd_rx_intent_req_ack_tx(glink->label, channel->name, 660 + channel->lcid, channel->rcid, 661 + granted); 696 662 697 663 msg.cmd = cpu_to_le16(GLINK_CMD_RX_INTENT_REQ_ACK); 698 664 msg.param1 = cpu_to_le16(channel->lcid); ··· 734 692 cmd.count = cpu_to_le32(1); 735 693 cmd.size = cpu_to_le32(intent->size); 736 694 cmd.liid = cpu_to_le32(intent->id); 695 + 696 + trace_qcom_glink_cmd_intent_tx(glink->label, channel->name, 697 + channel->lcid, channel->rcid, 698 + cmd.count, cmd.size, cmd.liid); 737 699 738 700 qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true); 739 701 ··· 791 745 struct glink_channel *channel; 792 746 unsigned long flags; 793 747 748 + qcom_glink_rx_advance(glink, ALIGN(sizeof(struct glink_msg), 8)); 749 + 794 750 spin_lock_irqsave(&glink->idr_lock, flags); 795 751 channel = idr_find(&glink->rcids, cid); 796 752 spin_unlock_irqrestore(&glink->idr_lock, flags); 753 + 754 + trace_qcom_glink_cmd_rx_done_rx(glink->label, channel ? channel->name : NULL, 755 + channel ? channel->lcid : 0, cid, iid, reuse); 797 756 if (!channel) { 798 757 dev_err(glink->dev, "invalid channel id received\n"); 799 758 return; ··· 848 797 channel = idr_find(&glink->rcids, cid); 849 798 spin_unlock_irqrestore(&glink->idr_lock, flags); 850 799 800 + trace_qcom_glink_cmd_rx_intent_req_rx(glink->label, 801 + channel ? channel->name : NULL, 802 + channel ? channel->lcid : 0, 803 + cid, size); 851 804 if (!channel) { 852 805 pr_err("%s channel not found for cid %d\n", __func__, cid); 853 806 return; ··· 881 826 882 827 INIT_LIST_HEAD(&dcmd->node); 883 828 884 - qcom_glink_rx_peek(glink, &dcmd->msg, 0, sizeof(dcmd->msg) + extra); 829 + qcom_glink_rx_peek(glink, 830 + container_of(&dcmd->msg, struct glink_msg, hdr), 0, 831 + sizeof(dcmd->msg) + extra); 885 832 886 833 spin_lock(&glink->rx_lock); 887 834 list_add_tail(&dcmd->node, &glink->rx_queue); ··· 900 843 struct glink_core_rx_intent *intent; 901 844 struct glink_channel *channel; 902 845 struct { 903 - struct glink_msg msg; 846 + struct glink_msg_hdr msg; 904 847 __le32 chunk_size; 905 848 __le32 left_size; 906 849 } __packed hdr; ··· 926 869 } 927 870 928 871 rcid = le16_to_cpu(hdr.msg.param1); 872 + liid = le32_to_cpu(hdr.msg.param2); 929 873 spin_lock_irqsave(&glink->idr_lock, flags); 930 874 channel = idr_find(&glink->rcids, rcid); 931 875 spin_unlock_irqrestore(&glink->idr_lock, flags); 876 + 877 + trace_qcom_glink_cmd_tx_data_rx(glink->label, channel ? channel->name : NULL, 878 + channel ? channel->lcid : 0, rcid, 879 + liid, chunk_size, left_size, 880 + hdr.msg.cmd == GLINK_CMD_TX_DATA_CONT); 932 881 if (!channel) { 933 882 dev_dbg(glink->dev, "Data on non-existing channel\n"); 934 883 ··· 965 902 intent = channel->buf; 966 903 } 967 904 } else { 968 - liid = le32_to_cpu(hdr.msg.param2); 969 - 970 905 spin_lock_irqsave(&channel->intent_lock, flags); 971 906 intent = idr_find(&channel->liids, liid); 972 907 spin_unlock_irqrestore(&channel->intent_lock, flags); ··· 1013 952 return ret; 1014 953 } 1015 954 955 + static void qcom_glink_rx_read_notif(struct qcom_glink *glink) 956 + { 957 + trace_qcom_glink_cmd_read_notif_rx(glink->label); 958 + 959 + qcom_glink_rx_advance(glink, ALIGN(sizeof(struct glink_msg), 8)); 960 + qcom_glink_tx_kick(glink); 961 + } 962 + 1016 963 static void qcom_glink_handle_intent(struct qcom_glink *glink, 1017 964 unsigned int cid, 1018 965 unsigned int count, ··· 1034 965 }; 1035 966 1036 967 struct { 1037 - struct glink_msg msg; 968 + struct glink_msg_hdr msg; 1038 969 struct intent_pair intents[]; 1039 970 } __packed * msg; 1040 971 ··· 1052 983 channel = idr_find(&glink->rcids, cid); 1053 984 spin_unlock_irqrestore(&glink->idr_lock, flags); 1054 985 if (!channel) { 986 + trace_qcom_glink_cmd_intent_rx(glink->label, NULL, 0, cid, count, 0, 0); 1055 987 dev_err(glink->dev, "intents for non-existing channel\n"); 1056 988 qcom_glink_rx_advance(glink, ALIGN(msglen, 8)); 1057 989 return; ··· 1063 993 return; 1064 994 1065 995 qcom_glink_rx_peek(glink, msg, 0, msglen); 996 + 997 + trace_qcom_glink_cmd_intent_rx(glink->label, channel->name, 998 + channel->lcid, cid, count, 999 + count > 0 ? msg->intents[0].size : 0, 1000 + count > 0 ? msg->intents[0].iid : 0); 1066 1001 1067 1002 for (i = 0; i < count; ++i) { 1068 1003 intent = kzalloc(sizeof(*intent), GFP_ATOMIC); ··· 1097 1022 { 1098 1023 struct glink_channel *channel; 1099 1024 1025 + qcom_glink_rx_advance(glink, ALIGN(sizeof(struct glink_msg), 8)); 1026 + 1100 1027 spin_lock(&glink->idr_lock); 1101 1028 channel = idr_find(&glink->lcids, lcid); 1102 1029 spin_unlock(&glink->idr_lock); 1030 + 1031 + trace_qcom_glink_cmd_open_ack_rx(glink->label, channel ? channel->name : NULL, 1032 + lcid, channel ? channel->rcid : 0); 1103 1033 if (!channel) { 1104 1034 dev_err(glink->dev, "Invalid open ack packet\n"); 1105 1035 return -EINVAL; ··· 1137 1057 msg.param1 = cpu_to_le16(channel->lcid); 1138 1058 msg.param2 = cpu_to_le32(sigs); 1139 1059 1060 + trace_qcom_glink_cmd_signal_tx(glink->label, channel->name, 1061 + channel->lcid, channel->rcid, sigs); 1062 + 1140 1063 return qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); 1141 1064 } 1142 1065 ··· 1150 1067 unsigned long flags; 1151 1068 bool enable; 1152 1069 1070 + qcom_glink_rx_advance(glink, ALIGN(sizeof(struct glink_msg), 8)); 1071 + 1153 1072 spin_lock_irqsave(&glink->idr_lock, flags); 1154 1073 channel = idr_find(&glink->rcids, rcid); 1155 1074 spin_unlock_irqrestore(&glink->idr_lock, flags); 1075 + 1076 + trace_qcom_glink_cmd_signal_rx(glink->label, channel ? channel->name : NULL, 1077 + channel ? channel->lcid : 0, rcid, sigs); 1156 1078 if (!channel) { 1157 1079 dev_err(glink->dev, "signal for non-existing channel\n"); 1158 1080 return; ··· 1202 1114 break; 1203 1115 case GLINK_CMD_OPEN_ACK: 1204 1116 ret = qcom_glink_rx_open_ack(glink, param1); 1205 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1206 1117 break; 1207 1118 case GLINK_CMD_OPEN: 1208 1119 ret = qcom_glink_rx_defer(glink, param2); ··· 1211 1124 ret = qcom_glink_rx_data(glink, avail); 1212 1125 break; 1213 1126 case GLINK_CMD_READ_NOTIF: 1214 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1215 - qcom_glink_tx_kick(glink); 1127 + qcom_glink_rx_read_notif(glink); 1216 1128 break; 1217 1129 case GLINK_CMD_INTENT: 1218 1130 qcom_glink_handle_intent(glink, param1, param2, avail); 1219 1131 break; 1220 1132 case GLINK_CMD_RX_DONE: 1221 1133 qcom_glink_handle_rx_done(glink, param1, param2, false); 1222 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1223 1134 break; 1224 1135 case GLINK_CMD_RX_DONE_W_REUSE: 1225 1136 qcom_glink_handle_rx_done(glink, param1, param2, true); 1226 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1227 1137 break; 1228 1138 case GLINK_CMD_RX_INTENT_REQ_ACK: 1229 1139 qcom_glink_handle_intent_req_ack(glink, param1, param2); 1230 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1231 1140 break; 1232 1141 case GLINK_CMD_SIGNALS: 1233 1142 qcom_glink_handle_signals(glink, param1, param2); 1234 - qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1235 1143 break; 1236 1144 default: 1237 1145 dev_err(glink->dev, "unhandled rx cmd: %d\n", cmd); ··· 1431 1349 cmd.cid = channel->lcid; 1432 1350 cmd.size = size; 1433 1351 1352 + trace_qcom_glink_cmd_rx_intent_req_tx(glink->label, channel->name, 1353 + channel->lcid, channel->rcid, 1354 + cmd.size); 1355 + 1434 1356 ret = qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true); 1435 1357 if (ret) 1436 1358 goto unlock; ··· 1463 1377 struct glink_core_rx_intent *tmp; 1464 1378 int iid = 0; 1465 1379 struct { 1466 - struct glink_msg msg; 1380 + struct glink_msg_hdr msg; 1467 1381 __le32 chunk_size; 1468 1382 __le32 left_size; 1469 1383 } __packed req; ··· 1514 1428 req.msg.param2 = cpu_to_le32(iid); 1515 1429 req.chunk_size = cpu_to_le32(chunk_size); 1516 1430 req.left_size = cpu_to_le32(len - offset - chunk_size); 1431 + 1432 + trace_qcom_glink_cmd_tx_data_tx(glink->label, channel->name, 1433 + channel->lcid, channel->rcid, 1434 + iid, chunk_size, 1435 + len - offset - chunk_size, 1436 + offset > 0); 1517 1437 1518 1438 ret = qcom_glink_tx(glink, &req, sizeof(req), data + offset, chunk_size, wait); 1519 1439 if (ret) { ··· 1636 1544 create_device = true; 1637 1545 } 1638 1546 1547 + trace_qcom_glink_cmd_open_rx(glink->label, name, channel->lcid, rcid); 1548 + 1639 1549 spin_lock_irqsave(&glink->idr_lock, flags); 1640 1550 ret = idr_alloc(&glink->rcids, channel, rcid, rcid + 1, GFP_ATOMIC); 1641 1551 if (ret < 0) { ··· 1699 1605 spin_lock_irqsave(&glink->idr_lock, flags); 1700 1606 channel = idr_find(&glink->rcids, rcid); 1701 1607 spin_unlock_irqrestore(&glink->idr_lock, flags); 1608 + 1609 + trace_qcom_glink_cmd_close_rx(glink->label, channel ? channel->name : NULL, 1610 + channel ? channel->lcid : 0, rcid); 1702 1611 if (WARN(!channel, "close request on unknown channel\n")) 1703 1612 return; 1704 1613 ··· 1717 1620 } 1718 1621 channel->rpdev = NULL; 1719 1622 1720 - qcom_glink_send_close_ack(glink, channel->rcid); 1623 + qcom_glink_send_close_ack(glink, channel); 1721 1624 1722 1625 spin_lock_irqsave(&glink->idr_lock, flags); 1723 1626 idr_remove(&glink->rcids, channel->rcid); ··· 1738 1641 1739 1642 spin_lock_irqsave(&glink->idr_lock, flags); 1740 1643 channel = idr_find(&glink->lcids, lcid); 1644 + 1645 + trace_qcom_glink_cmd_close_ack_rx(glink->label, channel ? channel->name : NULL, 1646 + lcid, channel ? channel->rcid : 0); 1741 1647 if (WARN(!channel, "close ack on unknown channel\n")) { 1742 1648 spin_unlock_irqrestore(&glink->idr_lock, flags); 1743 1649 return; ··· 1785 1685 list_del(&dcmd->node); 1786 1686 spin_unlock_irqrestore(&glink->rx_lock, flags); 1787 1687 1788 - msg = &dcmd->msg; 1688 + msg = container_of(&dcmd->msg, struct glink_msg, hdr); 1789 1689 cmd = le16_to_cpu(msg->cmd); 1790 1690 param1 = le16_to_cpu(msg->param1); 1791 1691 param2 = le32_to_cpu(msg->param2); ··· 1914 1814 spin_lock_init(&glink->idr_lock); 1915 1815 idr_init(&glink->lcids); 1916 1816 idr_init(&glink->rcids); 1817 + 1818 + ret = of_property_read_string(dev->of_node, "label", &glink->label); 1819 + if (ret < 0) 1820 + glink->label = dev->of_node->name; 1917 1821 1918 1822 glink->dev->groups = qcom_glink_groups; 1919 1823

+406

drivers/rpmsg/qcom_glink_trace.h

··· 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + 3 + #undef TRACE_SYSTEM 4 + #define TRACE_SYSTEM qcom_glink 5 + 6 + #if !defined(__QCOM_GLINK_TRACE_H__) || defined(TRACE_HEADER_MULTI_READ) 7 + #define __QCOM_GLINK_TRACE_H__ 8 + 9 + #include <linux/tracepoint.h> 10 + #include "qcom_glink_native.h" 11 + 12 + 13 + TRACE_EVENT(qcom_glink_cmd_version, 14 + TP_PROTO(const char *remote, unsigned int version, unsigned int features, bool tx), 15 + TP_ARGS(remote, version, features, tx), 16 + TP_STRUCT__entry( 17 + __string(remote, remote) 18 + __field(u32, version) 19 + __field(u32, features) 20 + __field(bool, tx) 21 + ), 22 + TP_fast_assign( 23 + __assign_str(remote); 24 + __entry->version = version; 25 + __entry->features = features; 26 + __entry->tx = tx; 27 + ), 28 + TP_printk("%s remote: %s version: %u features: %#x", 29 + __entry->tx ? "tx" : "rx", 30 + __get_str(remote), 31 + __entry->version, 32 + __entry->features 33 + ) 34 + ); 35 + #define trace_qcom_glink_cmd_version_tx(...) trace_qcom_glink_cmd_version(__VA_ARGS__, true) 36 + #define trace_qcom_glink_cmd_version_rx(...) trace_qcom_glink_cmd_version(__VA_ARGS__, false) 37 + 38 + TRACE_EVENT(qcom_glink_cmd_version_ack, 39 + TP_PROTO(const char *remote, unsigned int version, unsigned int features, bool tx), 40 + TP_ARGS(remote, version, features, tx), 41 + TP_STRUCT__entry( 42 + __string(remote, remote) 43 + __field(u32, version) 44 + __field(u32, features) 45 + __field(bool, tx) 46 + ), 47 + TP_fast_assign( 48 + __assign_str(remote); 49 + __entry->version = version; 50 + __entry->features = features; 51 + __entry->tx = tx; 52 + ), 53 + TP_printk("%s remote: %s version: %u features: %#x", 54 + __entry->tx ? "tx" : "rx", 55 + __get_str(remote), 56 + __entry->version, 57 + __entry->features 58 + ) 59 + ); 60 + #define trace_qcom_glink_cmd_version_ack_tx(...) trace_qcom_glink_cmd_version_ack(__VA_ARGS__, true) 61 + #define trace_qcom_glink_cmd_version_ack_rx(...) trace_qcom_glink_cmd_version_ack(__VA_ARGS__, false) 62 + 63 + TRACE_EVENT(qcom_glink_cmd_open, 64 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, bool tx), 65 + TP_ARGS(remote, channel, lcid, rcid, tx), 66 + TP_STRUCT__entry( 67 + __string(remote, remote) 68 + __string(channel, channel) 69 + __field(u16, lcid) 70 + __field(u16, rcid) 71 + __field(bool, tx) 72 + ), 73 + TP_fast_assign( 74 + __assign_str(remote); 75 + __assign_str(channel); 76 + __entry->lcid = lcid; 77 + __entry->rcid = rcid; 78 + __entry->tx = tx; 79 + ), 80 + TP_printk("%s remote: %s channel: %s[%u/%u]", 81 + __entry->tx ? "tx" : "rx", 82 + __get_str(remote), 83 + __get_str(channel), 84 + __entry->lcid, 85 + __entry->rcid 86 + ) 87 + ); 88 + #define trace_qcom_glink_cmd_open_tx(...) trace_qcom_glink_cmd_open(__VA_ARGS__, true) 89 + #define trace_qcom_glink_cmd_open_rx(...) trace_qcom_glink_cmd_open(__VA_ARGS__, false) 90 + 91 + TRACE_EVENT(qcom_glink_cmd_close, 92 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, bool tx), 93 + TP_ARGS(remote, channel, lcid, rcid, tx), 94 + TP_STRUCT__entry( 95 + __string(remote, remote) 96 + __string(channel, channel) 97 + __field(u16, lcid) 98 + __field(u16, rcid) 99 + __field(bool, tx) 100 + ), 101 + TP_fast_assign( 102 + __assign_str(remote); 103 + __assign_str(channel); 104 + __entry->lcid = lcid; 105 + __entry->rcid = rcid; 106 + __entry->tx = tx; 107 + ), 108 + TP_printk("%s remote: %s channel: %s[%u/%u]", 109 + __entry->tx ? "tx" : "rx", 110 + __get_str(remote), 111 + __get_str(channel), 112 + __entry->lcid, 113 + __entry->rcid 114 + ) 115 + ); 116 + #define trace_qcom_glink_cmd_close_tx(...) trace_qcom_glink_cmd_close(__VA_ARGS__, true) 117 + #define trace_qcom_glink_cmd_close_rx(...) trace_qcom_glink_cmd_close(__VA_ARGS__, false) 118 + 119 + TRACE_EVENT(qcom_glink_cmd_open_ack, 120 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, bool tx), 121 + TP_ARGS(remote, channel, lcid, rcid, tx), 122 + TP_STRUCT__entry( 123 + __string(remote, remote) 124 + __string(channel, channel) 125 + __field(u16, lcid) 126 + __field(u16, rcid) 127 + __field(bool, tx) 128 + ), 129 + TP_fast_assign( 130 + __assign_str(remote); 131 + __assign_str(channel); 132 + __entry->lcid = lcid; 133 + __entry->rcid = rcid; 134 + __entry->tx = tx; 135 + ), 136 + TP_printk("%s remote: %s channel: %s[%u/%u]", 137 + __entry->tx ? "tx" : "rx", 138 + __get_str(remote), 139 + __get_str(channel), 140 + __entry->lcid, 141 + __entry->rcid 142 + ) 143 + ); 144 + #define trace_qcom_glink_cmd_open_ack_tx(...) trace_qcom_glink_cmd_open_ack(__VA_ARGS__, true) 145 + #define trace_qcom_glink_cmd_open_ack_rx(...) trace_qcom_glink_cmd_open_ack(__VA_ARGS__, false) 146 + 147 + TRACE_EVENT(qcom_glink_cmd_intent, 148 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, size_t count, size_t size, u32 liid, bool tx), 149 + TP_ARGS(remote, channel, lcid, rcid, count, size, liid, tx), 150 + TP_STRUCT__entry( 151 + __string(remote, remote) 152 + __string(channel, channel) 153 + __field(u16, lcid) 154 + __field(u16, rcid) 155 + __field(u32, count) 156 + __field(u32, size) 157 + __field(u32, liid) 158 + __field(bool, tx) 159 + ), 160 + TP_fast_assign( 161 + __assign_str(remote); 162 + __assign_str(channel); 163 + __entry->lcid = lcid; 164 + __entry->rcid = rcid; 165 + __entry->count = count; 166 + __entry->size = size; 167 + __entry->liid = liid; 168 + __entry->tx = tx; 169 + ), 170 + TP_printk("%s remote: %s channel: %s[%u/%u] count: %d [size: %d liid: %d]", 171 + __entry->tx ? "tx" : "rx", 172 + __get_str(remote), 173 + __get_str(channel), 174 + __entry->lcid, 175 + __entry->rcid, 176 + __entry->count, 177 + __entry->size, 178 + __entry->liid 179 + ) 180 + ); 181 + #define trace_qcom_glink_cmd_intent_tx(...) trace_qcom_glink_cmd_intent(__VA_ARGS__, true) 182 + #define trace_qcom_glink_cmd_intent_rx(...) trace_qcom_glink_cmd_intent(__VA_ARGS__, false) 183 + 184 + TRACE_EVENT(qcom_glink_cmd_rx_done, 185 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, u32 iid, bool reuse, bool tx), 186 + TP_ARGS(remote, channel, lcid, rcid, iid, reuse, tx), 187 + TP_STRUCT__entry( 188 + __string(remote, remote) 189 + __string(channel, channel) 190 + __field(u16, lcid) 191 + __field(u16, rcid) 192 + __field(u32, iid) 193 + __field(bool, reuse) 194 + __field(bool, tx) 195 + ), 196 + TP_fast_assign( 197 + __assign_str(remote); 198 + __assign_str(channel); 199 + __entry->lcid = lcid; 200 + __entry->rcid = rcid; 201 + __entry->iid = iid; 202 + __entry->reuse = reuse; 203 + __entry->tx = tx; 204 + ), 205 + TP_printk("%s remote: %s channel: %s[%u/%u] iid: %d reuse: %d", 206 + __entry->tx ? "tx" : "rx", 207 + __get_str(remote), 208 + __get_str(channel), 209 + __entry->lcid, 210 + __entry->rcid, 211 + __entry->iid, 212 + __entry->reuse 213 + ) 214 + ); 215 + #define trace_qcom_glink_cmd_rx_done_tx(...) trace_qcom_glink_cmd_rx_done(__VA_ARGS__, true) 216 + #define trace_qcom_glink_cmd_rx_done_rx(...) trace_qcom_glink_cmd_rx_done(__VA_ARGS__, false) 217 + 218 + TRACE_EVENT(qcom_glink_cmd_rx_intent_req, 219 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, size_t size, bool tx), 220 + TP_ARGS(remote, channel, lcid, rcid, size, tx), 221 + TP_STRUCT__entry( 222 + __string(remote, remote) 223 + __string(channel, channel) 224 + __field(u16, lcid) 225 + __field(u16, rcid) 226 + __field(u32, size) 227 + __field(bool, tx) 228 + ), 229 + TP_fast_assign( 230 + __assign_str(remote); 231 + __assign_str(channel); 232 + __entry->lcid = lcid; 233 + __entry->rcid = rcid; 234 + __entry->size = size; 235 + __entry->tx = tx; 236 + ), 237 + TP_printk("%s remote: %s channel: %s[%u/%u] size: %d", 238 + __entry->tx ? "tx" : "rx", 239 + __get_str(remote), 240 + __get_str(channel), 241 + __entry->lcid, 242 + __entry->rcid, 243 + __entry->size 244 + ) 245 + ); 246 + #define trace_qcom_glink_cmd_rx_intent_req_tx(...) trace_qcom_glink_cmd_rx_intent_req(__VA_ARGS__, true) 247 + #define trace_qcom_glink_cmd_rx_intent_req_rx(...) trace_qcom_glink_cmd_rx_intent_req(__VA_ARGS__, false) 248 + 249 + TRACE_EVENT(qcom_glink_cmd_rx_intent_req_ack, 250 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, bool granted, bool tx), 251 + TP_ARGS(remote, channel, lcid, rcid, granted, tx), 252 + TP_STRUCT__entry( 253 + __string(remote, remote) 254 + __string(channel, channel) 255 + __field(u16, lcid) 256 + __field(u16, rcid) 257 + __field(bool, granted) 258 + __field(bool, tx) 259 + ), 260 + TP_fast_assign( 261 + __assign_str(remote); 262 + __assign_str(channel); 263 + __entry->lcid = lcid; 264 + __entry->rcid = rcid; 265 + __entry->granted = granted; 266 + __entry->tx = tx; 267 + ), 268 + TP_printk("%s remote: %s channel: %s[%u/%u] granted: %d", 269 + __entry->tx ? "tx" : "rx", 270 + __get_str(remote), 271 + __get_str(channel), 272 + __entry->lcid, 273 + __entry->rcid, 274 + __entry->granted 275 + ) 276 + ); 277 + #define trace_qcom_glink_cmd_rx_intent_req_ack_tx(...) trace_qcom_glink_cmd_rx_intent_req_ack(__VA_ARGS__, true) 278 + #define trace_qcom_glink_cmd_rx_intent_req_ack_rx(...) trace_qcom_glink_cmd_rx_intent_req_ack(__VA_ARGS__, false) 279 + 280 + TRACE_EVENT(qcom_glink_cmd_tx_data, 281 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, u32 iid, u32 chunk_size, u32 left_size, bool cont, bool tx), 282 + TP_ARGS(remote, channel, lcid, rcid, iid, chunk_size, left_size, cont, tx), 283 + TP_STRUCT__entry( 284 + __string(remote, remote) 285 + __string(channel, channel) 286 + __field(u16, lcid) 287 + __field(u16, rcid) 288 + __field(u32, iid) 289 + __field(u32, chunk_size) 290 + __field(u32, left_size) 291 + __field(bool, cont) 292 + __field(bool, tx) 293 + ), 294 + TP_fast_assign( 295 + __assign_str(remote); 296 + __assign_str(channel); 297 + __entry->lcid = lcid; 298 + __entry->rcid = rcid; 299 + __entry->iid = iid; 300 + __entry->chunk_size = chunk_size; 301 + __entry->left_size = left_size; 302 + __entry->cont = cont; 303 + __entry->tx = tx; 304 + ), 305 + TP_printk("%s remote: %s channel: %s[%u/%u] iid: %d chunk_size: %d left_size: %d cont: %d", 306 + __entry->tx ? "tx" : "rx", 307 + __get_str(remote), 308 + __get_str(channel), 309 + __entry->lcid, 310 + __entry->rcid, 311 + __entry->iid, 312 + __entry->chunk_size, 313 + __entry->left_size, 314 + __entry->cont 315 + ) 316 + ); 317 + #define trace_qcom_glink_cmd_tx_data_tx(...) trace_qcom_glink_cmd_tx_data(__VA_ARGS__, true) 318 + #define trace_qcom_glink_cmd_tx_data_rx(...) trace_qcom_glink_cmd_tx_data(__VA_ARGS__, false) 319 + 320 + TRACE_EVENT(qcom_glink_cmd_close_ack, 321 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, bool tx), 322 + TP_ARGS(remote, channel, lcid, rcid, tx), 323 + TP_STRUCT__entry( 324 + __string(remote, remote) 325 + __string(channel, channel) 326 + __field(u16, lcid) 327 + __field(u16, rcid) 328 + __field(bool, tx) 329 + ), 330 + TP_fast_assign( 331 + __assign_str(remote); 332 + __assign_str(channel); 333 + __entry->lcid = lcid; 334 + __entry->rcid = rcid; 335 + __entry->tx = tx; 336 + ), 337 + TP_printk("%s remote: %s channel: %s[%u/%u]", 338 + __entry->tx ? "tx" : "rx", 339 + __get_str(remote), 340 + __get_str(channel), 341 + __entry->lcid, 342 + __entry->rcid 343 + ) 344 + ); 345 + #define trace_qcom_glink_cmd_close_ack_tx(...) trace_qcom_glink_cmd_close_ack(__VA_ARGS__, true) 346 + #define trace_qcom_glink_cmd_close_ack_rx(...) trace_qcom_glink_cmd_close_ack(__VA_ARGS__, false) 347 + 348 + TRACE_EVENT(qcom_glink_cmd_read_notif, 349 + TP_PROTO(const char *remote, bool tx), 350 + TP_ARGS(remote, tx), 351 + TP_STRUCT__entry( 352 + __string(remote, remote) 353 + __field(bool, tx) 354 + ), 355 + TP_fast_assign( 356 + __assign_str(remote); 357 + __entry->tx = tx; 358 + ), 359 + TP_printk("%s remote: %s", 360 + __entry->tx ? "tx" : "rx", 361 + __get_str(remote) 362 + ) 363 + ); 364 + #define trace_qcom_glink_cmd_read_notif_tx(...) trace_qcom_glink_cmd_read_notif(__VA_ARGS__, true) 365 + #define trace_qcom_glink_cmd_read_notif_rx(...) trace_qcom_glink_cmd_read_notif(__VA_ARGS__, false) 366 + 367 + TRACE_EVENT(qcom_glink_cmd_signal, 368 + TP_PROTO(const char *remote, const char *channel, u16 lcid, u16 rcid, unsigned int signals, bool tx), 369 + TP_ARGS(remote, channel, lcid, rcid, signals, tx), 370 + TP_STRUCT__entry( 371 + __string(remote, remote) 372 + __string(channel, channel) 373 + __field(u16, lcid) 374 + __field(u16, rcid) 375 + __field(u32, signals) 376 + __field(bool, tx) 377 + ), 378 + TP_fast_assign( 379 + __assign_str(remote); 380 + __assign_str(channel); 381 + __entry->lcid = lcid; 382 + __entry->rcid = rcid; 383 + __entry->signals = signals; 384 + __entry->tx = tx; 385 + ), 386 + TP_printk("%s remote: %s channel: %s[%u/%u] signals: %#x", 387 + __entry->tx ? "tx" : "rx", 388 + __get_str(remote), 389 + __get_str(channel), 390 + __entry->lcid, 391 + __entry->rcid, 392 + __entry->signals 393 + ) 394 + ); 395 + #define trace_qcom_glink_cmd_signal_tx(...) trace_qcom_glink_cmd_signal(__VA_ARGS__, true) 396 + #define trace_qcom_glink_cmd_signal_rx(...) trace_qcom_glink_cmd_signal(__VA_ARGS__, false) 397 + 398 + #endif 399 + 400 + #undef TRACE_INCLUDE_PATH 401 + #define TRACE_INCLUDE_PATH . 402 + 403 + #undef TRACE_INCLUDE_FILE 404 + #define TRACE_INCLUDE_FILE qcom_glink_trace 405 + 406 + #include <trace/define_trace.h>

Configure Feed

Configure Feed