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

tjh.dev / kernel

fork

Configure Feed

Issues Pull Requests Commits Tags

Feed URL

Select the types of activity you want to include in your feed.

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork

Configure Feed

Issues Pull Requests Commits Tags

Feed URL

Select the types of activity you want to include in your feed.

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

Pull rpmsg updates from Bjorn Andersson:

- rpmsg ctrl and char driver locking is ensure ordering in cases where
the communication link is being torn down in parallel with calls to
open(2) or poll(2)

- The glink driver is refactored, to move rpm/smem-specifics out of the
common logic and better suite further improvements, such as
transports without a mailbox controller. The handling of remoteproc
shutdown is improved, to fail clients immediately instead of having
them to wait for timeouts. A driver_override memory leak is corrected
and a few spelling improvements are introduced

- glink_ssr is transitioned off strlcpy() and "gpr" is added as a valid
child node of the glink-edge DT binding

* tag 'rpmsg-v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux:
rpmsg: glink: Release driver_override
rpmsg: glink: Avoid infinite loop on intent for missing channel
rpmsg: glink: Fix GLINK command prefix
rpmsg: glink: Fix spelling of peek
rpmsg: glink: Cancel pending intent requests at removal
rpmsg: glink: Fail qcom_glink_tx() once remove has been initiated
rpmsg: glink: Move irq and mbox handling to transports
rpmsg: glink: rpm: Wrap driver context
rpmsg: glink: smem: Wrap driver context
rpmsg: glink: Extract tx kick operation
rpmsg: glink: Include types in qcom_glink_native.h
rpmsg: ctrl: Add lock to rpmsg_ctrldev_remove
rpmsg: char: Add lock to avoid race when rpmsg device is released
rpmsg: move from strlcpy with unused retval to strscpy
dt-bindings: remoteproc: qcom,glink-edge: add GPR node

Linus Torvalds 3 years ago cc38a46d 9b0b0dd8

+315 -156

10 changed files

expand all collapse all

Documentation

devicetree

bindings

remoteproc

qcom,glink-edge.yaml

drivers

remoteproc

qcom_common.h

rpmsg

qcom_glink_native.c

qcom_glink_native.h

qcom_glink_rpm.c

qcom_glink_smem.c

qcom_glink_ssr.c

rpmsg_char.c

rpmsg_ctrl.c

include

linux

rpmsg

qcom_glink.h

+23 -1

Documentation/devicetree/bindings/remoteproc/qcom,glink-edge.yaml

reviewed

··· 22 22 required: 23 23 - qcom,glink-channels 24 24 description: 25 25 - Qualcomm APR/GPR (Asynchronous/Generic Packet Router) 25 25 + Qualcomm APR (Asynchronous Packet Router) 26 26 27 27 fastrpc: 28 28 $ref: /schemas/misc/qcom,fastrpc.yaml# ··· 30 30 - qcom,glink-channels 31 31 description: 32 32 Qualcomm FastRPC 33 33 + 34 34 + gpr: 35 35 + $ref: /schemas/soc/qcom/qcom,apr.yaml# 36 36 + required: 37 37 + - qcom,glink-channels 38 38 + description: 39 39 + Qualcomm GPR (Generic Packet Router) 33 40 34 41 interrupts: 35 42 maxItems: 1 ··· 58 51 - label 59 52 - mboxes 60 53 - qcom,remote-pid 54 54 + 55 55 + allOf: 56 56 + - if: 57 57 + required: 58 58 + - apr 59 59 + then: 60 60 + properties: 61 61 + gpr: false 62 62 + 63 63 + - if: 64 64 + required: 65 65 + - gpr 66 66 + then: 67 67 + properties: 68 68 + apr: false 61 69 62 70 additionalProperties: false 63 71

+2 -1

drivers/remoteproc/qcom_common.h

reviewed

··· 6 6 #include "remoteproc_internal.h" 7 7 #include <linux/soc/qcom/qmi.h> 8 8 9 9 + struct qcom_glink_smem; 9 10 struct qcom_sysmon; 10 11 11 12 struct qcom_rproc_glink { ··· 16 15 17 16 struct device *dev; 18 17 struct device_node *node; 19 19 - struct qcom_glink *edge; 18 18 + struct qcom_glink_smem *edge; 20 19 }; 21 20 22 21 struct qcom_rproc_subdev {

+101 -107

drivers/rpmsg/qcom_glink_native.c

reviewed

