linux/drivers/rpmsg/qcom_glink_native.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2016-2017, Linaro Ltd
   4 */
   5
   6#include <linux/idr.h>
   7#include <linux/interrupt.h>
   8#include <linux/io.h>
   9#include <linux/list.h>
  10#include <linux/mfd/syscon.h>
  11#include <linux/module.h>
  12#include <linux/of.h>
  13#include <linux/of_address.h>
  14#include <linux/of_irq.h>
  15#include <linux/platform_device.h>
  16#include <linux/regmap.h>
  17#include <linux/rpmsg.h>
  18#include <linux/sizes.h>
  19#include <linux/slab.h>
  20#include <linux/workqueue.h>
  21#include <linux/mailbox_client.h>
  22
  23#include "rpmsg_internal.h"
  24#include "qcom_glink_native.h"
  25
  26#define GLINK_NAME_SIZE         32
  27#define GLINK_VERSION_1         1
  28
  29#define RPM_GLINK_CID_MIN       1
  30#define RPM_GLINK_CID_MAX       65536
  31
  32struct glink_msg {
  33        __le16 cmd;
  34        __le16 param1;
  35        __le32 param2;
  36        u8 data[];
  37} __packed;
  38
  39/**
  40 * struct glink_defer_cmd - deferred incoming control message
  41 * @node:       list node
  42 * @msg:        message header
  43 * @data:       payload of the message
  44 *
  45 * Copy of a received control message, to be added to @rx_queue and processed
  46 * by @rx_work of @qcom_glink.
  47 */
  48struct glink_defer_cmd {
  49        struct list_head node;
  50
  51        struct glink_msg msg;
  52        u8 data[];
  53};
  54
  55/**
  56 * struct glink_core_rx_intent - RX intent
  57 * RX intent
  58 *
  59 * @data: pointer to the data (may be NULL for zero-copy)
  60 * @id: remote or local intent ID
  61 * @size: size of the original intent (do not modify)
  62 * @reuse: To mark if the intent can be reused after first use
  63 * @in_use: To mark if intent is already in use for the channel
  64 * @offset: next write offset (initially 0)
  65 * @node:       list node
  66 */
  67struct glink_core_rx_intent {
  68        void *data;
  69        u32 id;
  70        size_t size;
  71        bool reuse;
  72        bool in_use;
  73        u32 offset;
  74
  75        struct list_head node;
  76};
  77
  78/**
  79 * struct qcom_glink - driver context, relates to one remote subsystem
  80 * @dev:        reference to the associated struct device
  81 * @mbox_client: mailbox client
  82 * @mbox_chan:  mailbox channel
  83 * @rx_pipe:    pipe object for receive FIFO
  84 * @tx_pipe:    pipe object for transmit FIFO
  85 * @irq:        IRQ for signaling incoming events
  86 * @rx_work:    worker for handling received control messages
  87 * @rx_lock:    protects the @rx_queue
  88 * @rx_queue:   queue of received control messages to be processed in @rx_work
  89 * @tx_lock:    synchronizes operations on the tx fifo
  90 * @idr_lock:   synchronizes @lcids and @rcids modifications
  91 * @lcids:      idr of all channels with a known local channel id
  92 * @rcids:      idr of all channels with a known remote channel id
  93 * @features:   remote features
  94 * @intentless: flag to indicate that there is no intent
  95 */
  96struct qcom_glink {
  97        struct device *dev;
  98
  99        const char *name;
 100
 101        struct mbox_client mbox_client;
 102        struct mbox_chan *mbox_chan;
 103
 104        struct qcom_glink_pipe *rx_pipe;
 105        struct qcom_glink_pipe *tx_pipe;
 106
 107        int irq;
 108
 109        struct work_struct rx_work;
 110        spinlock_t rx_lock;
 111        struct list_head rx_queue;
 112
 113        spinlock_t tx_lock;
 114
 115        spinlock_t idr_lock;
 116        struct idr lcids;
 117        struct idr rcids;
 118        unsigned long features;
 119
 120        bool intentless;
 121};
 122
 123enum {
 124        GLINK_STATE_CLOSED,
 125        GLINK_STATE_OPENING,
 126        GLINK_STATE_OPEN,
 127        GLINK_STATE_CLOSING,
 128};
 129
 130/**
 131 * struct glink_channel - internal representation of a channel
 132 * @rpdev:      rpdev reference, only used for primary endpoints
 133 * @ept:        rpmsg endpoint this channel is associated with
 134 * @glink:      qcom_glink context handle
 135 * @refcount:   refcount for the channel object
 136 * @recv_lock:  guard for @ept.cb
 137 * @name:       unique channel name/identifier
 138 * @lcid:       channel id, in local space
 139 * @rcid:       channel id, in remote space
 140 * @intent_lock: lock for protection of @liids, @riids
 141 * @liids:      idr of all local intents
 142 * @riids:      idr of all remote intents
 143 * @intent_work: worker responsible for transmitting rx_done packets
 144 * @done_intents: list of intents that needs to be announced rx_done
 145 * @buf:        receive buffer, for gathering fragments
 146 * @buf_offset: write offset in @buf
 147 * @buf_size:   size of current @buf
 148 * @open_ack:   completed once remote has acked the open-request
 149 * @open_req:   completed once open-request has been received
 150 * @intent_req_lock: Synchronises multiple intent requests
 151 * @intent_req_result: Result of intent request
 152 * @intent_req_comp: Completion for intent_req signalling
 153 */
 154struct glink_channel {
 155        struct rpmsg_endpoint ept;
 156
 157        struct rpmsg_device *rpdev;
 158        struct qcom_glink *glink;
 159
 160        struct kref refcount;
 161
 162        spinlock_t recv_lock;
 163
 164        char *name;
 165        unsigned int lcid;
 166        unsigned int rcid;
 167
 168        spinlock_t intent_lock;
 169        struct idr liids;
 170        struct idr riids;
 171        struct work_struct intent_work;
 172        struct list_head done_intents;
 173
 174        struct glink_core_rx_intent *buf;
 175        int buf_offset;
 176        int buf_size;
 177
 178        struct completion open_ack;
 179        struct completion open_req;
 180
 181        struct mutex intent_req_lock;
 182        bool intent_req_result;
 183        struct completion intent_req_comp;
 184};
 185
 186#define to_glink_channel(_ept) container_of(_ept, struct glink_channel, ept)
 187
 188static const struct rpmsg_endpoint_ops glink_endpoint_ops;
 189
 190#define RPM_CMD_VERSION                 0
 191#define RPM_CMD_VERSION_ACK             1
 192#define RPM_CMD_OPEN                    2
 193#define RPM_CMD_CLOSE                   3
 194#define RPM_CMD_OPEN_ACK                4
 195#define RPM_CMD_INTENT                  5
 196#define RPM_CMD_RX_DONE                 6
 197#define RPM_CMD_RX_INTENT_REQ           7
 198#define RPM_CMD_RX_INTENT_REQ_ACK       8
 199#define RPM_CMD_TX_DATA                 9
 200#define RPM_CMD_CLOSE_ACK               11
 201#define RPM_CMD_TX_DATA_CONT            12
 202#define RPM_CMD_READ_NOTIF              13
 203#define RPM_CMD_RX_DONE_W_REUSE         14
 204
 205#define GLINK_FEATURE_INTENTLESS        BIT(1)
 206
 207static void qcom_glink_rx_done_work(struct work_struct *work);
 208
 209static struct glink_channel *qcom_glink_alloc_channel(struct qcom_glink *glink,
 210                                                      const char *name)
 211{
 212        struct glink_channel *channel;
 213
 214        channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 215        if (!channel)
 216                return ERR_PTR(-ENOMEM);
 217
 218        /* Setup glink internal glink_channel data */
 219        spin_lock_init(&channel->recv_lock);
 220        spin_lock_init(&channel->intent_lock);
 221        mutex_init(&channel->intent_req_lock);
 222
 223        channel->glink = glink;
 224        channel->name = kstrdup(name, GFP_KERNEL);
 225
 226        init_completion(&channel->open_req);
 227        init_completion(&channel->open_ack);
 228        init_completion(&channel->intent_req_comp);
 229
 230        INIT_LIST_HEAD(&channel->done_intents);
 231        INIT_WORK(&channel->intent_work, qcom_glink_rx_done_work);
 232
 233        idr_init(&channel->liids);
 234        idr_init(&channel->riids);
 235        kref_init(&channel->refcount);
 236
 237        return channel;
 238}
 239
 240static void qcom_glink_channel_release(struct kref *ref)
 241{
 242        struct glink_channel *channel = container_of(ref, struct glink_channel,
 243                                                     refcount);
 244        struct glink_core_rx_intent *intent;
 245        struct glink_core_rx_intent *tmp;
 246        unsigned long flags;
 247        int iid;
 248
 249        /* cancel pending rx_done work */
 250        cancel_work_sync(&channel->intent_work);
 251
 252        spin_lock_irqsave(&channel->intent_lock, flags);
 253        /* Free all non-reuse intents pending rx_done work */
 254        list_for_each_entry_safe(intent, tmp, &channel->done_intents, node) {
 255                if (!intent->reuse) {
 256                        kfree(intent->data);
 257                        kfree(intent);
 258                }
 259        }
 260
 261        idr_for_each_entry(&channel->liids, tmp, iid) {
 262                kfree(tmp->data);
 263                kfree(tmp);
 264        }
 265        idr_destroy(&channel->liids);
 266
 267        idr_for_each_entry(&channel->riids, tmp, iid)
 268                kfree(tmp);
 269        idr_destroy(&channel->riids);
 270        spin_unlock_irqrestore(&channel->intent_lock, flags);
 271
 272        kfree(channel->name);
 273        kfree(channel);
 274}
 275
 276static size_t qcom_glink_rx_avail(struct qcom_glink *glink)
 277{
 278        return glink->rx_pipe->avail(glink->rx_pipe);
 279}
 280
 281static void qcom_glink_rx_peak(struct qcom_glink *glink,
 282                               void *data, unsigned int offset, size_t count)
 283{
 284        glink->rx_pipe->peak(glink->rx_pipe, data, offset, count);
 285}
 286
 287static void qcom_glink_rx_advance(struct qcom_glink *glink, size_t count)
 288{
 289        glink->rx_pipe->advance(glink->rx_pipe, count);
 290}
 291
 292static size_t qcom_glink_tx_avail(struct qcom_glink *glink)
 293{
 294        return glink->tx_pipe->avail(glink->tx_pipe);
 295}
 296
 297static void qcom_glink_tx_write(struct qcom_glink *glink,
 298                                const void *hdr, size_t hlen,
 299                                const void *data, size_t dlen)
 300{
 301        glink->tx_pipe->write(glink->tx_pipe, hdr, hlen, data, dlen);
 302}
 303
 304static int qcom_glink_tx(struct qcom_glink *glink,
 305                         const void *hdr, size_t hlen,
 306                         const void *data, size_t dlen, bool wait)
 307{
 308        unsigned int tlen = hlen + dlen;
 309        unsigned long flags;
 310        int ret = 0;
 311
 312        /* Reject packets that are too big */
 313        if (tlen >= glink->tx_pipe->length)
 314                return -EINVAL;
 315
 316        spin_lock_irqsave(&glink->tx_lock, flags);
 317
 318        while (qcom_glink_tx_avail(glink) < tlen) {
 319                if (!wait) {
 320                        ret = -EAGAIN;
 321                        goto out;
 322                }
 323
 324                /* Wait without holding the tx_lock */
 325                spin_unlock_irqrestore(&glink->tx_lock, flags);
 326
 327                usleep_range(10000, 15000);
 328
 329                spin_lock_irqsave(&glink->tx_lock, flags);
 330        }
 331
 332        qcom_glink_tx_write(glink, hdr, hlen, data, dlen);
 333
 334        mbox_send_message(glink->mbox_chan, NULL);
 335        mbox_client_txdone(glink->mbox_chan, 0);
 336
 337out:
 338        spin_unlock_irqrestore(&glink->tx_lock, flags);
 339
 340        return ret;
 341}
 342
 343static int qcom_glink_send_version(struct qcom_glink *glink)
 344{
 345        struct glink_msg msg;
 346
 347        msg.cmd = cpu_to_le16(RPM_CMD_VERSION);
 348        msg.param1 = cpu_to_le16(GLINK_VERSION_1);
 349        msg.param2 = cpu_to_le32(glink->features);
 350
 351        return qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true);
 352}
 353
 354static void qcom_glink_send_version_ack(struct qcom_glink *glink)
 355{
 356        struct glink_msg msg;
 357
 358        msg.cmd = cpu_to_le16(RPM_CMD_VERSION_ACK);
 359        msg.param1 = cpu_to_le16(GLINK_VERSION_1);
 360        msg.param2 = cpu_to_le32(glink->features);
 361
 362        qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true);
 363}
 364
 365static void qcom_glink_send_open_ack(struct qcom_glink *glink,
 366                                     struct glink_channel *channel)
 367{
 368        struct glink_msg msg;
 369
 370        msg.cmd = cpu_to_le16(RPM_CMD_OPEN_ACK);
 371        msg.param1 = cpu_to_le16(channel->rcid);
 372        msg.param2 = cpu_to_le32(0);
 373
 374        qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true);
 375}
 376
 377static void qcom_glink_handle_intent_req_ack(struct qcom_glink *glink,
 378                                             unsigned int cid, bool granted)
 379{
 380        struct glink_channel *channel;
 381        unsigned long flags;
 382
 383        spin_lock_irqsave(&glink->idr_lock, flags);
 384        channel = idr_find(&glink->rcids, cid);
 385        spin_unlock_irqrestore(&glink->idr_lock, flags);
 386        if (!channel) {
 387                dev_err(glink->dev, "unable to find channel\n");
 388                return;
 389        }
 390
 391        channel->intent_req_result = granted;
 392        complete(&channel->intent_req_comp);
 393}
 394
 395/**
 396 * qcom_glink_send_open_req() - send a RPM_CMD_OPEN request to the remote
 397 * @glink: Ptr to the glink edge
 398 * @channel: Ptr to the channel that the open req is sent
 399 *
 400 * Allocates a local channel id and sends a RPM_CMD_OPEN message to the remote.
 401 * Will return with refcount held, regardless of outcome.
 402 *
 403 * Returns 0 on success, negative errno otherwise.
 404 */
 405static int qcom_glink_send_open_req(struct qcom_glink *glink,
 406                                    struct glink_channel *channel)
 407{
 408        struct {
 409                struct glink_msg msg;
 410                u8 name[GLINK_NAME_SIZE];
 411        } __packed req;
 412        int name_len = strlen(channel->name) + 1;
 413        int req_len = ALIGN(sizeof(req.msg) + name_len, 8);
 414        int ret;
 415        unsigned long flags;
 416
 417        kref_get(&channel->refcount);
 418
 419        spin_lock_irqsave(&glink->idr_lock, flags);
 420        ret = idr_alloc_cyclic(&glink->lcids, channel,
 421                               RPM_GLINK_CID_MIN, RPM_GLINK_CID_MAX,
 422                               GFP_ATOMIC);
 423        spin_unlock_irqrestore(&glink->idr_lock, flags);
 424        if (ret < 0)
 425                return ret;
 426
 427        channel->lcid = ret;
 428
 429        req.msg.cmd = cpu_to_le16(RPM_CMD_OPEN);
 430        req.msg.param1 = cpu_to_le16(channel->lcid);
 431        req.msg.param2 = cpu_to_le32(name_len);
 432        strcpy(req.name, channel->name);
 433
 434        ret = qcom_glink_tx(glink, &req, req_len, NULL, 0, true);
 435        if (ret)
 436                goto remove_idr;
 437
 438        return 0;
 439
 440remove_idr:
 441        spin_lock_irqsave(&glink->idr_lock, flags);
 442        idr_remove(&glink->lcids, channel->lcid);
 443        channel->lcid = 0;
 444        spin_unlock_irqrestore(&glink->idr_lock, flags);
 445
 446        return ret;
 447}
 448
 449static void qcom_glink_send_close_req(struct qcom_glink *glink,
 450                                      struct glink_channel *channel)
 451{
 452        struct glink_msg req;
 453
 454        req.cmd = cpu_to_le16(RPM_CMD_CLOSE);
 455        req.param1 = cpu_to_le16(channel->lcid);
 456        req.param2 = 0;
 457
 458        qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true);
 459}
 460
 461static void qcom_glink_send_close_ack(struct qcom_glink *glink,
 462                                      unsigned int rcid)
 463{
 464        struct glink_msg req;
 465
 466        req.cmd = cpu_to_le16(RPM_CMD_CLOSE_ACK);
 467        req.param1 = cpu_to_le16(rcid);
 468        req.param2 = 0;
 469
 470        qcom_glink_tx(glink, &req, sizeof(req), NULL, 0, true);
 471}
 472
 473static void qcom_glink_rx_done_work(struct work_struct *work)
 474{
 475        struct glink_channel *channel = container_of(work, struct glink_channel,
 476                                                     intent_work);
 477        struct qcom_glink *glink = channel->glink;
 478        struct glink_core_rx_intent *intent, *tmp;
 479        struct {
 480                u16 id;
 481                u16 lcid;
 482                u32 liid;
 483        } __packed cmd;
 484
 485        unsigned int cid = channel->lcid;
 486        unsigned int iid;
 487        bool reuse;
 488        unsigned long flags;
 489
 490        spin_lock_irqsave(&channel->intent_lock, flags);
 491        list_for_each_entry_safe(intent, tmp, &channel->done_intents, node) {
 492                list_del(&intent->node);
 493                spin_unlock_irqrestore(&channel->intent_lock, flags);
 494                iid = intent->id;
 495                reuse = intent->reuse;
 496
 497                cmd.id = reuse ? RPM_CMD_RX_DONE_W_REUSE : RPM_CMD_RX_DONE;
 498                cmd.lcid = cid;
 499                cmd.liid = iid;
 500
 501                qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true);
 502                if (!reuse) {
 503                        kfree(intent->data);
 504                        kfree(intent);
 505                }
 506                spin_lock_irqsave(&channel->intent_lock, flags);
 507        }
 508        spin_unlock_irqrestore(&channel->intent_lock, flags);
 509}
 510
 511static void qcom_glink_rx_done(struct qcom_glink *glink,
 512                               struct glink_channel *channel,
 513                               struct glink_core_rx_intent *intent)
 514{
 515        /* We don't send RX_DONE to intentless systems */
 516        if (glink->intentless) {
 517                kfree(intent->data);
 518                kfree(intent);
 519                return;
 520        }
 521
 522        /* Take it off the tree of receive intents */
 523        if (!intent->reuse) {
 524                spin_lock(&channel->intent_lock);
 525                idr_remove(&channel->liids, intent->id);
 526                spin_unlock(&channel->intent_lock);
 527        }
 528
 529        /* Schedule the sending of a rx_done indication */
 530        spin_lock(&channel->intent_lock);
 531        list_add_tail(&intent->node, &channel->done_intents);
 532        spin_unlock(&channel->intent_lock);
 533
 534        schedule_work(&channel->intent_work);
 535}
 536
 537/**
 538 * qcom_glink_receive_version() - receive version/features from remote system
 539 *
 540 * @glink:      pointer to transport interface
 541 * @version:    remote version
 542 * @features:   remote features
 543 *
 544 * This function is called in response to a remote-initiated version/feature
 545 * negotiation sequence.
 546 */
 547static void qcom_glink_receive_version(struct qcom_glink *glink,
 548                                       u32 version,
 549                                       u32 features)
 550{
 551        switch (version) {
 552        case 0:
 553                break;
 554        case GLINK_VERSION_1:
 555                glink->features &= features;
 556                /* FALLTHROUGH */
 557        default:
 558                qcom_glink_send_version_ack(glink);
 559                break;
 560        }
 561}
 562
 563/**
 564 * qcom_glink_receive_version_ack() - receive negotiation ack from remote system
 565 *
 566 * @glink:      pointer to transport interface
 567 * @version:    remote version response
 568 * @features:   remote features response
 569 *
 570 * This function is called in response to a local-initiated version/feature
 571 * negotiation sequence and is the counter-offer from the remote side based
 572 * upon the initial version and feature set requested.
 573 */
 574static void qcom_glink_receive_version_ack(struct qcom_glink *glink,
 575                                           u32 version,
 576                                           u32 features)
 577{
 578        switch (version) {
 579        case 0:
 580                /* Version negotiation failed */
 581                break;
 582        case GLINK_VERSION_1:
 583                if (features == glink->features)
 584                        break;
 585
 586                glink->features &= features;
 587                /* FALLTHROUGH */
 588        default:
 589                qcom_glink_send_version(glink);
 590                break;
 591        }
 592}
 593
 594/**
 595 * qcom_glink_send_intent_req_ack() - convert an rx intent request ack cmd to
 596 *      wire format and transmit
 597 * @glink:      The transport to transmit on.
 598 * @channel:    The glink channel
 599 * @granted:    The request response to encode.
 600 *
 601 * Return: 0 on success or standard Linux error code.
 602 */
 603static int qcom_glink_send_intent_req_ack(struct qcom_glink *glink,
 604                                          struct glink_channel *channel,
 605                                          bool granted)
 606{
 607        struct glink_msg msg;
 608
 609        msg.cmd = cpu_to_le16(RPM_CMD_RX_INTENT_REQ_ACK);
 610        msg.param1 = cpu_to_le16(channel->lcid);
 611        msg.param2 = cpu_to_le32(granted);
 612
 613        qcom_glink_tx(glink, &msg, sizeof(msg), NULL, 0, true);
 614
 615        return 0;
 616}
 617
 618/**
 619 * qcom_glink_advertise_intent - convert an rx intent cmd to wire format and
 620 *                         transmit
 621 * @glink:      The transport to transmit on.
 622 * @channel:    The local channel
 623 * @intent:     The intent to pass on to remote.
 624 *
 625 * Return: 0 on success or standard Linux error code.
 626 */
 627static int qcom_glink_advertise_intent(struct qcom_glink *glink,
 628                                       struct glink_channel *channel,
 629                                       struct glink_core_rx_intent *intent)
 630{
 631        struct command {
 632                __le16 id;
 633                __le16 lcid;
 634                __le32 count;
 635                __le32 size;
 636                __le32 liid;
 637        } __packed;
 638        struct command cmd;
 639
 640        cmd.id = cpu_to_le16(RPM_CMD_INTENT);
 641        cmd.lcid = cpu_to_le16(channel->lcid);
 642        cmd.count = cpu_to_le32(1);
 643        cmd.size = cpu_to_le32(intent->size);
 644        cmd.liid = cpu_to_le32(intent->id);
 645
 646        qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true);
 647
 648        return 0;
 649}
 650
 651static struct glink_core_rx_intent *
 652qcom_glink_alloc_intent(struct qcom_glink *glink,
 653                        struct glink_channel *channel,
 654                        size_t size,
 655                        bool reuseable)
 656{
 657        struct glink_core_rx_intent *intent;
 658        int ret;
 659        unsigned long flags;
 660
 661        intent = kzalloc(sizeof(*intent), GFP_KERNEL);
 662        if (!intent)
 663                return NULL;
 664
 665        intent->data = kzalloc(size, GFP_KERNEL);
 666        if (!intent->data)
 667                goto free_intent;
 668
 669        spin_lock_irqsave(&channel->intent_lock, flags);
 670        ret = idr_alloc_cyclic(&channel->liids, intent, 1, -1, GFP_ATOMIC);
 671        if (ret < 0) {
 672                spin_unlock_irqrestore(&channel->intent_lock, flags);
 673                goto free_data;
 674        }
 675        spin_unlock_irqrestore(&channel->intent_lock, flags);
 676
 677        intent->id = ret;
 678        intent->size = size;
 679        intent->reuse = reuseable;
 680
 681        return intent;
 682
 683free_data:
 684        kfree(intent->data);
 685free_intent:
 686        kfree(intent);
 687        return NULL;
 688}
 689
 690static void qcom_glink_handle_rx_done(struct qcom_glink *glink,
 691                                      u32 cid, uint32_t iid,
 692                                      bool reuse)
 693{
 694        struct glink_core_rx_intent *intent;
 695        struct glink_channel *channel;
 696        unsigned long flags;
 697
 698        spin_lock_irqsave(&glink->idr_lock, flags);
 699        channel = idr_find(&glink->rcids, cid);
 700        spin_unlock_irqrestore(&glink->idr_lock, flags);
 701        if (!channel) {
 702                dev_err(glink->dev, "invalid channel id received\n");
 703                return;
 704        }
 705
 706        spin_lock_irqsave(&channel->intent_lock, flags);
 707        intent = idr_find(&channel->riids, iid);
 708
 709        if (!intent) {
 710                spin_unlock_irqrestore(&channel->intent_lock, flags);
 711                dev_err(glink->dev, "invalid intent id received\n");
 712                return;
 713        }
 714
 715        intent->in_use = false;
 716
 717        if (!reuse) {
 718                idr_remove(&channel->riids, intent->id);
 719                kfree(intent);
 720        }
 721        spin_unlock_irqrestore(&channel->intent_lock, flags);
 722}
 723
 724/**
 725 * qcom_glink_handle_intent_req() - Receive a request for rx_intent
 726 *                                          from remote side
 727 * @glink:      Pointer to the transport interface
 728 * @cid:        Remote channel ID
 729 * @size:       size of the intent
 730 *
 731 * The function searches for the local channel to which the request for
 732 * rx_intent has arrived and allocates and notifies the remote back
 733 */
 734static void qcom_glink_handle_intent_req(struct qcom_glink *glink,
 735                                         u32 cid, size_t size)
 736{
 737        struct glink_core_rx_intent *intent;
 738        struct glink_channel *channel;
 739        unsigned long flags;
 740
 741        spin_lock_irqsave(&glink->idr_lock, flags);
 742        channel = idr_find(&glink->rcids, cid);
 743        spin_unlock_irqrestore(&glink->idr_lock, flags);
 744
 745        if (!channel) {
 746                pr_err("%s channel not found for cid %d\n", __func__, cid);
 747                return;
 748        }
 749
 750        intent = qcom_glink_alloc_intent(glink, channel, size, false);
 751        if (intent)
 752                qcom_glink_advertise_intent(glink, channel, intent);
 753
 754        qcom_glink_send_intent_req_ack(glink, channel, !!intent);
 755}
 756
 757static int qcom_glink_rx_defer(struct qcom_glink *glink, size_t extra)
 758{
 759        struct glink_defer_cmd *dcmd;
 760
 761        extra = ALIGN(extra, 8);
 762
 763        if (qcom_glink_rx_avail(glink) < sizeof(struct glink_msg) + extra) {
 764                dev_dbg(glink->dev, "Insufficient data in rx fifo");
 765                return -ENXIO;
 766        }
 767
 768        dcmd = kzalloc(sizeof(*dcmd) + extra, GFP_ATOMIC);
 769        if (!dcmd)
 770                return -ENOMEM;
 771
 772        INIT_LIST_HEAD(&dcmd->node);
 773
 774        qcom_glink_rx_peak(glink, &dcmd->msg, 0, sizeof(dcmd->msg) + extra);
 775
 776        spin_lock(&glink->rx_lock);
 777        list_add_tail(&dcmd->node, &glink->rx_queue);
 778        spin_unlock(&glink->rx_lock);
 779
 780        schedule_work(&glink->rx_work);
 781        qcom_glink_rx_advance(glink, sizeof(dcmd->msg) + extra);
 782
 783        return 0;
 784}
 785
 786static int qcom_glink_rx_data(struct qcom_glink *glink, size_t avail)
 787{
 788        struct glink_core_rx_intent *intent;
 789        struct glink_channel *channel;
 790        struct {
 791                struct glink_msg msg;
 792                __le32 chunk_size;
 793                __le32 left_size;
 794        } __packed hdr;
 795        unsigned int chunk_size;
 796        unsigned int left_size;
 797        unsigned int rcid;
 798        unsigned int liid;
 799        int ret = 0;
 800        unsigned long flags;
 801
 802        if (avail < sizeof(hdr)) {
 803                dev_dbg(glink->dev, "Not enough data in fifo\n");
 804                return -EAGAIN;
 805        }
 806
 807        qcom_glink_rx_peak(glink, &hdr, 0, sizeof(hdr));
 808        chunk_size = le32_to_cpu(hdr.chunk_size);
 809        left_size = le32_to_cpu(hdr.left_size);
 810
 811        if (avail < sizeof(hdr) + chunk_size) {
 812                dev_dbg(glink->dev, "Payload not yet in fifo\n");
 813                return -EAGAIN;
 814        }
 815
 816        rcid = le16_to_cpu(hdr.msg.param1);
 817        spin_lock_irqsave(&glink->idr_lock, flags);
 818        channel = idr_find(&glink->rcids, rcid);
 819        spin_unlock_irqrestore(&glink->idr_lock, flags);
 820        if (!channel) {
 821                dev_dbg(glink->dev, "Data on non-existing channel\n");
 822
 823                /* Drop the message */
 824                goto advance_rx;
 825        }
 826
 827        if (glink->intentless) {
 828                /* Might have an ongoing, fragmented, message to append */
 829                if (!channel->buf) {
 830                        intent = kzalloc(sizeof(*intent), GFP_ATOMIC);
 831                        if (!intent)
 832                                return -ENOMEM;
 833
 834                        intent->data = kmalloc(chunk_size + left_size,
 835                                               GFP_ATOMIC);
 836                        if (!intent->data) {
 837                                kfree(intent);
 838                                return -ENOMEM;
 839                        }
 840
 841                        intent->id = 0xbabababa;
 842                        intent->size = chunk_size + left_size;
 843                        intent->offset = 0;
 844
 845                        channel->buf = intent;
 846                } else {
 847                        intent = channel->buf;
 848                }
 849        } else {
 850                liid = le32_to_cpu(hdr.msg.param2);
 851
 852                spin_lock_irqsave(&channel->intent_lock, flags);
 853                intent = idr_find(&channel->liids, liid);
 854                spin_unlock_irqrestore(&channel->intent_lock, flags);
 855
 856                if (!intent) {
 857                        dev_err(glink->dev,
 858                                "no intent found for channel %s intent %d",
 859                                channel->name, liid);
 860                        goto advance_rx;
 861                }
 862        }
 863
 864        if (intent->size - intent->offset < chunk_size) {
 865                dev_err(glink->dev, "Insufficient space in intent\n");
 866
 867                /* The packet header lied, drop payload */
 868                goto advance_rx;
 869        }
 870
 871        qcom_glink_rx_peak(glink, intent->data + intent->offset,
 872                           sizeof(hdr), chunk_size);
 873        intent->offset += chunk_size;
 874
 875        /* Handle message when no fragments remain to be received */
 876        if (!left_size) {
 877                spin_lock(&channel->recv_lock);
 878                if (channel->ept.cb) {
 879                        channel->ept.cb(channel->ept.rpdev,
 880                                        intent->data,
 881                                        intent->offset,
 882                                        channel->ept.priv,
 883                                        RPMSG_ADDR_ANY);
 884                }
 885                spin_unlock(&channel->recv_lock);
 886
 887                intent->offset = 0;
 888                channel->buf = NULL;
 889
 890                qcom_glink_rx_done(glink, channel, intent);
 891        }
 892
 893advance_rx:
 894        qcom_glink_rx_advance(glink, ALIGN(sizeof(hdr) + chunk_size, 8));
 895
 896        return ret;
 897}
 898
 899static void qcom_glink_handle_intent(struct qcom_glink *glink,
 900                                     unsigned int cid,
 901                                     unsigned int count,
 902                                     size_t avail)
 903{
 904        struct glink_core_rx_intent *intent;
 905        struct glink_channel *channel;
 906        struct intent_pair {
 907                __le32 size;
 908                __le32 iid;
 909        };
 910
 911        struct {
 912                struct glink_msg msg;
 913                struct intent_pair intents[];
 914        } __packed * msg;
 915
 916        const size_t msglen = struct_size(msg, intents, count);
 917        int ret;
 918        int i;
 919        unsigned long flags;
 920
 921        if (avail < msglen) {
 922                dev_dbg(glink->dev, "Not enough data in fifo\n");
 923                return;
 924        }
 925
 926        spin_lock_irqsave(&glink->idr_lock, flags);
 927        channel = idr_find(&glink->rcids, cid);
 928        spin_unlock_irqrestore(&glink->idr_lock, flags);
 929        if (!channel) {
 930                dev_err(glink->dev, "intents for non-existing channel\n");
 931                return;
 932        }
 933
 934        msg = kmalloc(msglen, GFP_ATOMIC);
 935        if (!msg)
 936                return;
 937
 938        qcom_glink_rx_peak(glink, msg, 0, msglen);
 939
 940        for (i = 0; i < count; ++i) {
 941                intent = kzalloc(sizeof(*intent), GFP_ATOMIC);
 942                if (!intent)
 943                        break;
 944
 945                intent->id = le32_to_cpu(msg->intents[i].iid);
 946                intent->size = le32_to_cpu(msg->intents[i].size);
 947
 948                spin_lock_irqsave(&channel->intent_lock, flags);
 949                ret = idr_alloc(&channel->riids, intent,
 950                                intent->id, intent->id + 1, GFP_ATOMIC);
 951                spin_unlock_irqrestore(&channel->intent_lock, flags);
 952
 953                if (ret < 0)
 954                        dev_err(glink->dev, "failed to store remote intent\n");
 955        }
 956
 957        kfree(msg);
 958        qcom_glink_rx_advance(glink, ALIGN(msglen, 8));
 959}
 960
 961static int qcom_glink_rx_open_ack(struct qcom_glink *glink, unsigned int lcid)
 962{
 963        struct glink_channel *channel;
 964
 965        spin_lock(&glink->idr_lock);
 966        channel = idr_find(&glink->lcids, lcid);
 967        spin_unlock(&glink->idr_lock);
 968        if (!channel) {
 969                dev_err(glink->dev, "Invalid open ack packet\n");
 970                return -EINVAL;
 971        }
 972
 973        complete(&channel->open_ack);
 974
 975        return 0;
 976}
 977
 978static irqreturn_t qcom_glink_native_intr(int irq, void *data)
 979{
 980        struct qcom_glink *glink = data;
 981        struct glink_msg msg;
 982        unsigned int param1;
 983        unsigned int param2;
 984        unsigned int avail;
 985        unsigned int cmd;
 986        int ret = 0;
 987
 988        for (;;) {
 989                avail = qcom_glink_rx_avail(glink);
 990                if (avail < sizeof(msg))
 991                        break;
 992
 993                qcom_glink_rx_peak(glink, &msg, 0, sizeof(msg));
 994
 995                cmd = le16_to_cpu(msg.cmd);
 996                param1 = le16_to_cpu(msg.param1);
 997                param2 = le32_to_cpu(msg.param2);
 998
 999                switch (cmd) {
1000                case RPM_CMD_VERSION:
1001                case RPM_CMD_VERSION_ACK:
1002                case RPM_CMD_CLOSE:
1003                case RPM_CMD_CLOSE_ACK:
1004                case RPM_CMD_RX_INTENT_REQ:
1005                        ret = qcom_glink_rx_defer(glink, 0);
1006                        break;
1007                case RPM_CMD_OPEN_ACK:
1008                        ret = qcom_glink_rx_open_ack(glink, param1);
1009                        qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8));
1010                        break;
1011                case RPM_CMD_OPEN:
1012                        ret = qcom_glink_rx_defer(glink, param2);
1013                        break;
1014                case RPM_CMD_TX_DATA:
1015                case RPM_CMD_TX_DATA_CONT:
1016                        ret = qcom_glink_rx_data(glink, avail);
1017                        break;
1018                case RPM_CMD_READ_NOTIF:
1019                        qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8));
1020
1021                        mbox_send_message(glink->mbox_chan, NULL);
1022                        mbox_client_txdone(glink->mbox_chan, 0);
1023                        break;
1024                case RPM_CMD_INTENT:
1025                        qcom_glink_handle_intent(glink, param1, param2, avail);
1026                        break;
1027                case RPM_CMD_RX_DONE:
1028                        qcom_glink_handle_rx_done(glink, param1, param2, false);
1029                        qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8));
1030                        break;
1031                case RPM_CMD_RX_DONE_W_REUSE:
1032                        qcom_glink_handle_rx_done(glink, param1, param2, true);
1033                        qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8));
1034                        break;
1035                case RPM_CMD_RX_INTENT_REQ_ACK:
1036                        qcom_glink_handle_intent_req_ack(glink, param1, param2);
1037                        qcom_glink_rx_advance(glink, ALIGN(sizeof(msg), 8));
1038                        break;
1039                default:
1040                        dev_err(glink->dev, "unhandled rx cmd: %d\n", cmd);
1041                        ret = -EINVAL;
1042                        break;
1043                }
1044
1045                if (ret)
1046                        break;
1047        }
1048
1049        return IRQ_HANDLED;
1050}
1051
1052/* Locally initiated rpmsg_create_ept */
1053static struct glink_channel *qcom_glink_create_local(struct qcom_glink *glink,
1054                                                     const char *name)
1055{
1056        struct glink_channel *channel;
1057        int ret;
1058        unsigned long flags;
1059
1060        channel = qcom_glink_alloc_channel(glink, name);
1061        if (IS_ERR(channel))
1062                return ERR_CAST(channel);
1063
1064        ret = qcom_glink_send_open_req(glink, channel);
1065        if (ret)
1066                goto release_channel;
1067
1068        ret = wait_for_completion_timeout(&channel->open_ack, 5 * HZ);
1069        if (!ret)
1070                goto err_timeout;
1071
1072        ret = wait_for_completion_timeout(&channel->open_req, 5 * HZ);
1073        if (!ret)
1074                goto err_timeout;
1075
1076        qcom_glink_send_open_ack(glink, channel);
1077
1078        return channel;
1079
1080err_timeout:
1081        /* qcom_glink_send_open_req() did register the channel in lcids*/
1082        spin_lock_irqsave(&glink->idr_lock, flags);
1083        idr_remove(&glink->lcids, channel->lcid);
1084        spin_unlock_irqrestore(&glink->idr_lock, flags);
1085
1086release_channel:
1087        /* Release qcom_glink_send_open_req() reference */
1088        kref_put(&channel->refcount, qcom_glink_channel_release);
1089        /* Release qcom_glink_alloc_channel() reference */
1090        kref_put(&channel->refcount, qcom_glink_channel_release);
1091
1092        return ERR_PTR(-ETIMEDOUT);
1093}
1094
1095/* Remote initiated rpmsg_create_ept */
1096static int qcom_glink_create_remote(struct qcom_glink *glink,
1097                                    struct glink_channel *channel)
1098{
1099        int ret;
1100
1101        qcom_glink_send_open_ack(glink, channel);
1102
1103        ret = qcom_glink_send_open_req(glink, channel);
1104        if (ret)
1105                goto close_link;
1106
1107        ret = wait_for_completion_timeout(&channel->open_ack, 5 * HZ);
1108        if (!ret) {
1109                ret = -ETIMEDOUT;
1110                goto close_link;
1111        }
1112
1113        return 0;
1114
1115close_link:
1116        /*
1117         * Send a close request to "undo" our open-ack. The close-ack will
1118         * release qcom_glink_send_open_req() reference and the last reference
1119         * will be relesed after receiving remote_close or transport unregister
1120         * by calling qcom_glink_native_remove().
1121         */
1122        qcom_glink_send_close_req(glink, channel);
1123
1124        return ret;
1125}
1126
1127static struct rpmsg_endpoint *qcom_glink_create_ept(struct rpmsg_device *rpdev,
1128                                                    rpmsg_rx_cb_t cb,
1129                                                    void *priv,
1130                                                    struct rpmsg_channel_info
1131                                                                        chinfo)
1132{
1133        struct glink_channel *parent = to_glink_channel(rpdev->ept);
1134        struct glink_channel *channel;
1135        struct qcom_glink *glink = parent->glink;
1136        struct rpmsg_endpoint *ept;
1137        const char *name = chinfo.name;
1138        int cid;
1139        int ret;
1140        unsigned long flags;
1141
1142        spin_lock_irqsave(&glink->idr_lock, flags);
1143        idr_for_each_entry(&glink->rcids, channel, cid) {
1144                if (!strcmp(channel->name, name))
1145                        break;
1146        }
1147        spin_unlock_irqrestore(&glink->idr_lock, flags);
1148
1149        if (!channel) {
1150                channel = qcom_glink_create_local(glink, name);
1151                if (IS_ERR(channel))
1152                        return NULL;
1153        } else {
1154                ret = qcom_glink_create_remote(glink, channel);
1155                if (ret)
1156                        return NULL;
1157        }
1158
1159        ept = &channel->ept;
1160        ept->rpdev = rpdev;
1161        ept->cb = cb;
1162        ept->priv = priv;
1163        ept->ops = &glink_endpoint_ops;
1164
1165        return ept;
1166}
1167
1168static int qcom_glink_announce_create(struct rpmsg_device *rpdev)
1169{
1170        struct glink_channel *channel = to_glink_channel(rpdev->ept);
1171        struct device_node *np = rpdev->dev.of_node;
1172        struct qcom_glink *glink = channel->glink;
1173        struct glink_core_rx_intent *intent;
1174        const struct property *prop = NULL;
1175        __be32 defaults[] = { cpu_to_be32(SZ_1K), cpu_to_be32(5) };
1176        int num_intents;
1177        int num_groups = 1;
1178        __be32 *val = defaults;
1179        int size;
1180
1181        if (glink->intentless)
1182                return 0;
1183
1184        prop = of_find_property(np, "qcom,intents", NULL);
1185        if (prop) {
1186                val = prop->value;
1187                num_groups = prop->length / sizeof(u32) / 2;
1188        }
1189
1190        /* Channel is now open, advertise base set of intents */
1191        while (num_groups--) {
1192                size = be32_to_cpup(val++);
1193                num_intents = be32_to_cpup(val++);
1194                while (num_intents--) {
1195                        intent = qcom_glink_alloc_intent(glink, channel, size,
1196                                                         true);
1197                        if (!intent)
1198                                break;
1199
1200                        qcom_glink_advertise_intent(glink, channel, intent);
1201                }
1202        }
1203        return 0;
1204}
1205
1206static void qcom_glink_destroy_ept(struct rpmsg_endpoint *ept)
1207{
1208        struct glink_channel *channel = to_glink_channel(ept);
1209        struct qcom_glink *glink = channel->glink;
1210        unsigned long flags;
1211
1212        spin_lock_irqsave(&channel->recv_lock, flags);
1213        channel->ept.cb = NULL;
1214        spin_unlock_irqrestore(&channel->recv_lock, flags);
1215
1216        /* Decouple the potential rpdev from the channel */
1217        channel->rpdev = NULL;
1218
1219        qcom_glink_send_close_req(glink, channel);
1220}
1221
1222static int qcom_glink_request_intent(struct qcom_glink *glink,
1223                                     struct glink_channel *channel,
1224                                     size_t size)
1225{
1226        struct {
1227                u16 id;
1228                u16 cid;
1229                u32 size;
1230        } __packed cmd;
1231
1232        int ret;
1233
1234        mutex_lock(&channel->intent_req_lock);
1235
1236        reinit_completion(&channel->intent_req_comp);
1237
1238        cmd.id = RPM_CMD_RX_INTENT_REQ;
1239        cmd.cid = channel->lcid;
1240        cmd.size = size;
1241
1242        ret = qcom_glink_tx(glink, &cmd, sizeof(cmd), NULL, 0, true);
1243        if (ret)
1244                goto unlock;
1245
1246        ret = wait_for_completion_timeout(&channel->intent_req_comp, 10 * HZ);
1247        if (!ret) {
1248                dev_err(glink->dev, "intent request timed out\n");
1249                ret = -ETIMEDOUT;
1250        } else {
1251                ret = channel->intent_req_result ? 0 : -ECANCELED;
1252        }
1253
1254unlock:
1255        mutex_unlock(&channel->intent_req_lock);
1256        return ret;
1257}
1258
1259static int __qcom_glink_send(struct glink_channel *channel,
1260                             void *data, int len, bool wait)
1261{
1262        struct qcom_glink *glink = channel->glink;
1263        struct glink_core_rx_intent *intent = NULL;
1264        struct glink_core_rx_intent *tmp;
1265        int iid = 0;
1266        struct {
1267                struct glink_msg msg;
1268                __le32 chunk_size;
1269                __le32 left_size;
1270        } __packed req;
1271        int ret;
1272        unsigned long flags;
1273
1274        if (!glink->intentless) {
1275                while (!intent) {
1276                        spin_lock_irqsave(&channel->intent_lock, flags);
1277                        idr_for_each_entry(&channel->riids, tmp, iid) {
1278                                if (tmp->size >= len && !tmp->in_use) {
1279                                        if (!intent)
1280                                                intent = tmp;
1281                                        else if (intent->size > tmp->size)
1282                                                intent = tmp;
1283                                        if (intent->size == len)
1284                                                break;
1285                                }
1286                        }
1287                        if (intent)
1288                                intent->in_use = true;
1289                        spin_unlock_irqrestore(&channel->intent_lock, flags);
1290
1291                        /* We found an available intent */
1292                        if (intent)
1293                                break;
1294
1295                        if (!wait)
1296                                return -EBUSY;
1297
1298                        ret = qcom_glink_request_intent(glink, channel, len);
1299                        if (ret < 0)
1300                                return ret;
1301                }
1302
1303                iid = intent->id;
1304        }
1305
1306        req.msg.cmd = cpu_to_le16(RPM_CMD_TX_DATA);
1307        req.msg.param1 = cpu_to_le16(channel->lcid);
1308        req.msg.param2 = cpu_to_le32(iid);
1309        req.chunk_size = cpu_to_le32(len);
1310        req.left_size = cpu_to_le32(0);
1311
1312        ret = qcom_glink_tx(glink, &req, sizeof(req), data, len, wait);
1313
1314        /* Mark intent available if we failed */
1315        if (ret && intent)
1316                intent->in_use = false;
1317
1318        return ret;
1319}
1320
1321static int qcom_glink_send(struct rpmsg_endpoint *ept, void *data, int len)
1322{
1323        struct glink_channel *channel = to_glink_channel(ept);
1324
1325        return __qcom_glink_send(channel, data, len, true);
1326}
1327
1328static int qcom_glink_trysend(struct rpmsg_endpoint *ept, void *data, int len)
1329{
1330        struct glink_channel *channel = to_glink_channel(ept);
1331
1332        return __qcom_glink_send(channel, data, len, false);
1333}
1334
1335/*
1336 * Finds the device_node for the glink child interested in this channel.
1337 */
1338static struct device_node *qcom_glink_match_channel(struct device_node *node,
1339                                                    const char *channel)
1340{
1341        struct device_node *child;
1342        const char *name;
1343        const char *key;
1344        int ret;
1345
1346        for_each_available_child_of_node(node, child) {
1347                key = "qcom,glink-channels";
1348                ret = of_property_read_string(child, key, &name);
1349                if (ret)
1350                        continue;
1351
1352                if (strcmp(name, channel) == 0)
1353                        return child;
1354        }
1355
1356        return NULL;
1357}
1358
1359static const struct rpmsg_device_ops glink_device_ops = {
1360        .create_ept = qcom_glink_create_ept,
1361        .announce_create = qcom_glink_announce_create,
1362};
1363
1364static const struct rpmsg_endpoint_ops glink_endpoint_ops = {
1365        .destroy_ept = qcom_glink_destroy_ept,
1366        .send = qcom_glink_send,
1367        .trysend = qcom_glink_trysend,
1368};
1369
1370static void qcom_glink_rpdev_release(struct device *dev)
1371{
1372        struct rpmsg_device *rpdev = to_rpmsg_device(dev);
1373        struct glink_channel *channel = to_glink_channel(rpdev->ept);
1374
1375        channel->rpdev = NULL;
1376        kfree(rpdev);
1377}
1378
1379static int qcom_glink_rx_open(struct qcom_glink *glink, unsigned int rcid,
1380                              char *name)
1381{
1382        struct glink_channel *channel;
1383        struct rpmsg_device *rpdev;
1384        bool create_device = false;
1385        struct device_node *node;
1386        int lcid;
1387        int ret;
1388        unsigned long flags;
1389
1390        spin_lock_irqsave(&glink->idr_lock, flags);
1391        idr_for_each_entry(&glink->lcids, channel, lcid) {
1392                if (!strcmp(channel->name, name))
1393                        break;
1394        }
1395        spin_unlock_irqrestore(&glink->idr_lock, flags);
1396
1397        if (!channel) {
1398                channel = qcom_glink_alloc_channel(glink, name);
1399                if (IS_ERR(channel))
1400                        return PTR_ERR(channel);
1401
1402                /* The opening dance was initiated by the remote */
1403                create_device = true;
1404        }
1405
1406        spin_lock_irqsave(&glink->idr_lock, flags);
1407        ret = idr_alloc(&glink->rcids, channel, rcid, rcid + 1, GFP_ATOMIC);
1408        if (ret < 0) {
1409                dev_err(glink->dev, "Unable to insert channel into rcid list\n");
1410                spin_unlock_irqrestore(&glink->idr_lock, flags);
1411                goto free_channel;
1412        }
1413        channel->rcid = ret;
1414        spin_unlock_irqrestore(&glink->idr_lock, flags);
1415
1416        complete(&channel->open_req);
1417
1418        if (create_device) {
1419                rpdev = kzalloc(sizeof(*rpdev), GFP_KERNEL);
1420                if (!rpdev) {
1421                        ret = -ENOMEM;
1422                        goto rcid_remove;
1423                }
1424
1425                rpdev->ept = &channel->ept;
1426                strncpy(rpdev->id.name, name, RPMSG_NAME_SIZE);
1427                rpdev->src = RPMSG_ADDR_ANY;
1428                rpdev->dst = RPMSG_ADDR_ANY;
1429                rpdev->ops = &glink_device_ops;
1430
1431                node = qcom_glink_match_channel(glink->dev->of_node, name);
1432                rpdev->dev.of_node = node;
1433                rpdev->dev.parent = glink->dev;
1434                rpdev->dev.release = qcom_glink_rpdev_release;
1435
1436                ret = rpmsg_register_device(rpdev);
1437                if (ret)
1438                        goto rcid_remove;
1439
1440                channel->rpdev = rpdev;
1441        }
1442
1443        return 0;
1444
1445rcid_remove:
1446        spin_lock_irqsave(&glink->idr_lock, flags);
1447        idr_remove(&glink->rcids, channel->rcid);
1448        channel->rcid = 0;
1449        spin_unlock_irqrestore(&glink->idr_lock, flags);
1450free_channel:
1451        /* Release the reference, iff we took it */
1452        if (create_device)
1453                kref_put(&channel->refcount, qcom_glink_channel_release);
1454
1455        return ret;
1456}
1457
1458static void qcom_glink_rx_close(struct qcom_glink *glink, unsigned int rcid)
1459{
1460        struct rpmsg_channel_info chinfo;
1461        struct glink_channel *channel;
1462        unsigned long flags;
1463
1464        spin_lock_irqsave(&glink->idr_lock, flags);
1465        channel = idr_find(&glink->rcids, rcid);
1466        spin_unlock_irqrestore(&glink->idr_lock, flags);
1467        if (WARN(!channel, "close request on unknown channel\n"))
1468                return;
1469
1470        /* cancel pending rx_done work */
1471        cancel_work_sync(&channel->intent_work);
1472
1473        if (channel->rpdev) {
1474                strncpy(chinfo.name, channel->name, sizeof(chinfo.name));
1475                chinfo.src = RPMSG_ADDR_ANY;
1476                chinfo.dst = RPMSG_ADDR_ANY;
1477
1478                rpmsg_unregister_device(glink->dev, &chinfo);
1479        }
1480
1481        qcom_glink_send_close_ack(glink, channel->rcid);
1482
1483        spin_lock_irqsave(&glink->idr_lock, flags);
1484        idr_remove(&glink->rcids, channel->rcid);
1485        channel->rcid = 0;
1486        spin_unlock_irqrestore(&glink->idr_lock, flags);
1487
1488        kref_put(&channel->refcount, qcom_glink_channel_release);
1489}
1490
1491static void qcom_glink_rx_close_ack(struct qcom_glink *glink, unsigned int lcid)
1492{
1493        struct glink_channel *channel;
1494        unsigned long flags;
1495
1496        spin_lock_irqsave(&glink->idr_lock, flags);
1497        channel = idr_find(&glink->lcids, lcid);
1498        if (WARN(!channel, "close ack on unknown channel\n")) {
1499                spin_unlock_irqrestore(&glink->idr_lock, flags);
1500                return;
1501        }
1502
1503        idr_remove(&glink->lcids, channel->lcid);
1504        channel->lcid = 0;
1505        spin_unlock_irqrestore(&glink->idr_lock, flags);
1506
1507        kref_put(&channel->refcount, qcom_glink_channel_release);
1508}
1509
1510static void qcom_glink_work(struct work_struct *work)
1511{
1512        struct qcom_glink *glink = container_of(work, struct qcom_glink,
1513                                                rx_work);
1514        struct glink_defer_cmd *dcmd;
1515        struct glink_msg *msg;
1516        unsigned long flags;
1517        unsigned int param1;
1518        unsigned int param2;
1519        unsigned int cmd;
1520
1521        for (;;) {
1522                spin_lock_irqsave(&glink->rx_lock, flags);
1523                if (list_empty(&glink->rx_queue)) {
1524                        spin_unlock_irqrestore(&glink->rx_lock, flags);
1525                        break;
1526                }
1527                dcmd = list_first_entry(&glink->rx_queue,
1528                                        struct glink_defer_cmd, node);
1529                list_del(&dcmd->node);
1530                spin_unlock_irqrestore(&glink->rx_lock, flags);
1531
1532                msg = &dcmd->msg;
1533                cmd = le16_to_cpu(msg->cmd);
1534                param1 = le16_to_cpu(msg->param1);
1535                param2 = le32_to_cpu(msg->param2);
1536
1537                switch (cmd) {
1538                case RPM_CMD_VERSION:
1539                        qcom_glink_receive_version(glink, param1, param2);
1540                        break;
1541                case RPM_CMD_VERSION_ACK:
1542                        qcom_glink_receive_version_ack(glink, param1, param2);
1543                        break;
1544                case RPM_CMD_OPEN:
1545                        qcom_glink_rx_open(glink, param1, msg->data);
1546                        break;
1547                case RPM_CMD_CLOSE:
1548                        qcom_glink_rx_close(glink, param1);
1549                        break;
1550                case RPM_CMD_CLOSE_ACK:
1551                        qcom_glink_rx_close_ack(glink, param1);
1552                        break;
1553                case RPM_CMD_RX_INTENT_REQ:
1554                        qcom_glink_handle_intent_req(glink, param1, param2);
1555                        break;
1556                default:
1557                        WARN(1, "Unknown defer object %d\n", cmd);
1558                        break;
1559                }
1560
1561                kfree(dcmd);
1562        }
1563}
1564
1565static void qcom_glink_cancel_rx_work(struct qcom_glink *glink)
1566{
1567        struct glink_defer_cmd *dcmd;
1568        struct glink_defer_cmd *tmp;
1569
1570        /* cancel any pending deferred rx_work */
1571        cancel_work_sync(&glink->rx_work);
1572
1573        list_for_each_entry_safe(dcmd, tmp, &glink->rx_queue, node)
1574                kfree(dcmd);
1575}
1576
1577struct qcom_glink *qcom_glink_native_probe(struct device *dev,
1578                                           unsigned long features,
1579                                           struct qcom_glink_pipe *rx,
1580                                           struct qcom_glink_pipe *tx,
1581                                           bool intentless)
1582{
1583        int irq;
1584        int ret;
1585        struct qcom_glink *glink;
1586
1587        glink = devm_kzalloc(dev, sizeof(*glink), GFP_KERNEL);
1588        if (!glink)
1589                return ERR_PTR(-ENOMEM);
1590
1591        glink->dev = dev;
1592        glink->tx_pipe = tx;
1593        glink->rx_pipe = rx;
1594
1595        glink->features = features;
1596        glink->intentless = intentless;
1597
1598        spin_lock_init(&glink->tx_lock);
1599        spin_lock_init(&glink->rx_lock);
1600        INIT_LIST_HEAD(&glink->rx_queue);
1601        INIT_WORK(&glink->rx_work, qcom_glink_work);
1602
1603        spin_lock_init(&glink->idr_lock);
1604        idr_init(&glink->lcids);
1605        idr_init(&glink->rcids);
1606
1607        ret = of_property_read_string(dev->of_node, "label", &glink->name);
1608        if (ret < 0)
1609                glink->name = dev->of_node->name;
1610
1611        glink->mbox_client.dev = dev;
1612        glink->mbox_client.knows_txdone = true;
1613        glink->mbox_chan = mbox_request_channel(&glink->mbox_client, 0);
1614        if (IS_ERR(glink->mbox_chan)) {
1615                if (PTR_ERR(glink->mbox_chan) != -EPROBE_DEFER)
1616                        dev_err(dev, "failed to acquire IPC channel\n");
1617                return ERR_CAST(glink->mbox_chan);
1618        }
1619
1620        irq = of_irq_get(dev->of_node, 0);
1621        ret = devm_request_irq(dev, irq,
1622                               qcom_glink_native_intr,
1623                               IRQF_NO_SUSPEND | IRQF_SHARED,
1624                               "glink-native", glink);
1625        if (ret) {
1626                dev_err(dev, "failed to request IRQ\n");
1627                return ERR_PTR(ret);
1628        }
1629
1630        glink->irq = irq;
1631
1632        ret = qcom_glink_send_version(glink);
1633        if (ret)
1634                return ERR_PTR(ret);
1635
1636        return glink;
1637}
1638EXPORT_SYMBOL_GPL(qcom_glink_native_probe);
1639
1640static int qcom_glink_remove_device(struct device *dev, void *data)
1641{
1642        device_unregister(dev);
1643
1644        return 0;
1645}
1646
1647void qcom_glink_native_remove(struct qcom_glink *glink)
1648{
1649        struct glink_channel *channel;
1650        int cid;
1651        int ret;
1652
1653        disable_irq(glink->irq);
1654        qcom_glink_cancel_rx_work(glink);
1655
1656        ret = device_for_each_child(glink->dev, NULL, qcom_glink_remove_device);
1657        if (ret)
1658                dev_warn(glink->dev, "Can't remove GLINK devices: %d\n", ret);
1659
1660        /* Release any defunct local channels, waiting for close-ack */
1661        idr_for_each_entry(&glink->lcids, channel, cid)
1662                kref_put(&channel->refcount, qcom_glink_channel_release);
1663
1664        /* Release any defunct local channels, waiting for close-req */
1665        idr_for_each_entry(&glink->rcids, channel, cid)
1666                kref_put(&channel->refcount, qcom_glink_channel_release);
1667
1668        idr_destroy(&glink->lcids);
1669        idr_destroy(&glink->rcids);
1670        mbox_free_channel(glink->mbox_chan);
1671}
1672EXPORT_SYMBOL_GPL(qcom_glink_native_remove);
1673
1674void qcom_glink_native_unregister(struct qcom_glink *glink)
1675{
1676        device_unregister(glink->dev);
1677}
1678EXPORT_SYMBOL_GPL(qcom_glink_native_unregister);
1679
1680MODULE_DESCRIPTION("Qualcomm GLINK driver");
1681MODULE_LICENSE("GPL v2");
1682