cregit-Linux how code gets into the kernel

Release 4.14 drivers/rpmsg/qcom_glink_native.c

Directory: drivers/rpmsg
/*
 * Copyright (c) 2016-2017, Linaro Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/idr.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/list.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/rpmsg.h>
#include <linux/sizes.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/mailbox_client.h>

#include "rpmsg_internal.h"
#include "qcom_glink_native.h"


#define GLINK_NAME_SIZE		32

#define GLINK_VERSION_1		1


#define RPM_GLINK_CID_MIN	1

#define RPM_GLINK_CID_MAX	65536


struct glink_msg {
	
__le16 cmd;
	
__le16 param1;
	
__le32 param2;
	
u8 data[];

} __packed;

/**
 * struct glink_defer_cmd - deferred incoming control message
 * @node:       list node
 * @msg:        message header
 * data:        payload of the message
 *
 * Copy of a received control message, to be added to @rx_queue and processed
 * by @rx_work of @qcom_glink.
 */

struct glink_defer_cmd {
	
struct list_head node;

	
struct glink_msg msg;
	
u8 data[];
};

/**
 * struct glink_core_rx_intent - RX intent
 * RX intent
 *
 * data: pointer to the data (may be NULL for zero-copy)
 * id: remote or local intent ID
 * size: size of the original intent (do not modify)
 * reuse: To mark if the intent can be reused after first use
 * in_use: To mark if intent is already in use for the channel
 * offset: next write offset (initially 0)
 */

struct glink_core_rx_intent {
	
void *data;
	
u32 id;
	
size_t size;
	
bool reuse;
	
bool in_use;
	
u32 offset;

	
struct list_head node;
};

/**
 * struct qcom_glink - driver context, relates to one remote subsystem
 * @dev:        reference to the associated struct device
 * @mbox_client: mailbox client
 * @mbox_chan:  mailbox channel
 * @rx_pipe:    pipe object for receive FIFO
 * @tx_pipe:    pipe object for transmit FIFO
 * @irq:        IRQ for signaling incoming events
 * @rx_work:    worker for handling received control messages
 * @rx_lock:    protects the @rx_queue
 * @rx_queue:   queue of received control messages to be processed in @rx_work
 * @tx_lock:    synchronizes operations on the tx fifo
 * @idr_lock:   synchronizes @lcids and @rcids modifications
 * @lcids:      idr of all channels with a known local channel id
 * @rcids:      idr of all channels with a known remote channel id
 */

struct qcom_glink {
	
struct device *dev;

	
struct mbox_client mbox_client;
	
struct mbox_chan *mbox_chan;

	
struct qcom_glink_pipe *rx_pipe;
	
struct qcom_glink_pipe *tx_pipe;

	
int irq;

	
struct work_struct rx_work;
	
spinlock_t rx_lock;
	
struct list_head rx_queue;

	
struct mutex tx_lock;

	
spinlock_t idr_lock;
	
struct idr lcids;
	
struct idr rcids;
	
unsigned long features;

	
bool intentless;
};

enum {
	
GLINK_STATE_CLOSED,
	
GLINK_STATE_OPENING,
	
GLINK_STATE_OPEN,
	
GLINK_STATE_CLOSING,
};

/**
 * struct glink_channel - internal representation of a channel
 * @rpdev:      rpdev reference, only used for primary endpoints
 * @ept:        rpmsg endpoint this channel is associated with
 * @glink:      qcom_glink context handle
 * @refcount:   refcount for the channel object
 * @recv_lock:  guard for @ept.cb
 * @name:       unique channel name/identifier
 * @lcid:       channel id, in local space
 * @rcid:       channel id, in remote space
 * @intent_lock: lock for protection of @liids, @riids
 * @liids:      idr of all local intents
 * @riids:      idr of all remote intents
 * @intent_work: worker responsible for transmitting rx_done packets
 * @done_intents: list of intents that needs to be announced rx_done
 * @buf:        receive buffer, for gathering fragments
 * @buf_offset: write offset in @buf
 * @buf_size:   size of current @buf
 * @open_ack:   completed once remote has acked the open-request
 * @open_req:   completed once open-request has been received
 * @intent_req_lock: Synchronises multiple intent requests
 * @intent_req_result: Result of intent request
 * @intent_req_comp: Completion for intent_req signalling
 */