··· 11 11 #include <linux/module.h> 12 12 #include <linux/of.h> 13 13 #include <linux/of_address.h> 14 14 - #include <linux/of_irq.h> 15 14 #include <linux/platform_device.h> 16 15 #include <linux/regmap.h> 17 16 #include <linux/rpmsg.h> ··· 77 78 /** 78 79 * struct qcom_glink - driver context, relates to one remote subsystem 79 80 * @dev: reference to the associated struct device 80 80 - * @mbox_client: mailbox client 81 81 - * @mbox_chan: mailbox channel 82 81 * @rx_pipe: pipe object for receive FIFO 83 82 * @tx_pipe: pipe object for transmit FIFO 84 84 - * @irq: IRQ for signaling incoming events 85 83 * @rx_work: worker for handling received control messages 86 84 * @rx_lock: protects the @rx_queue 87 85 * @rx_queue: queue of received control messages to be processed in @rx_work ··· 90 94 * @intentless: flag to indicate that there is no intent 91 95 * @tx_avail_notify: Waitqueue for pending tx tasks 92 96 * @sent_read_notify: flag to check cmd sent or not 97 97 + * @abort_tx: flag indicating that all tx attempts should fail 93 98 */ 94 99 struct qcom_glink { 95 100 struct device *dev; 96 101 97 97 - struct mbox_client mbox_client; 98 98 - struct mbox_chan *mbox_chan; 99 99 - 100 102 struct qcom_glink_pipe *rx_pipe; 101 103 struct qcom_glink_pipe *tx_pipe; 102 102 - 103 103 - int irq; 104 104 105 105 struct work_struct rx_work; 106 106 spinlock_t rx_lock; ··· 112 120 bool intentless; 113 121 wait_queue_head_t tx_avail_notify; 114 122 bool sent_read_notify; 123 123 + 124 124 + bool abort_tx; 115 125 }; 116 126 117 127 enum { ··· 183 189 184 190 static const struct rpmsg_endpoint_ops glink_endpoint_ops; 185 191 186 186 - #define RPM_CMD_VERSION 0 187 187 - #define RPM_CMD_VERSION_ACK 1 188 188 - #define RPM_CMD_OPEN 2 189 189 - #define RPM_CMD_CLOSE 3 190 190 - #define RPM_CMD_OPEN_ACK 4 191 191 - #define RPM_CMD_INTENT 5 192 192 - #define RPM_CMD_RX_DONE 6 193 193 - #define RPM_CMD_RX_INTENT_REQ 7 194 194 - #define RPM_CMD_RX_INTENT_REQ_ACK 8 195 195 - #define RPM_CMD_TX_DATA 9 196 196 - #define RPM_CMD_CLOSE_ACK 11 197 197 - #define RPM_CMD_TX_DATA_CONT 12 198 198 - #define RPM_CMD_READ_NOTIF 13 199 199 - #define RPM_CMD_RX_DONE_W_REUSE 14 192 192 + #define GLINK_CMD_VERSION 0 193 193 + #define GLINK_CMD_VERSION_ACK 1 194 194 + #define GLINK_CMD_OPEN 2 195 195 + #define GLINK_CMD_CLOSE 3 196 196 + #define GLINK_CMD_OPEN_ACK 4 197 197 + #define GLINK_CMD_INTENT 5 198 198 + #define GLINK_CMD_RX_DONE 6 199 199 + #define GLINK_CMD_RX_INTENT_REQ 7 200 200 + #define GLINK_CMD_RX_INTENT_REQ_ACK 8 201 201 + #define GLINK_CMD_TX_DATA 9 202 202 + #define GLINK_CMD_CLOSE_ACK 11 203 203 + #define GLINK_CMD_TX_DATA_CONT 12 204 204 + #define GLINK_CMD_READ_NOTIF 13 205 205 + #define GLINK_CMD_RX_DONE_W_REUSE 14 200 206 201 207 #define GLINK_FEATURE_INTENTLESS BIT(1) 202 208 ··· 274 280 return glink->rx_pipe->avail(glink->rx_pipe); 275 281 } 276 282 277 277 - static void qcom_glink_rx_peak(struct qcom_glink *glink, 283 283 + static void qcom_glink_rx_peek(struct qcom_glink *glink, 278 284 void *data, unsigned int offset, size_t count) 279 285 { 280 280 - glink->rx_pipe->peak(glink->rx_pipe, data, offset, count); 286 286 + glink->rx_pipe->peek(glink->rx_pipe, data, offset, count); 281 287 } 282 288 283 289 static void qcom_glink_rx_advance(struct qcom_glink *glink, size_t count) ··· 297 303 glink->tx_pipe->write(glink->tx_pipe, hdr, hlen, data, dlen); 298 304 } 299 305 306 306 + static void qcom_glink_tx_kick(struct qcom_glink *glink) 307 307 + { 308 308 + glink->tx_pipe->kick(glink->tx_pipe); 309 309 + } 310 310 + 300 311 static void qcom_glink_send_read_notify(struct qcom_glink *glink) 301 312 { 302 313 struct glink_msg msg; 303 314 304 304 - msg.cmd = cpu_to_le16(RPM_CMD_READ_NOTIF); 315 315 + msg.cmd = cpu_to_le16(GLINK_CMD_READ_NOTIF); 305 316 msg.param1 = 0; 306 317 msg.param2 = 0; 307 318 308 319 qcom_glink_tx_write(glink, &msg, sizeof(msg), NULL, 0); 309 320 310 310 - mbox_send_message(glink->mbox_chan, NULL); 311 311 - mbox_client_txdone(glink->mbox_chan, 0); 321 321 + qcom_glink_tx_kick(glink); 312 322 } 313 323 314 324 static int qcom_glink_tx(struct qcom_glink *glink, ··· 329 331 330 332 spin_lock_irqsave(&glink->tx_lock, flags); 331 333 334 334 + if (glink->abort_tx) { 335 335 + ret = -EIO; 336 336 + goto out; 337 337 + } 338 338 + 332 339 while (qcom_glink_tx_avail(glink) < tlen) { 333 340 if (!wait) { 334 341 ret = -EAGAIN; 342 342 + goto out; 343 343 + } 344 344 + 345 345 + if (glink->abort_tx) { 346 346 + ret = -EIO; 335 347 goto out; 336 348 } 337 349 ··· 363 355 } 364 356 365 357 qcom_glink_tx_write(glink, hdr, hlen, data, dlen); 366 366 - 367 367 - mbox_send_message(glink->mbox_chan, NULL); 368 368 - mbox_client_txdone(glink->mbox_chan, 0); 358 358 + qcom_glink_tx_kick(glink); 369 359 370 360 out: 371 361 spin_unlock_irqrestore(&glink->tx_lock, flags); ··· 375 369 { 376 370 struct glink_msg msg; 377 371 378 378 - msg.cmd = cpu_to_le16(RPM_CMD_VERSION); 372 372 + msg.cmd = cpu_to_le16(GLINK_CMD_VERSION); 379 373 msg.param1 = cpu_to_le16(GLINK_VERSION_1); 380 374 msg.param2 = cpu_to_le32(glink->features); 381 375 ··· 386 380 { 387 381 struct glink_msg msg; 388 382 389 389 - msg.cmd = cpu_to_le16(RPM_CMD_VERSION_ACK); 383 383 + msg.cmd = cpu_to_le16(GLINK_CMD_VERSION_ACK); 390 384 msg.param1 = cpu_to_le16(GLINK_VERSION_1); 391 385 msg.param2 = cpu_to_le32(glink->features); 392 386 ··· 398 392 { 399 393 struct glink_msg msg; 400 394 401 401 - msg.cmd = cpu_to_le16(RPM_CMD_OPEN_ACK); 395 395 + msg.cmd = cpu_to_le16(GLINK_CMD_OPEN_ACK); 402 396 msg.param1 = cpu_to_le16(channel->rcid); 403 397 msg.param2 = cpu_to_le32(0); 404 398 ··· 423 417 complete(&channel->intent_req_comp); 424 418 } 425 419 420 420 + static void qcom_glink_intent_req_abort(struct glink_channel *channel) 421 421 + { 422 422 + channel->intent_req_result = 0; 423 423 + complete(&channel->intent_req_comp); 424 424 + } 425 425 + 426 426 /** 427 427 - * qcom_glink_send_open_req() - send a RPM_CMD_OPEN request to the remote 427 427 + * qcom_glink_send_open_req() - send a GLINK_CMD_OPEN request to the remote 428 428 * @glink: Ptr to the glink edge 429 429 * @channel: Ptr to the channel that the open req is sent 430 430 * 431 431 - * Allocates a local channel id and sends a RPM_CMD_OPEN message to the remote. 431 431 + * Allocates a local channel id and sends a GLINK_CMD_OPEN message to the remote. 432 432 * Will return with refcount held, regardless of outcome. 433 433 * 434 434 * Return: 0 on success, negative errno otherwise. ··· 463 451 464 452 channel->lcid = ret; 465 453 466 466 - req.msg.cmd = cpu_to_le16(RPM_CMD_OPEN); 454 454 + req.msg.cmd = cpu_to_le16(GLINK_CMD_OPEN); 467 455 req.msg.param1 = cpu_to_le16(channel->lcid); 468 456 req.msg.param2 = cpu_to_le32(name_len); 469 457 strcpy(req.name, channel->name); ··· 488 476 { 489 477 struct glink_msg req; 490 478 491 491 - req.cmd = cpu_to_le16(RPM_CMD_CLOSE); 479 479 + req.cmd = cpu_to_le16(GLINK_CMD_CLOSE); 492 480 req.param1 = cpu_to_le16(channel->lcid); 493 481 req.param2 = 0; 494 482 ··· 500 488 { 501 489 struct glink_msg req; 502 490 503 503 - req.cmd = cpu_to_le16(RPM_CMD_CLOSE_ACK); 491 491 + req.cmd = cpu_to_le16(GLINK_CMD_CLOSE_ACK); 504 492 req.param1 = cpu_to_le16(rcid); 505 493 req.param2 = 0; 506 494 ··· 531 519 iid = intent->id; 532 520 reuse = intent->reuse; 533 521 534 534 - cmd.id = reuse ? RPM_CMD_RX_DONE_W_REUSE : RPM_CMD_RX_DONE; 522 522 + cmd.id = reuse ? GLINK_CMD_RX_DONE_W_REUSE : GLINK_CMD_RX_DONE; 535 523 cmd.lcid = cid; 536 524 cmd.liid = iid; 537 525 ··· 643 631 { 644 632 struct glink_msg msg; 645 633 646 646 - msg.cmd = cpu_to_le16(RPM_CMD_RX_INTENT_REQ_ACK); 634 634 + msg.cmd = cpu_to_le16(GLINK_CMD_RX_INTENT_REQ_ACK); 647 635 msg.param1 = cpu_to_le16(channel->lcid); 648 636 msg.param2 = cpu_to_le32(granted); 649 637 ··· 674 662 } __packed; 675 663 struct command cmd; 676 664 677 677 - cmd.id = cpu_to_le16(RPM_CMD_INTENT); 665 665 + cmd.id = cpu_to_le16(GLINK_CMD_INTENT); 678 666 cmd.lcid = cpu_to_le16(channel->lcid); 679 667 cmd.count = cpu_to_le32(1); 680 668 cmd.size = cpu_to_le32(intent->size); ··· 808 796 809 797 INIT_LIST_HEAD(&dcmd->node); 810 798 811 811 - qcom_glink_rx_peak(glink, &dcmd->msg, 0, sizeof(dcmd->msg) + extra); 799 799 + qcom_glink_rx_peek(glink, &dcmd->msg, 0, sizeof(dcmd->msg) + extra); 812 800 813 801 spin_lock(&glink->rx_lock); 814 802 list_add_tail(&dcmd->node, &glink->rx_queue); ··· 841 829 return -EAGAIN; 842 830 } 843 831 844 844 - qcom_glink_rx_peak(glink, &hdr, 0, sizeof(hdr)); 832 832 + qcom_glink_rx_peek(glink, &hdr, 0, sizeof(hdr)); 845 833 chunk_size = le32_to_cpu(hdr.chunk_size); 846 834 left_size = le32_to_cpu(hdr.left_size); 847 835 ··· 906 894 goto advance_rx; 907 895 } 908 896 909 909 - qcom_glink_rx_peak(glink, intent->data + intent->offset, 897 897 + qcom_glink_rx_peek(glink, intent->data + intent->offset, 910 898 sizeof(hdr), chunk_size); 911 899 intent->offset += chunk_size; 912 900 ··· 966 954 spin_unlock_irqrestore(&glink->idr_lock, flags); 967 955 if (!channel) { 968 956 dev_err(glink->dev, "intents for non-existing channel\n"); 957 957 + qcom_glink_rx_advance(glink, ALIGN(msglen, 8)); 969 958 return; 970 959 } 971 960 ··· 974 961 if (!msg) 975 962 return; 976 963 977 977 - qcom_glink_rx_peak(glink, msg, 0, msglen); 964 964 + qcom_glink_rx_peek(glink, msg, 0, msglen); 978 965 979 966 for (i = 0; i < count; ++i) { 980 967 intent = kzalloc(sizeof(*intent), GFP_ATOMIC); ··· 1014 1001 return 0; 1015 1002 } 1016 1003 1017 1017 - static irqreturn_t qcom_glink_native_intr(int irq, void *data) 1004 1004 + void qcom_glink_native_rx(struct qcom_glink *glink) 1018 1005 { 1019 1019 - struct qcom_glink *glink = data; 1020 1006 struct glink_msg msg; 1021 1007 unsigned int param1; 1022 1008 unsigned int param2; ··· 1031 1019 if (avail < sizeof(msg)) 1032 1020 break; 1033 1021 1034 1034 - qcom_glink_rx_peak(glink, &msg, 0, sizeof(msg)); 1022 1022 + qcom_glink_rx_peek(glink, &msg, 0, sizeof(msg)); 1035 1023 1036 1024 cmd = le16_to_cpu(msg.cmd); 1037 1025 param1 = le16_to_cpu(msg.param1); 1038 1026 param2 = le32_to_cpu(msg.param2); 1039 1027 1040 1028 switch (cmd) { 1041 1041 - case RPM_CMD_VERSION: 1042 1042 - case RPM_CMD_VERSION_ACK: 1043 1043 - case RPM_CMD_CLOSE: 1044 1044 - case RPM_CMD_CLOSE_ACK: 1045 1045 - case RPM_CMD_RX_INTENT_REQ: 1029 1029 + case GLINK_CMD_VERSION: 1030 1030 + case GLINK_CMD_VERSION_ACK: 1031 1031 + case GLINK_CMD_CLOSE: 1032 1032 + case GLINK_CMD_CLOSE_ACK: 1033 1033 + case GLINK_CMD_RX_INTENT_REQ: 1046 1034 ret = qcom_glink_rx_defer(glink, 0); 1047 1035 break; 1048 1048 - case RPM_CMD_OPEN_ACK: 1036 1036 + case GLINK_CMD_OPEN_ACK: 1049 1037 ret = qcom_glink_rx_open_ack(glink, param1); 1050 1038 qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1051 1039 break; 1052 1052 - case RPM_CMD_OPEN: 1040 1040 + case GLINK_CMD_OPEN: 1053 1041 ret = qcom_glink_rx_defer(glink, param2); 1054 1042 break; 1055 1055 - case RPM_CMD_TX_DATA: 1056 1056 - case RPM_CMD_TX_DATA_CONT: 1043 1043 + case GLINK_CMD_TX_DATA: 1044 1044 + case GLINK_CMD_TX_DATA_CONT: 1057 1045 ret = qcom_glink_rx_data(glink, avail); 1058 1046 break; 1059 1059 - case RPM_CMD_READ_NOTIF: 1047 1047 + case GLINK_CMD_READ_NOTIF: 1060 1048 qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1061 1061 - 1062 1062 - mbox_send_message(glink->mbox_chan, NULL); 1063 1063 - mbox_client_txdone(glink->mbox_chan, 0); 1049 1049 + qcom_glink_tx_kick(glink); 1064 1050 break; 1065 1065 - case RPM_CMD_INTENT: 1051 1051 + case GLINK_CMD_INTENT: 1066 1052 qcom_glink_handle_intent(glink, param1, param2, avail); 1067 1053 break; 1068 1068 - case RPM_CMD_RX_DONE: 1054 1054 + case GLINK_CMD_RX_DONE: 1069 1055 qcom_glink_handle_rx_done(glink, param1, param2, false); 1070 1056 qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1071 1057 break; 1072 1072 - case RPM_CMD_RX_DONE_W_REUSE: 1058 1058 + case GLINK_CMD_RX_DONE_W_REUSE: 1073 1059 qcom_glink_handle_rx_done(glink, param1, param2, true); 1074 1060 qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1075 1061 break; 1076 1076 - case RPM_CMD_RX_INTENT_REQ_ACK: 1062 1062 + case GLINK_CMD_RX_INTENT_REQ_ACK: 1077 1063 qcom_glink_handle_intent_req_ack(glink, param1, param2); 1078 1064 qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8)); 1079 1065 break; ··· 1084 1074 if (ret) 1085 1075 break; 1086 1076 } 1087 1087 - 1088 1088 - return IRQ_HANDLED; 1089 1077 } 1078 1078 + EXPORT_SYMBOL(qcom_glink_native_rx); 1090 1079 1091 1080 /* Locally initiated rpmsg_create_ept */ 1092 1081 static struct glink_channel *qcom_glink_create_local(struct qcom_glink *glink, ··· 1273 1264 1274 1265 reinit_completion(&channel->intent_req_comp); 1275 1266 1276 1276 - cmd.id = RPM_CMD_RX_INTENT_REQ; 1267 1267 + cmd.id = GLINK_CMD_RX_INTENT_REQ; 1277 1268 cmd.cid = channel->lcid; 1278 1269 cmd.size = size; 1279 1270 ··· 1347 1338 chunk_size = SZ_8K; 1348 1339 left_size = len - chunk_size; 1349 1340 } 1350 1350 - req.msg.cmd = cpu_to_le16(RPM_CMD_TX_DATA); 1341 1341 + req.msg.cmd = cpu_to_le16(GLINK_CMD_TX_DATA); 1351 1342 req.msg.param1 = cpu_to_le16(channel->lcid); 1352 1343 req.msg.param2 = cpu_to_le32(iid); 1353 1344 req.chunk_size = cpu_to_le32(chunk_size); ··· 1368 1359 chunk_size = SZ_8K; 1369 1360 left_size -= chunk_size; 1370 1361 1371 1371 - req.msg.cmd = cpu_to_le16(RPM_CMD_TX_DATA_CONT); 1362 1362 + req.msg.cmd = cpu_to_le16(GLINK_CMD_TX_DATA_CONT); 1372 1363 req.msg.param1 = cpu_to_le16(channel->lcid); 1373 1364 req.msg.param2 = cpu_to_le32(iid); 1374 1365 req.chunk_size = cpu_to_le32(chunk_size); ··· 1455 1446 { 1456 1447 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 1457 1448 1449 1449 + kfree(rpdev->driver_override); 1458 1450 kfree(rpdev); 1459 1451 } 1460 1452 ··· 1633 1623 param2 = le32_to_cpu(msg->param2); 1634 1624 1635 1625 switch (cmd) { 1636 1636 - case RPM_CMD_VERSION: 1626 1626 + case GLINK_CMD_VERSION: 1637 1627 qcom_glink_receive_version(glink, param1, param2); 1638 1628 break; 1639 1639 - case RPM_CMD_VERSION_ACK: 1629 1629 + case GLINK_CMD_VERSION_ACK: 1640 1630 qcom_glink_receive_version_ack(glink, param1, param2); 1641 1631 break; 1642 1642 - case RPM_CMD_OPEN: 1632 1632 + case GLINK_CMD_OPEN: 1643 1633 qcom_glink_rx_open(glink, param1, msg->data); 1644 1634 break; 1645 1645 - case RPM_CMD_CLOSE: 1635 1635 + case GLINK_CMD_CLOSE: 1646 1636 qcom_glink_rx_close(glink, param1); 1647 1637 break; 1648 1648 - case RPM_CMD_CLOSE_ACK: 1638 1638 + case GLINK_CMD_CLOSE_ACK: 1649 1639 qcom_glink_rx_close_ack(glink, param1); 1650 1640 break; 1651 1651 - case RPM_CMD_RX_INTENT_REQ: 1641 1641 + case GLINK_CMD_RX_INTENT_REQ: 1652 1642 qcom_glink_handle_intent_req(glink, param1, param2); 1653 1643 break; 1654 1644 default: ··· 1699 1689 1700 1690 /* Release qcom_glink_alloc_channel() reference */ 1701 1691 kref_put(&channel->refcount, qcom_glink_channel_release); 1692 1692 + kfree(rpdev->driver_override); 1702 1693 kfree(rpdev); 1703 1694 } 1704 1695 ··· 1733 1722 struct qcom_glink_pipe *tx, 1734 1723 bool intentless) 1735 1724 { 1736 1736 - int irq; 1737 1725 int ret; 1738 1726 struct qcom_glink *glink; 1739 1727 ··· 1763 1753 if (ret) 1764 1754 dev_err(dev, "failed to add groups\n"); 1765 1755 1766 1766 - glink->mbox_client.dev = dev; 1767 1767 - glink->mbox_client.knows_txdone = true; 1768 1768 - glink->mbox_chan = mbox_request_channel(&glink->mbox_client, 0); 1769 1769 - if (IS_ERR(glink->mbox_chan)) { 1770 1770 - if (PTR_ERR(glink->mbox_chan) != -EPROBE_DEFER) 1771 1771 - dev_err(dev, "failed to acquire IPC channel\n"); 1772 1772 - return ERR_CAST(glink->mbox_chan); 1773 1773 - } 1774 1774 - 1775 1775 - irq = of_irq_get(dev->of_node, 0); 1776 1776 - ret = devm_request_irq(dev, irq, 1777 1777 - qcom_glink_native_intr, 1778 1778 - IRQF_NO_SUSPEND | IRQF_SHARED, 1779 1779 - "glink-native", glink); 1780 1780 - if (ret) { 1781 1781 - dev_err(dev, "failed to request IRQ\n"); 1782 1782 - return ERR_PTR(ret); 1783 1783 - } 1784 1784 - 1785 1785 - glink->irq = irq; 1786 1786 - 1787 1756 ret = qcom_glink_send_version(glink); 1788 1757 if (ret) 1789 1758 return ERR_PTR(ret); ··· 1785 1796 void qcom_glink_native_remove(struct qcom_glink *glink) 1786 1797 { 1787 1798 struct glink_channel *channel; 1799 1799 + unsigned long flags; 1788 1800 int cid; 1789 1801 int ret; 1790 1802 1791 1791 - disable_irq(glink->irq); 1792 1803 qcom_glink_cancel_rx_work(glink); 1804 1804 + 1805 1805 + /* Fail all attempts at sending messages */ 1806 1806 + spin_lock_irqsave(&glink->tx_lock, flags); 1807 1807 + glink->abort_tx = true; 1808 1808 + wake_up_all(&glink->tx_avail_notify); 1809 1809 + spin_unlock_irqrestore(&glink->tx_lock, flags); 1810 1810 + 1811 1811 + /* Abort any senders waiting for intent requests */ 1812 1812 + spin_lock_irqsave(&glink->idr_lock, flags); 1813 1813 + idr_for_each_entry(&glink->lcids, channel, cid) 1814 1814 + qcom_glink_intent_req_abort(channel); 1815 1815 + spin_unlock_irqrestore(&glink->idr_lock, flags); 1793 1816 1794 1817 ret = device_for_each_child(glink->dev, NULL, qcom_glink_remove_device); 1795 1818 if (ret) ··· 1817 1816 1818 1817 idr_destroy(&glink->lcids); 1819 1818 idr_destroy(&glink->rcids); 1820 1820 - mbox_free_channel(glink->mbox_chan); 1821 1819 } 1822 1820 EXPORT_SYMBOL_GPL(qcom_glink_native_remove); 1823 1823 - 1824 1824 - void qcom_glink_native_unregister(struct qcom_glink *glink) 1825 1825 - { 1826 1826 - device_unregister(glink->dev); 1827 1827 - } 1828 1828 - EXPORT_SYMBOL_GPL(qcom_glink_native_unregister); 1829 1821 1830 1822 MODULE_DESCRIPTION("Qualcomm GLINK driver"); 1831 1823 MODULE_LICENSE("GPL v2");

+6 -2

drivers/rpmsg/qcom_glink_native.h

reviewed

··· 6 6 #ifndef __QCOM_GLINK_NATIVE_H__ 7 7 #define __QCOM_GLINK_NATIVE_H__ 8 8 9 9 + #include <linux/types.h> 10 10 + 9 11 #define GLINK_FEATURE_INTENT_REUSE BIT(0) 10 12 #define GLINK_FEATURE_MIGRATION BIT(1) 11 13 #define GLINK_FEATURE_TRACER_PKT BIT(2) ··· 17 15 18 16 size_t (*avail)(struct qcom_glink_pipe *glink_pipe); 19 17 20 20 - void (*peak)(struct qcom_glink_pipe *glink_pipe, void *data, 18 18 + void (*peek)(struct qcom_glink_pipe *glink_pipe, void *data, 21 19 unsigned int offset, size_t count); 22 20 void (*advance)(struct qcom_glink_pipe *glink_pipe, size_t count); 23 21 24 22 void (*write)(struct qcom_glink_pipe *glink_pipe, 25 23 const void *hdr, size_t hlen, 26 24 const void *data, size_t dlen); 25 25 + void (*kick)(struct qcom_glink_pipe *glink_pipe); 27 26 }; 28 27 28 28 + struct device; 29 29 struct qcom_glink; 30 30 31 31 struct qcom_glink *qcom_glink_native_probe(struct device *dev, ··· 36 32 struct qcom_glink_pipe *tx, 37 33 bool intentless); 38 34 void qcom_glink_native_remove(struct qcom_glink *glink); 35 35 + void qcom_glink_native_rx(struct qcom_glink *glink); 39 36 40 40 - void qcom_glink_native_unregister(struct qcom_glink *glink); 41 37 #endif