struct glink_channel {
	
struct rpmsg_endpoint ept;

	
struct rpmsg_device *rpdev;
	
struct qcom_glink *glink;

	
struct kref refcount;

	
spinlock_t recv_lock;

	
char *name;
	
unsigned int lcid;
	
unsigned int rcid;

	
spinlock_t intent_lock;
	
struct idr liids;
	
struct idr riids;
	
struct work_struct intent_work;
	
struct list_head done_intents;

	
struct glink_core_rx_intent *buf;
	
int buf_offset;
	
int buf_size;

	
struct completion open_ack;
	
struct completion open_req;

	
struct mutex intent_req_lock;
	
bool intent_req_result;
	
struct completion intent_req_comp;
};


#define to_glink_channel(_ept) container_of(_ept, struct glink_channel, ept)


static const struct rpmsg_endpoint_ops glink_endpoint_ops;


#define RPM_CMD_VERSION			0

#define RPM_CMD_VERSION_ACK		1

#define RPM_CMD_OPEN			2

#define RPM_CMD_CLOSE			3

#define RPM_CMD_OPEN_ACK		4

#define RPM_CMD_INTENT			5

#define RPM_CMD_RX_DONE			6

#define RPM_CMD_RX_INTENT_REQ		7

#define RPM_CMD_RX_INTENT_REQ_ACK	8

#define RPM_CMD_TX_DATA			9

#define RPM_CMD_CLOSE_ACK		11

#define RPM_CMD_TX_DATA_CONT		12

#define RPM_CMD_READ_NOTIF		13

#define RPM_CMD_RX_DONE_W_REUSE		14


#define GLINK_FEATURE_INTENTLESS	BIT(1)

static void qcom_glink_rx_done_work(struct work_struct *work);


static struct glink_channel *qcom_glink_alloc_channel(struct qcom_glink *glink, const char *name) { struct glink_channel *channel; channel = kzalloc(sizeof(*channel), GFP_KERNEL); if (!channel) return ERR_PTR(-ENOMEM); /* Setup glink internal glink_channel data */ spin_lock_init(&channel->recv_lock); spin_lock_init(&channel->intent_lock); channel->glink = glink; channel->name = kstrdup(name, GFP_KERNEL); init_completion(&channel->open_req); init_completion(&channel->open_ack); INIT_LIST_HEAD(&channel->done_intents); INIT_WORK(&channel->intent_work, qcom_glink_rx_done_work); idr_init(&channel->liids); idr_init(&channel->riids); kref_init(&channel->refcount); return channel; }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson10170.63%125.00%
R Sricharan4229.37%375.00%
Total143100.00%4100.00%