+76 -20

drivers/rpmsg/qcom_glink_rpm.c

reviewed

··· 11 11 #include <linux/module.h> 12 12 #include <linux/of.h> 13 13 #include <linux/of_address.h> 14 14 + #include <linux/of_irq.h> 14 15 #include <linux/platform_device.h> 15 16 #include <linux/regmap.h> 16 17 #include <linux/rpmsg.h> ··· 54 53 void __iomem *fifo; 55 54 }; 56 55 56 56 + struct glink_rpm { 57 57 + struct qcom_glink *glink; 58 58 + 59 59 + int irq; 60 60 + 61 61 + struct mbox_client mbox_client; 62 62 + struct mbox_chan *mbox_chan; 63 63 + 64 64 + struct glink_rpm_pipe rx_pipe; 65 65 + struct glink_rpm_pipe tx_pipe; 66 66 + }; 67 67 + 57 68 static size_t glink_rpm_rx_avail(struct qcom_glink_pipe *glink_pipe) 58 69 { 59 70 struct glink_rpm_pipe *pipe = to_rpm_pipe(glink_pipe); ··· 81 68 return head - tail; 82 69 } 83 70 84 84 - static void glink_rpm_rx_peak(struct qcom_glink_pipe *glink_pipe, 71 71 + static void glink_rpm_rx_peek(struct qcom_glink_pipe *glink_pipe, 85 72 void *data, unsigned int offset, size_t count) 86 73 { 87 74 struct glink_rpm_pipe *pipe = to_rpm_pipe(glink_pipe); ··· 192 179 writel(head, pipe->head); 193 180 } 194 181 182 182 + static void glink_rpm_tx_kick(struct qcom_glink_pipe *glink_pipe) 183 183 + { 184 184 + struct glink_rpm_pipe *pipe = to_rpm_pipe(glink_pipe); 185 185 + struct glink_rpm *rpm = container_of(pipe, struct glink_rpm, tx_pipe); 186 186 + 187 187 + mbox_send_message(rpm->mbox_chan, NULL); 188 188 + mbox_client_txdone(rpm->mbox_chan, 0); 189 189 + } 190 190 + 191 191 + static irqreturn_t qcom_glink_rpm_intr(int irq, void *data) 192 192 + { 193 193 + struct glink_rpm *rpm = data; 194 194 + 195 195 + qcom_glink_native_rx(rpm->glink); 196 196 + 197 197 + return IRQ_HANDLED; 198 198 + } 199 199 + 195 200 static int glink_rpm_parse_toc(struct device *dev, 196 201 void __iomem *msg_ram, 197 202 size_t msg_ram_size, ··· 288 257 static int glink_rpm_probe(struct platform_device *pdev) 289 258 { 290 259 struct qcom_glink *glink; 291 291 - struct glink_rpm_pipe *rx_pipe; 292 292 - struct glink_rpm_pipe *tx_pipe; 260 260 + struct glink_rpm *rpm; 293 261 struct device_node *np; 294 262 void __iomem *msg_ram; 295 263 size_t msg_ram_size; ··· 296 266 struct resource r; 297 267 int ret; 298 268 299 299 - rx_pipe = devm_kzalloc(&pdev->dev, sizeof(*rx_pipe), GFP_KERNEL); 300 300 - tx_pipe = devm_kzalloc(&pdev->dev, sizeof(*tx_pipe), GFP_KERNEL); 301 301 - if (!rx_pipe || !tx_pipe) 269 269 + rpm = devm_kzalloc(&pdev->dev, sizeof(*rpm), GFP_KERNEL); 270 270 + if (!rpm) 302 271 return -ENOMEM; 303 272 304 273 np = of_parse_phandle(dev->of_node, "qcom,rpm-msg-ram", 0); ··· 312 283 return -ENOMEM; 313 284 314 285 ret = glink_rpm_parse_toc(dev, msg_ram, msg_ram_size, 315 315 - rx_pipe, tx_pipe); 286 286 + &rpm->rx_pipe, &rpm->tx_pipe); 316 287 if (ret) 317 288 return ret; 318 289 290 290 + rpm->irq = of_irq_get(dev->of_node, 0); 291 291 + ret = devm_request_irq(dev, rpm->irq, qcom_glink_rpm_intr, 292 292 + IRQF_NO_SUSPEND | IRQF_NO_AUTOEN, 293 293 + "glink-rpm", rpm); 294 294 + if (ret) { 295 295 + dev_err(dev, "failed to request IRQ\n"); 296 296 + return ret; 297 297 + } 298 298 + 299 299 + rpm->mbox_client.dev = dev; 300 300 + rpm->mbox_client.knows_txdone = true; 301 301 + rpm->mbox_chan = mbox_request_channel(&rpm->mbox_client, 0); 302 302 + if (IS_ERR(rpm->mbox_chan)) 303 303 + return dev_err_probe(dev, PTR_ERR(rpm->mbox_chan), "failed to acquire IPC channel\n"); 304 304 + 319 305 /* Pipe specific accessors */ 320 320 - rx_pipe->native.avail = glink_rpm_rx_avail; 321 321 - rx_pipe->native.peak = glink_rpm_rx_peak; 322 322 - rx_pipe->native.advance = glink_rpm_rx_advance; 323 323 - tx_pipe->native.avail = glink_rpm_tx_avail; 324 324 - tx_pipe->native.write = glink_rpm_tx_write; 306 306 + rpm->rx_pipe.native.avail = glink_rpm_rx_avail; 307 307 + rpm->rx_pipe.native.peek = glink_rpm_rx_peek; 308 308 + rpm->rx_pipe.native.advance = glink_rpm_rx_advance; 309 309 + rpm->tx_pipe.native.avail = glink_rpm_tx_avail; 310 310 + rpm->tx_pipe.native.write = glink_rpm_tx_write; 311 311 + rpm->tx_pipe.native.kick = glink_rpm_tx_kick; 325 312 326 326 - writel(0, tx_pipe->head); 327 327 - writel(0, rx_pipe->tail); 313 313 + writel(0, rpm->tx_pipe.head); 314 314 + writel(0, rpm->rx_pipe.tail); 328 315 329 329 - glink = qcom_glink_native_probe(&pdev->dev, 316 316 + glink = qcom_glink_native_probe(dev, 330 317 0, 331 331 - &rx_pipe->native, 332 332 - &tx_pipe->native, 318 318 + &rpm->rx_pipe.native, 319 319 + &rpm->tx_pipe.native, 333 320 true); 334 334 - if (IS_ERR(glink)) 321 321 + if (IS_ERR(glink)) { 322 322 + mbox_free_channel(rpm->mbox_chan); 335 323 return PTR_ERR(glink); 324 324 + } 336 325 337 337 - platform_set_drvdata(pdev, glink); 326 326 + rpm->glink = glink; 327 327 + 328 328 + platform_set_drvdata(pdev, rpm); 329 329 + 330 330 + enable_irq(rpm->irq); 338 331 339 332 return 0; 340 333 } 341 334 342 335 static int glink_rpm_remove(struct platform_device *pdev) 343 336 { 344 344 - struct qcom_glink *glink = platform_get_drvdata(pdev); 337 337 + struct glink_rpm *rpm = platform_get_drvdata(pdev); 338 338 + struct qcom_glink *glink = rpm->glink; 339 339 + 340 340 + disable_irq(rpm->irq); 345 341 346 342 qcom_glink_native_remove(glink); 343 343 + 344 344 + mbox_free_channel(rpm->mbox_chan); 347 345 348 346 return 0; 349 347 }

+90 -18

drivers/rpmsg/qcom_glink_smem.c

reviewed

··· 7 7 #include <linux/module.h> 8 8 #include <linux/of.h> 9 9 #include <linux/of_address.h> 10 10 + #include <linux/of_irq.h> 10 11 #include <linux/interrupt.h> 11 12 #include <linux/platform_device.h> 13 13 + #include <linux/mailbox_client.h> 12 14 #include <linux/mfd/syscon.h> 13 15 #include <linux/slab.h> 14 16 #include <linux/rpmsg.h> ··· 35 33 #define SMEM_GLINK_NATIVE_XPRT_FIFO_0 479 36 34 #define SMEM_GLINK_NATIVE_XPRT_FIFO_1 480 37 35 36 36 + struct qcom_glink_smem { 37 37 + struct device dev; 38 38 + 39 39 + int irq; 40 40 + struct qcom_glink *glink; 41 41 + 42 42 + struct mbox_client mbox_client; 43 43 + struct mbox_chan *mbox_chan; 44 44 + 45 45 + u32 remote_pid; 46 46 + }; 47 47 + 38 48 struct glink_smem_pipe { 39 49 struct qcom_glink_pipe native; 40 50 ··· 55 41 56 42 void *fifo; 57 43 58 58 - int remote_pid; 44 44 + struct qcom_glink_smem *smem; 59 45 }; 60 46 61 47 #define to_smem_pipe(p) container_of(p, struct glink_smem_pipe, native) ··· 63 49 static size_t glink_smem_rx_avail(struct qcom_glink_pipe *np) 64 50 { 65 51 struct glink_smem_pipe *pipe = to_smem_pipe(np); 52 52 + struct qcom_glink_smem *smem = pipe->smem; 66 53 size_t len; 67 54 void *fifo; 68 55 u32 head; 69 56 u32 tail; 70 57 71 58 if (!pipe->fifo) { 72 72 - fifo = qcom_smem_get(pipe->remote_pid, 59 59 + fifo = qcom_smem_get(smem->remote_pid, 73 60 SMEM_GLINK_NATIVE_XPRT_FIFO_1, &len); 74 61 if (IS_ERR(fifo)) { 75 62 pr_err("failed to acquire RX fifo handle: %ld\n", ··· 91 76 return head - tail; 92 77 } 93 78 94 94 - static void glink_smem_rx_peak(struct qcom_glink_pipe *np, 79 79 + static void glink_smem_rx_peek(struct qcom_glink_pipe *np, 95 80 void *data, unsigned int offset, size_t count) 96 81 { 97 82 struct glink_smem_pipe *pipe = to_smem_pipe(np); ··· 192 177 *pipe->head = cpu_to_le32(head); 193 178 } 194 179 195 195 - static void qcom_glink_smem_release(struct device *dev) 180 180 + static void glink_smem_tx_kick(struct qcom_glink_pipe *glink_pipe) 196 181 { 197 197 - kfree(dev); 182 182 + struct glink_smem_pipe *pipe = to_smem_pipe(glink_pipe); 183 183 + struct qcom_glink_smem *smem = pipe->smem; 184 184 + 185 185 + mbox_send_message(smem->mbox_chan, NULL); 186 186 + mbox_client_txdone(smem->mbox_chan, 0); 198 187 } 199 188 200 200 - struct qcom_glink *qcom_glink_smem_register(struct device *parent, 201 201 - struct device_node *node) 189 189 + static irqreturn_t qcom_glink_smem_intr(int irq, void *data) 190 190 + { 191 191 + struct qcom_glink_smem *smem = data; 192 192 + 193 193 + qcom_glink_native_rx(smem->glink); 194 194 + 195 195 + return IRQ_HANDLED; 196 196 + } 197 197 + 198 198 + static void qcom_glink_smem_release(struct device *dev) 199 199 + { 200 200 + struct qcom_glink_smem *smem = container_of(dev, struct qcom_glink_smem, dev); 201 201 + 202 202 + kfree(smem); 203 203 + } 204 204 + 205 205 + struct qcom_glink_smem *qcom_glink_smem_register(struct device *parent, 206 206 + struct device_node *node) 202 207 { 203 208 struct glink_smem_pipe *rx_pipe; 204 209 struct glink_smem_pipe *tx_pipe; 210 210 + struct qcom_glink_smem *smem; 205 211 struct qcom_glink *glink; 206 212 struct device *dev; 207 213 u32 remote_pid; ··· 230 194 size_t size; 231 195 int ret; 232 196 233 233 - dev = kzalloc(sizeof(*dev), GFP_KERNEL); 234 234 - if (!dev) 197 197 + smem = kzalloc(sizeof(*smem), GFP_KERNEL); 198 198 + if (!smem) 235 199 return ERR_PTR(-ENOMEM); 200 200 + 201 201 + dev = &smem->dev; 236 202 237 203 dev->parent = parent; 238 204 dev->of_node = node; ··· 253 215 dev_err(dev, "failed to parse qcom,remote-pid\n"); 254 216 goto err_put_dev; 255 217 } 218 218 + 219 219 + smem->remote_pid = remote_pid; 256 220 257 221 rx_pipe = devm_kzalloc(dev, sizeof(*rx_pipe), GFP_KERNEL); 258 222 tx_pipe = devm_kzalloc(dev, sizeof(*tx_pipe), GFP_KERNEL); ··· 304 264 goto err_put_dev; 305 265 } 306 266 307 307 - rx_pipe->native.avail = glink_smem_rx_avail; 308 308 - rx_pipe->native.peak = glink_smem_rx_peak; 309 309 - rx_pipe->native.advance = glink_smem_rx_advance; 310 310 - rx_pipe->remote_pid = remote_pid; 267 267 + smem->irq = of_irq_get(smem->dev.of_node, 0); 268 268 + ret = devm_request_irq(&smem->dev, smem->irq, qcom_glink_smem_intr, 269 269 + IRQF_NO_SUSPEND | IRQF_NO_AUTOEN, 270 270 + "glink-smem", smem); 271 271 + if (ret) { 272 272 + dev_err(&smem->dev, "failed to request IRQ\n"); 273 273 + goto err_put_dev; 274 274 + } 311 275 276 276 + smem->mbox_client.dev = &smem->dev; 277 277 + smem->mbox_client.knows_txdone = true; 278 278 + smem->mbox_chan = mbox_request_channel(&smem->mbox_client, 0); 279 279 + if (IS_ERR(smem->mbox_chan)) { 280 280 + ret = dev_err_probe(&smem->dev, PTR_ERR(smem->mbox_chan), 281 281 + "failed to acquire IPC channel\n"); 282 282 + goto err_put_dev; 283 283 + } 284 284 + 285 285 + rx_pipe->smem = smem; 286 286 + rx_pipe->native.avail = glink_smem_rx_avail; 287 287 + rx_pipe->native.peek = glink_smem_rx_peek; 288 288 + rx_pipe->native.advance = glink_smem_rx_advance; 289 289 + 290 290 + tx_pipe->smem = smem; 312 291 tx_pipe->native.avail = glink_smem_tx_avail; 313 292 tx_pipe->native.write = glink_smem_tx_write; 314 314 - tx_pipe->remote_pid = remote_pid; 293 293 + tx_pipe->native.kick = glink_smem_tx_kick; 315 294 316 295 *rx_pipe->tail = 0; 317 296 *tx_pipe->head = 0; ··· 341 282 false); 342 283 if (IS_ERR(glink)) { 343 284 ret = PTR_ERR(glink); 344 344 - goto err_put_dev; 285 285 + goto err_free_mbox; 345 286 } 346 287 347 347 - return glink; 288 288 + smem->glink = glink; 289 289 + 290 290 + enable_irq(smem->irq); 291 291 + 292 292 + return smem; 293 293 + 294 294 + err_free_mbox: 295 295 + mbox_free_channel(smem->mbox_chan); 348 296 349 297 err_put_dev: 350 298 device_unregister(dev); ··· 360 294 } 361 295 EXPORT_SYMBOL_GPL(qcom_glink_smem_register); 362 296 363 363 - void qcom_glink_smem_unregister(struct qcom_glink *glink) 297 297 + void qcom_glink_smem_unregister(struct qcom_glink_smem *smem) 364 298 { 299 299 + struct qcom_glink *glink = smem->glink; 300 300 + 301 301 + disable_irq(smem->irq); 302 302 + 365 303 qcom_glink_native_remove(glink); 366 366 - qcom_glink_native_unregister(glink); 304 304 + 305 305 + mbox_free_channel(smem->mbox_chan); 306 306 + device_unregister(&smem->dev); 367 307 } 368 308 EXPORT_SYMBOL_GPL(qcom_glink_smem_unregister); 369 309