static void qcom_glink_channel_release(struct kref *ref) { struct glink_channel *channel = container_of(ref, struct glink_channel, refcount); unsigned long flags; spin_lock_irqsave(&channel->intent_lock, flags); idr_destroy(&channel->liids); idr_destroy(&channel->riids); spin_unlock_irqrestore(&channel->intent_lock, flags); kfree(channel->name); kfree(channel); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan4051.28%266.67%
Björn Andersson3848.72%133.33%
Total78100.00%3100.00%


static size_t qcom_glink_rx_avail(struct qcom_glink *glink) { return glink->rx_pipe->avail(glink->rx_pipe); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson23100.00%1100.00%
Total23100.00%1100.00%


static void qcom_glink_rx_peak(struct qcom_glink *glink, void *data, unsigned int offset, size_t count) { glink->rx_pipe->peak(glink->rx_pipe, data, offset, count); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson39100.00%2100.00%
Total39100.00%2100.00%


static void qcom_glink_rx_advance(struct qcom_glink *glink, size_t count) { glink->rx_pipe->advance(glink->rx_pipe, count); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson27100.00%1100.00%
Total27100.00%1100.00%


static size_t qcom_glink_tx_avail(struct qcom_glink *glink) { return glink->tx_pipe->avail(glink->tx_pipe); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson23100.00%1100.00%
Total23100.00%1100.00%


static void qcom_glink_tx_write(struct qcom_glink *glink, const void *hdr, size_t hlen, const void *data, size_t dlen) { glink->tx_pipe->write(glink->tx_pipe, hdr, hlen, data, dlen); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson46100.00%1100.00%
Total46100.00%1100.00%


static int qcom_glink_tx(struct qcom_glink *glink, const void *hdr, size_t hlen, const void *data, size_t dlen, bool wait) { unsigned int tlen = hlen + dlen; int ret; /* Reject packets that are too big */ if (tlen >= glink->tx_pipe->length) return -EINVAL; ret = mutex_lock_interruptible(&glink->tx_lock); if (ret) return ret; while (qcom_glink_tx_avail(glink) < tlen) { if (!wait) { ret = -EAGAIN; goto out; } usleep_range(10000, 15000); } qcom_glink_tx_write(glink, hdr, hlen, data, dlen); mbox_send_message(glink->mbox_chan, NULL); mbox_client_txdone(glink->mbox_chan, 0); out: mutex_unlock(&glink->tx_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson14999.33%150.00%
R Sricharan10.67%150.00%
Total150100.00%2100.00%


static int qcom_glink_send_version(struct qcom_glink *glink) { struct glink_msg msg; msg.cmd = cpu_to_le16(RPM_CMD_VERSION); msg.param1 = cpu_to_le16(GLINK_VERSION_1); msg.param2 = cpu_to_le32(glink->features); return qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson6093.75%150.00%
R Sricharan46.25%150.00%
Total64100.00%2100.00%


static void qcom_glink_send_version_ack(struct qcom_glink *glink) { struct glink_msg msg; msg.cmd = cpu_to_le16(RPM_CMD_VERSION_ACK); msg.param1 = cpu_to_le16(GLINK_VERSION_1); msg.param2 = cpu_to_le32(glink->features); qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson5993.65%150.00%
R Sricharan46.35%150.00%
Total63100.00%2100.00%


static void qcom_glink_send_open_ack(struct qcom_glink *glink, struct glink_channel *channel) { struct glink_msg msg; msg.cmd = cpu_to_le16(RPM_CMD_OPEN_ACK); msg.param1 = cpu_to_le16(channel->rcid); msg.param2 = cpu_to_le32(0); qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson68100.00%1100.00%
Total68100.00%1100.00%


static void qcom_glink_handle_intent_req_ack(struct qcom_glink *glink, unsigned int cid, bool granted) { struct glink_channel *channel; unsigned long flags; spin_lock_irqsave(&glink->idr_lock, flags); channel = idr_find(&glink->rcids, cid); spin_unlock_irqrestore(&glink->idr_lock, flags); if (!channel) { dev_err(glink->dev, "unable to find channel\n"); return; } channel->intent_req_result = granted; complete(&channel->intent_req_comp); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan90100.00%1100.00%
Total90100.00%1100.00%

/** * qcom_glink_send_open_req() - send a RPM_CMD_OPEN request to the remote * @glink: Ptr to the glink edge * @channel: Ptr to the channel that the open req is sent * * Allocates a local channel id and sends a RPM_CMD_OPEN message to the remote. * Will return with refcount held, regardless of outcome. * * Returns 0 on success, negative errno otherwise. */
static int qcom_glink_send_open_req(struct qcom_glink *glink, struct glink_channel *channel) { struct { struct glink_msg msg; u8 name[GLINK_NAME_SIZE]; } __packed req; int name_len = strlen(channel->name) + 1; int req_len = ALIGN(sizeof(req.msg) + name_len, 8); int ret; unsigned long flags; kref_get(&channel->refcount); spin_lock_irqsave(&glink->idr_lock, flags); ret = idr_alloc_cyclic(&glink->lcids, channel, RPM_GLINK_CID_MIN, RPM_GLINK_CID_MAX, GFP_ATOMIC); spin_unlock_irqrestore(&glink->idr_lock, flags); if (ret < 0) return ret; channel->lcid = ret; req.msg.cmd = cpu_to_le16(RPM_CMD_OPEN); req.msg.param1 = cpu_to_le16(channel->lcid); req.msg.param2 = cpu_to_le32(name_len); strcpy(req.name, channel->name); ret = qcom_glink_tx(glink, &req, req_len, NULL, 0, true); if (ret) goto remove_idr; return 0; remove_idr: spin_lock_irqsave(&glink->idr_lock, flags); idr_remove(&glink->lcids, channel->lcid); channel->lcid = 0; spin_unlock_irqrestore(&glink->idr_lock, flags); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson22993.09%150.00%
R Sricharan176.91%150.00%
Total246100.00%2100.00%


static void qcom_glink_send_close_req(struct qcom_glink *glink, struct glink_channel *channel) { struct glink_msg req; req.cmd = cpu_to_le16(RPM_CMD_CLOSE); req.param1 = cpu_to_le16(channel->lcid); req.param2 = 0; qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true); }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson65100.00%1100.00%
Total65100.00%1100.00%


static void qcom_glink_send_close_ack(struct qcom_glink *glink, unsigned int rcid) { struct glink_msg req; req.cmd = cpu_to_le16(RPM_CMD_CLOSE_ACK); req.param1 = cpu_to_le16(rcid); req.param2 = 0; qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan4064.52%150.00%
Björn Andersson2235.48%150.00%
Total62100.00%2100.00%


static void qcom_glink_rx_done_work(struct work_struct *work) { struct glink_channel *channel = container_of(work, struct glink_channel, intent_work); struct qcom_glink *glink = channel->glink; struct glink_core_rx_intent *intent, *tmp; struct { u16 id; u16 lcid; u32 liid; } __packed cmd; unsigned int cid = channel->lcid; unsigned int iid; bool reuse; unsigned long flags; spin_lock_irqsave(&channel->intent_lock, flags); list_for_each_entry_safe(intent, tmp, &channel->done_intents, node) { list_del(&intent->node); spin_unlock_irqrestore(&channel->intent_lock, flags); iid = intent->id; reuse = intent->reuse; cmd.id = reuse ? RPM_CMD_RX_DONE_W_REUSE : RPM_CMD_RX_DONE; cmd.lcid = cid; cmd.liid = iid; qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true); if (!reuse) { kfree(intent->data); kfree(intent); } spin_lock_irqsave(&channel->intent_lock, flags); } spin_unlock_irqrestore(&channel->intent_lock, flags); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan209100.00%1100.00%
Total209100.00%1100.00%


static void qcom_glink_rx_done(struct qcom_glink *glink, struct glink_channel *channel, struct glink_core_rx_intent *intent) { /* We don't send RX_DONE to intentless systems */ if (glink->intentless) { kfree(intent->data); kfree(intent); return; } /* Take it off the tree of receive intents */ if (!intent->reuse) { spin_lock(&channel->intent_lock); idr_remove(&channel->liids, intent->id); spin_unlock(&channel->intent_lock); } /* Schedule the sending of a rx_done indication */ spin_lock(&channel->intent_lock); list_add_tail(&intent->node, &channel->done_intents); spin_unlock(&channel->intent_lock); schedule_work(&channel->intent_work); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan119100.00%1100.00%
Total119100.00%1100.00%

/** * qcom_glink_receive_version() - receive version/features from remote system * * @glink: pointer to transport interface * @r_version: remote version * @r_features: remote features * * This function is called in response to a remote-initiated version/feature * negotiation sequence. */
static void qcom_glink_receive_version(struct qcom_glink *glink, u32 version, u32 features) { switch (version) { case 0: break; case GLINK_VERSION_1: glink->features &= features; /* FALLTHROUGH */ default: qcom_glink_send_version_ack(glink); break; } }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan44100.00%1100.00%
Total44100.00%1100.00%

/** * qcom_glink_receive_version_ack() - receive negotiation ack from remote system * * @glink: pointer to transport interface * @r_version: remote version response * @r_features: remote features response * * This function is called in response to a local-initiated version/feature * negotiation sequence and is the counter-offer from the remote side based * upon the initial version and feature set requested. */
static void qcom_glink_receive_version_ack(struct qcom_glink *glink, u32 version, u32 features) { switch (version) { case 0: /* Version negotiation failed */ break; case GLINK_VERSION_1: if (features == glink->features) break; glink->features &= features; /* FALLTHROUGH */ default: qcom_glink_send_version(glink); break; } }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan54100.00%1100.00%
Total54100.00%1100.00%

/** * qcom_glink_send_intent_req_ack() - convert an rx intent request ack cmd to wire format and transmit * @glink: The transport to transmit on. * @channel: The glink channel * @granted: The request response to encode. * * Return: 0 on success or standard Linux error code. */
static int qcom_glink_send_intent_req_ack(struct qcom_glink *glink, struct glink_channel *channel, bool granted) { struct glink_msg msg; msg.cmd = cpu_to_le16(RPM_CMD_RX_INTENT_REQ_ACK); msg.param1 = cpu_to_le16(channel->lcid); msg.param2 = cpu_to_le32(granted); qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan74100.00%1100.00%
Total74100.00%1100.00%

/** * qcom_glink_advertise_intent - convert an rx intent cmd to wire format and * transmit * @glink: The transport to transmit on. * @channel: The local channel * @size: The intent to pass on to remote. * * Return: 0 on success or standard Linux error code. */
static int qcom_glink_advertise_intent(struct qcom_glink *glink, struct glink_channel *channel, struct glink_core_rx_intent *intent) { struct command { u16 id; u16 lcid; u32 count; u32 size; u32 liid; } __packed; struct command cmd; cmd.id = cpu_to_le16(RPM_CMD_INTENT); cmd.lcid = cpu_to_le16(channel->lcid); cmd.count = cpu_to_le32(1); cmd.size = cpu_to_le32(intent->size); cmd.liid = cpu_to_le32(intent->id); qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan119100.00%1100.00%
Total119100.00%1100.00%


static struct glink_core_rx_intent * qcom_glink_alloc_intent(struct qcom_glink *glink, struct glink_channel *channel, size_t size, bool reuseable) { struct glink_core_rx_intent *intent; int ret; unsigned long flags; intent = kzalloc(sizeof(*intent), GFP_KERNEL); if (!intent) return NULL; intent->data = kzalloc(size, GFP_KERNEL); if (!intent->data) goto free_intent; spin_lock_irqsave(&channel->intent_lock, flags); ret = idr_alloc_cyclic(&channel->liids, intent, 1, -1, GFP_ATOMIC); if (ret < 0) { spin_unlock_irqrestore(&channel->intent_lock, flags); goto free_data; } spin_unlock_irqrestore(&channel->intent_lock, flags); intent->id = ret; intent->size = size; intent->reuse = reuseable; return intent; free_data: kfree(intent->data); free_intent: kfree(intent); return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan13676.40%133.33%
Dan Carpenter2514.04%133.33%
Björn Andersson179.55%133.33%
Total178100.00%3100.00%


static void qcom_glink_handle_rx_done(struct qcom_glink *glink, u32 cid, uint32_t iid, bool reuse) { struct glink_core_rx_intent *intent; struct glink_channel *channel; unsigned long flags; spin_lock_irqsave(&glink->idr_lock, flags); channel = idr_find(&glink->rcids, cid); spin_unlock_irqrestore(&glink->idr_lock, flags); if (!channel) { dev_err(glink->dev, "invalid channel id received\n"); return; } spin_lock_irqsave(&channel->intent_lock, flags); intent = idr_find(&channel->riids, iid); if (!intent) { spin_unlock_irqrestore(&channel->intent_lock, flags); dev_err(glink->dev, "invalid intent id received\n"); return; } intent->in_use = false; if (!reuse) { idr_remove(&channel->riids, intent->id); kfree(intent); } spin_unlock_irqrestore(&channel->intent_lock, flags); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan172100.00%1100.00%
Total172100.00%1100.00%

/** * qcom_glink_handle_intent_req() - Receive a request for rx_intent * from remote side * if_ptr: Pointer to the transport interface * rcid: Remote channel ID * size: size of the intent * * The function searches for the local channel to which the request for * rx_intent has arrived and allocates and notifies the remote back */
static void qcom_glink_handle_intent_req(struct qcom_glink *glink, u32 cid, size_t size) { struct glink_core_rx_intent *intent; struct glink_channel *channel; unsigned long flags; spin_lock_irqsave(&glink->idr_lock, flags); channel = idr_find(&glink->rcids, cid); spin_unlock_irqrestore(&glink->idr_lock, flags); if (!channel) { pr_err("%s channel not found for cid %d\n", __func__, cid); return; } intent = qcom_glink_alloc_intent(glink, channel, size, false); if (intent) qcom_glink_advertise_intent(glink, channel, intent); qcom_glink_send_intent_req_ack(glink, channel, !!intent); }

Contributors

PersonTokensPropCommitsCommitProp
R Sricharan117100.00%2100.00%
Total117100.00%2100.00%


static int qcom_glink_rx_defer(struct qcom_glink *glink, size_t extra) { struct glink_defer_cmd *dcmd; extra = ALIGN(extra, 8); if (qcom_glink_rx_avail(glink) < sizeof(struct glink_msg) + extra) { dev_dbg(glink->dev, "Insufficient data in rx fifo"); return -ENXIO; } dcmd = kzalloc(sizeof(*dcmd) + extra, GFP_ATOMIC); if (!dcmd) return -ENOMEM; INIT_LIST_HEAD(&dcmd->node); qcom_glink_rx_peak(glink, &dcmd->msg, 0, sizeof(dcmd->msg) + extra); spin_lock(&glink->rx_lock); list_add_tail(&dcmd->node, &glink->rx_queue); spin_unlock(&glink->rx_lock); schedule_work(&glink->rx_work); qcom_glink_rx_advance(glink, sizeof(dcmd->msg) + extra); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Björn Andersson165100.00%2100.00%
Total165100.00%2100.00%


static int qcom_glink_rx_data(struct qcom_glink *glink, size_t