+1 -1

drivers/rpmsg/qcom_glink_ssr.c

reviewed

··· 111 111 msg.command = cpu_to_le32(GLINK_SSR_DO_CLEANUP); 112 112 msg.seq_num = cpu_to_le32(ssr->seq_num); 113 113 msg.name_len = cpu_to_le32(strlen(ssr_name)); 114 114 - strlcpy(msg.name, ssr_name, sizeof(msg.name)); 114 114 + strscpy(msg.name, ssr_name, sizeof(msg.name)); 115 115 116 116 ret = rpmsg_send(ssr->ept, &msg, sizeof(msg)); 117 117 if (ret < 0)

drivers/rpmsg/rpmsg_char.c

reviewed

··· 75 75 struct rpmsg_eptdev *eptdev = dev_to_eptdev(dev); 76 76 77 77 mutex_lock(&eptdev->ept_lock); 78 78 + eptdev->rpdev = NULL; 78 79 if (eptdev->ept) { 79 80 /* The default endpoint is released by the rpmsg core */ 80 81 if (!eptdev->default_ept) ··· 127 126 if (eptdev->ept) { 128 127 mutex_unlock(&eptdev->ept_lock); 129 128 return -EBUSY; 129 129 + } 130 130 + 131 131 + if (!eptdev->rpdev) { 132 132 + mutex_unlock(&eptdev->ept_lock); 133 133 + return -ENETRESET; 130 134 } 131 135 132 136 get_device(dev); ··· 285 279 if (!skb_queue_empty(&eptdev->queue)) 286 280 mask |= EPOLLIN | EPOLLRDNORM; 287 281 282 282 + mutex_lock(&eptdev->ept_lock); 288 283 mask |= rpmsg_poll(eptdev->ept, filp, wait); 284 284 + mutex_unlock(&eptdev->ept_lock); 289 285 290 286 return mask; 291 287 }

drivers/rpmsg/rpmsg_ctrl.c

reviewed

··· 194 194 struct rpmsg_ctrldev *ctrldev = dev_get_drvdata(&rpdev->dev); 195 195 int ret; 196 196 197 197 + mutex_lock(&ctrldev->ctrl_lock); 197 198 /* Destroy all endpoints */ 198 199 ret = device_for_each_child(&ctrldev->dev, NULL, rpmsg_chrdev_eptdev_destroy); 199 200 if (ret) 200 201 dev_warn(&rpdev->dev, "failed to nuke endpoints: %d\n", ret); 202 202 + mutex_unlock(&ctrldev->ctrl_lock); 201 203 202 204 cdev_device_del(&ctrldev->cdev, &ctrldev->dev); 203 205 put_device(&ctrldev->dev);

+6 -6

include/linux/rpmsg/qcom_glink.h

reviewed

··· 5 5 6 6 #include <linux/device.h> 7 7 8 8 - struct qcom_glink; 8 8 + struct qcom_glink_smem; 9 9 10 10 #if IS_ENABLED(CONFIG_RPMSG_QCOM_GLINK) 11 11 void qcom_glink_ssr_notify(const char *ssr_name); ··· 15 15 16 16 #if IS_ENABLED(CONFIG_RPMSG_QCOM_GLINK_SMEM) 17 17 18 18 - struct qcom_glink *qcom_glink_smem_register(struct device *parent, 19 19 - struct device_node *node); 20 20 - void qcom_glink_smem_unregister(struct qcom_glink *glink); 18 18 + struct qcom_glink_smem *qcom_glink_smem_register(struct device *parent, 19 19 + struct device_node *node); 20 20 + void qcom_glink_smem_unregister(struct qcom_glink_smem *glink); 21 21 22 22 #else 23 23 24 24 - static inline struct qcom_glink * 24 24 + static inline struct qcom_glink_smem * 25 25 qcom_glink_smem_register(struct device *parent, 26 26 struct device_node *node) 27 27 { 28 28 return NULL; 29 29 } 30 30 31 31 - static inline void qcom_glink_smem_unregister(struct qcom_glink *glink) {} 31 31 + static inline void qcom_glink_smem_unregister(struct qcom_glink_smem *glink) {} 32 32 #endif 33 33 34 34 #endif