drivers/rpmsg/qcom_smd.c

   1 /*
   2  * Copyright (c) 2015, Sony Mobile Communications AB.
   3  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 and
   7  * only version 2 as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/io.h>
  17 #include <linux/mfd/syscon.h>
  18 #include <linux/module.h>
  19 #include <linux/of_irq.h>
  20 #include <linux/of_platform.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regmap.h>
  23 #include <linux/sched.h>
  24 #include <linux/slab.h>
  25 #include <linux/soc/qcom/smem.h>
  26 #include <linux/wait.h>
  27 #include <linux/rpmsg.h>
  28 #include <linux/rpmsg/qcom_smd.h>
  29
  30 #include "rpmsg_internal.h"
  31
  32 /*
  33  * The Qualcomm Shared Memory communication solution provides point-to-point
  34  * channels for clients to send and receive streaming or packet based data.
  35  *
  36  * Each channel consists of a control item (channel info) and a ring buffer
  37  * pair. The channel info carry information related to channel state, flow
  38  * control and the offsets within the ring buffer.
  39  *
  40  * All allocated channels are listed in an allocation table, identifying the
  41  * pair of items by name, type and remote processor.
  42  *
  43  * Upon creating a new channel the remote processor allocates channel info and
  44  * ring buffer items from the smem heap and populate the allocation table. An
  45  * interrupt is sent to the other end of the channel and a scan for new
  46  * channels should be done. A channel never goes away, it will only change
  47  * state.
  48  *
  49  * The remote processor signals it intent for bring up the communication
  50  * channel by setting the state of its end of the channel to "opening" and
  51  * sends out an interrupt. We detect this change and register a smd device to
  52  * consume the channel. Upon finding a consumer we finish the handshake and the
  53  * channel is up.
  54  *
  55  * Upon closing a channel, the remote processor will update the state of its
  56  * end of the channel and signal us, we will then unregister any attached
  57  * device and close our end of the channel.
  58  *
  59  * Devices attached to a channel can use the qcom_smd_send function to push
  60  * data to the channel, this is done by copying the data into the tx ring
  61  * buffer, updating the pointers in the channel info and signaling the remote
  62  * processor.
  63  *
  64  * The remote processor does the equivalent when it transfer data and upon
  65  * receiving the interrupt we check the channel info for new data and delivers
  66  * this to the attached device. If the device is not ready to receive the data
  67  * we leave it in the ring buffer for now.
  68  */
  69
  70 struct smd_channel_info;
  71 struct smd_channel_info_pair;
  72 struct smd_channel_info_word;
  73 struct smd_channel_info_word_pair;
  74
  75 static const struct rpmsg_endpoint_ops qcom_smd_endpoint_ops;
  76
  77 #define SMD_ALLOC_TBL_COUNT     2
  78 #define SMD_ALLOC_TBL_SIZE      64
  79
  80 /*
  81  * This lists the various smem heap items relevant for the allocation table and
  82  * smd channel entries.
  83  */
  84 static const struct {
  85         unsigned alloc_tbl_id;
  86         unsigned info_base_id;
  87         unsigned fifo_base_id;
  88 } smem_items[SMD_ALLOC_TBL_COUNT] = {
  89         {
  90                 .alloc_tbl_id = 13,
  91                 .info_base_id = 14,
  92                 .fifo_base_id = 338
  93         },
  94         {
  95                 .alloc_tbl_id = 266,
  96                 .info_base_id = 138,
  97                 .fifo_base_id = 202,
  98         },
  99 };
 100
 101 /**
 102  * struct qcom_smd_edge - representing a remote processor
 103  * @of_node:            of_node handle for information related to this edge
 104  * @edge_id:            identifier of this edge
 105  * @remote_pid:         identifier of remote processor
 106  * @irq:                interrupt for signals on this edge
 107  * @ipc_regmap:         regmap handle holding the outgoing ipc register
 108  * @ipc_offset:         offset within @ipc_regmap of the register for ipc
 109  * @ipc_bit:            bit in the register at @ipc_offset of @ipc_regmap
 110  * @channels:           list of all channels detected on this edge
 111  * @channels_lock:      guard for modifications of @channels
 112  * @allocated:          array of bitmaps representing already allocated channels
 113  * @smem_available:     last available amount of smem triggering a channel scan
 114  * @scan_work:          work item for discovering new channels
 115  * @state_work:         work item for edge state changes
 116  */
 117 struct qcom_smd_edge {
 118         struct device dev;
 119
 120         struct device_node *of_node;
 121         unsigned edge_id;
 122         unsigned remote_pid;
 123
 124         int irq;
 125
 126         struct regmap *ipc_regmap;
 127         int ipc_offset;
 128         int ipc_bit;
 129
 130         struct list_head channels;
 131         spinlock_t channels_lock;
 132
 133         DECLARE_BITMAP(allocated[SMD_ALLOC_TBL_COUNT], SMD_ALLOC_TBL_SIZE);
 134
 135         unsigned smem_available;
 136
 137         wait_queue_head_t new_channel_event;
 138
 139         struct work_struct scan_work;
 140         struct work_struct state_work;
 141 };
 142
 143 /*
 144  * SMD channel states.
 145  */
 146 enum smd_channel_state {
 147         SMD_CHANNEL_CLOSED,
 148         SMD_CHANNEL_OPENING,
 149         SMD_CHANNEL_OPENED,
 150         SMD_CHANNEL_FLUSHING,
 151         SMD_CHANNEL_CLOSING,
 152         SMD_CHANNEL_RESET,
 153         SMD_CHANNEL_RESET_OPENING
 154 };
 155
 156 struct qcom_smd_device {
 157         struct rpmsg_device rpdev;
 158
 159         struct qcom_smd_edge *edge;
 160 };
 161
 162 struct qcom_smd_endpoint {
 163         struct rpmsg_endpoint ept;
 164
 165         struct qcom_smd_channel *qsch;
 166 };
 167
 168 #define to_smd_device(_rpdev)   container_of(_rpdev, struct qcom_smd_device, rpdev)
 169 #define to_smd_edge(d)          container_of(d, struct qcom_smd_edge, dev)
 170 #define to_smd_endpoint(ept)    container_of(ept, struct qcom_smd_endpoint, ept)
 171
 172 /**
 173  * struct qcom_smd_channel - smd channel struct
 174  * @edge:               qcom_smd_edge this channel is living on
 175  * @qsdev:              reference to a associated smd client device
 176  * @name:               name of the channel
 177  * @state:              local state of the channel
 178  * @remote_state:       remote state of the channel
 179  * @info:               byte aligned outgoing/incoming channel info
 180  * @info_word:          word aligned outgoing/incoming channel info
 181  * @tx_lock:            lock to make writes to the channel mutually exclusive
 182  * @fblockread_event:   wakeup event tied to tx fBLOCKREADINTR
 183  * @tx_fifo:            pointer to the outgoing ring buffer
 184  * @rx_fifo:            pointer to the incoming ring buffer
 185  * @fifo_size:          size of each ring buffer
 186  * @bounce_buffer:      bounce buffer for reading wrapped packets
 187  * @cb:                 callback function registered for this channel
 188  * @recv_lock:          guard for rx info modifications and cb pointer
 189  * @pkt_size:           size of the currently handled packet
 190  * @list:               lite entry for @channels in qcom_smd_edge
 191  */
 192 struct qcom_smd_channel {
 193         struct qcom_smd_edge *edge;
 194
 195         struct qcom_smd_endpoint *qsept;
 196         bool registered;
 197
 198         char *name;
 199         enum smd_channel_state state;
 200         enum smd_channel_state remote_state;
 201
 202         struct smd_channel_info_pair *info;
 203         struct smd_channel_info_word_pair *info_word;
 204
 205         struct mutex tx_lock;
 206         wait_queue_head_t fblockread_event;
 207
 208         void *tx_fifo;
 209         void *rx_fifo;
 210         int fifo_size;
 211
 212         void *bounce_buffer;
 213
 214         spinlock_t recv_lock;
 215
 216         int pkt_size;
 217
 218         void *drvdata;
 219
 220         struct list_head list;
 221 };
 222
 223 /*
 224  * Format of the smd_info smem items, for byte aligned channels.
 225  */
 226 struct smd_channel_info {
 227         __le32 state;
 228         u8  fDSR;
 229         u8  fCTS;
 230         u8  fCD;
 231         u8  fRI;
 232         u8  fHEAD;
 233         u8  fTAIL;
 234         u8  fSTATE;
 235         u8  fBLOCKREADINTR;
 236         __le32 tail;
 237         __le32 head;
 238 };
 239
 240 struct smd_channel_info_pair {
 241         struct smd_channel_info tx;
 242         struct smd_channel_info rx;
 243 };
 244
 245 /*
 246  * Format of the smd_info smem items, for word aligned channels.
 247  */
 248 struct smd_channel_info_word {
 249         __le32 state;
 250         __le32 fDSR;
 251         __le32 fCTS;
 252         __le32 fCD;
 253         __le32 fRI;
 254         __le32 fHEAD;
 255         __le32 fTAIL;
 256         __le32 fSTATE;
 257         __le32 fBLOCKREADINTR;
 258         __le32 tail;
 259         __le32 head;
 260 };
 261
 262 struct smd_channel_info_word_pair {
 263         struct smd_channel_info_word tx;
 264         struct smd_channel_info_word rx;
 265 };
 266
 267 #define GET_RX_CHANNEL_FLAG(channel, param)                                  \
 268         ({                                                                   \
 269                 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
 270                 channel->info_word ?                                         \
 271                         le32_to_cpu(channel->info_word->rx.param) :          \
 272                         channel->info->rx.param;                             \
 273         })
 274
 275 #define GET_RX_CHANNEL_INFO(channel, param)                                   \
 276         ({                                                                    \
 277                 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
 278                 le32_to_cpu(channel->info_word ?                              \
 279                         channel->info_word->rx.param :                        \
 280                         channel->info->rx.param);                             \
 281         })
 282
 283 #define SET_RX_CHANNEL_FLAG(channel, param, value)                           \
 284         ({                                                                   \
 285                 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
 286                 if (channel->info_word)                                      \
 287                         channel->info_word->rx.param = cpu_to_le32(value);   \
 288                 else                                                         \
 289                         channel->info->rx.param = value;                     \
 290         })
 291
 292 #define SET_RX_CHANNEL_INFO(channel, param, value)                            \
 293         ({                                                                    \
 294                 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
 295                 if (channel->info_word)                                       \
 296                         channel->info_word->rx.param = cpu_to_le32(value);    \
 297                 else                                                          \
 298                         channel->info->rx.param = cpu_to_le32(value);         \
 299         })
 300
 301 #define GET_TX_CHANNEL_FLAG(channel, param)                                  \
 302         ({                                                                   \
 303                 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
 304                 channel->info_word ?                                         \
 305                         le32_to_cpu(channel->info_word->tx.param) :          \
 306                         channel->info->tx.param;                             \
 307         })
 308
 309 #define GET_TX_CHANNEL_INFO(channel, param)                                   \
 310         ({                                                                    \
 311                 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
 312                 le32_to_cpu(channel->info_word ?                              \
 313                         channel->info_word->tx.param :                        \
 314                         channel->info->tx.param);                             \
 315         })
 316
 317 #define SET_TX_CHANNEL_FLAG(channel, param, value)                           \
 318         ({                                                                   \
 319                 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
 320                 if (channel->info_word)                                      \
 321                         channel->info_word->tx.param = cpu_to_le32(value);   \
 322                 else                                                         \
 323                         channel->info->tx.param = value;                     \
 324         })
 325
 326 #define SET_TX_CHANNEL_INFO(channel, param, value)                            \
 327         ({                                                                    \
 328                 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
 329                 if (channel->info_word)                                       \
 330                         channel->info_word->tx.param = cpu_to_le32(value);   \
 331                 else                                                          \
 332                         channel->info->tx.param = cpu_to_le32(value);         \
 333         })
 334
 335 /**
 336  * struct qcom_smd_alloc_entry - channel allocation entry
 337  * @name:       channel name
 338  * @cid:        channel index
 339  * @flags:      channel flags and edge id
 340  * @ref_count:  reference count of the channel
 341  */
 342 struct qcom_smd_alloc_entry {
 343         u8 name[20];
 344         __le32 cid;
 345         __le32 flags;
 346         __le32 ref_count;
 347 } __packed;
 348
 349 #define SMD_CHANNEL_FLAGS_EDGE_MASK     0xff
 350 #define SMD_CHANNEL_FLAGS_STREAM        BIT(8)
 351 #define SMD_CHANNEL_FLAGS_PACKET        BIT(9)
 352
 353 /*
 354  * Each smd packet contains a 20 byte header, with the first 4 being the length
 355  * of the packet.
 356  */
 357 #define SMD_PACKET_HEADER_LEN   20
 358
 359 /*
 360  * Signal the remote processor associated with 'channel'.
 361  */
 362 static void qcom_smd_signal_channel(struct qcom_smd_channel *channel)
 363 {
 364         struct qcom_smd_edge *edge = channel->edge;
 365
 366         regmap_write(edge->ipc_regmap, edge->ipc_offset, BIT(edge->ipc_bit));
 367 }
 368
 369 /*
 370  * Initialize the tx channel info
 371  */
 372 static void qcom_smd_channel_reset(struct qcom_smd_channel *channel)
 373 {
 374         SET_TX_CHANNEL_INFO(channel, state, SMD_CHANNEL_CLOSED);
 375         SET_TX_CHANNEL_FLAG(channel, fDSR, 0);
 376         SET_TX_CHANNEL_FLAG(channel, fCTS, 0);
 377         SET_TX_CHANNEL_FLAG(channel, fCD, 0);
 378         SET_TX_CHANNEL_FLAG(channel, fRI, 0);
 379         SET_TX_CHANNEL_FLAG(channel, fHEAD, 0);
 380         SET_TX_CHANNEL_FLAG(channel, fTAIL, 0);
 381         SET_TX_CHANNEL_FLAG(channel, fSTATE, 1);
 382         SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 1);
 383         SET_TX_CHANNEL_INFO(channel, head, 0);
 384         SET_RX_CHANNEL_INFO(channel, tail, 0);
 385
 386         qcom_smd_signal_channel(channel);
 387
 388         channel->state = SMD_CHANNEL_CLOSED;
 389         channel->pkt_size = 0;
 390 }
 391
 392 /*
 393  * Set the callback for a channel, with appropriate locking
 394  */
 395 static void qcom_smd_channel_set_callback(struct qcom_smd_channel *channel,
 396                                           rpmsg_rx_cb_t cb)
 397 {
 398         struct rpmsg_endpoint *ept = &channel->qsept->ept;
 399         unsigned long flags;
 400
 401         spin_lock_irqsave(&channel->recv_lock, flags);
 402         ept->cb = cb;
 403         spin_unlock_irqrestore(&channel->recv_lock, flags);
 404 };
 405
 406 /*
 407  * Calculate the amount of data available in the rx fifo
 408  */
 409 static size_t qcom_smd_channel_get_rx_avail(struct qcom_smd_channel *channel)
 410 {
 411         unsigned head;
 412         unsigned tail;
 413
 414         head = GET_RX_CHANNEL_INFO(channel, head);
 415         tail = GET_RX_CHANNEL_INFO(channel, tail);
 416
 417         return (head - tail) & (channel->fifo_size - 1);
 418 }
 419
 420 /*
 421  * Set tx channel state and inform the remote processor
 422  */
 423 static void qcom_smd_channel_set_state(struct qcom_smd_channel *channel,
 424                                        int state)
 425 {
 426         struct qcom_smd_edge *edge = channel->edge;
 427         bool is_open = state == SMD_CHANNEL_OPENED;
 428
 429         if (channel->state == state)
 430                 return;
 431
 432         dev_dbg(&edge->dev, "set_state(%s, %d)\n", channel->name, state);
 433
 434         SET_TX_CHANNEL_FLAG(channel, fDSR, is_open);
 435         SET_TX_CHANNEL_FLAG(channel, fCTS, is_open);
 436         SET_TX_CHANNEL_FLAG(channel, fCD, is_open);
 437
 438         SET_TX_CHANNEL_INFO(channel, state, state);
 439         SET_TX_CHANNEL_FLAG(channel, fSTATE, 1);
 440
 441         channel->state = state;
 442         qcom_smd_signal_channel(channel);
 443 }
 444
 445 /*
 446  * Copy count bytes of data using 32bit accesses, if that's required.
 447  */
 448 static void smd_copy_to_fifo(void __iomem *dst,
 449                              const void *src,
 450                              size_t count,
 451                              bool word_aligned)
 452 {
 453         if (word_aligned) {
 454                 __iowrite32_copy(dst, src, count / sizeof(u32));
 455         } else {
 456                 memcpy_toio(dst, src, count);
 457         }
 458 }
 459
 460 /*
 461  * Copy count bytes of data using 32bit accesses, if that is required.
 462  */
 463 static void smd_copy_from_fifo(void *dst,
 464                                const void __iomem *src,
 465                                size_t count,
 466                                bool word_aligned)
 467 {
 468         if (word_aligned) {
 469                 __ioread32_copy(dst, src, count / sizeof(u32));
 470         } else {
 471                 memcpy_fromio(dst, src, count);
 472         }
 473 }
 474
 475 /*
 476  * Read count bytes of data from the rx fifo into buf, but don't advance the
 477  * tail.
 478  */
 479 static size_t qcom_smd_channel_peek(struct qcom_smd_channel *channel,
 480                                     void *buf, size_t count)
 481 {
 482         bool word_aligned;
 483         unsigned tail;
 484         size_t len;
 485
 486         word_aligned = channel->info_word;
 487         tail = GET_RX_CHANNEL_INFO(channel, tail);
 488
 489         len = min_t(size_t, count, channel->fifo_size - tail);
 490         if (len) {
 491                 smd_copy_from_fifo(buf,
 492                                    channel->rx_fifo + tail,
 493                                    len,
 494                                    word_aligned);
 495         }
 496
 497         if (len != count) {
 498                 smd_copy_from_fifo(buf + len,
 499                                    channel->rx_fifo,
 500                                    count - len,
 501                                    word_aligned);
 502         }
 503
 504         return count;
 505 }
 506
 507 /*
 508  * Advance the rx tail by count bytes.
 509  */
 510 static void qcom_smd_channel_advance(struct qcom_smd_channel *channel,
 511                                      size_t count)
 512 {
 513         unsigned tail;
 514
 515         tail = GET_RX_CHANNEL_INFO(channel, tail);
 516         tail += count;
 517         tail &= (channel->fifo_size - 1);
 518         SET_RX_CHANNEL_INFO(channel, tail, tail);
 519 }
 520
 521 /*
 522  * Read out a single packet from the rx fifo and deliver it to the device
 523  */
 524 static int qcom_smd_channel_recv_single(struct qcom_smd_channel *channel)
 525 {
 526         struct rpmsg_endpoint *ept = &channel->qsept->ept;
 527         unsigned tail;
 528         size_t len;
 529         void *ptr;
 530         int ret;
 531
 532         tail = GET_RX_CHANNEL_INFO(channel, tail);
 533
 534         /* Use bounce buffer if the data wraps */
 535         if (tail + channel->pkt_size >= channel->fifo_size) {
 536                 ptr = channel->bounce_buffer;
 537                 len = qcom_smd_channel_peek(channel, ptr, channel->pkt_size);
 538         } else {
 539                 ptr = channel->rx_fifo + tail;
 540                 len = channel->pkt_size;
 541         }
 542
 543         ret = ept->cb(ept->rpdev, ptr, len, ept->priv, RPMSG_ADDR_ANY);
 544         if (ret < 0)
 545                 return ret;
 546
 547         /* Only forward the tail if the client consumed the data */
 548         qcom_smd_channel_advance(channel, len);
 549
 550         channel->pkt_size = 0;
 551
 552         return 0;
 553 }
 554
 555 /*
 556  * Per channel interrupt handling
 557  */
 558 static bool qcom_smd_channel_intr(struct qcom_smd_channel *channel)
 559 {
 560         bool need_state_scan = false;
 561         int remote_state;
 562         __le32 pktlen;
 563         int avail;
 564         int ret;
 565
 566         /* Handle state changes */
 567         remote_state = GET_RX_CHANNEL_INFO(channel, state);
 568         if (remote_state != channel->remote_state) {
 569                 channel->remote_state = remote_state;
 570                 need_state_scan = true;
 571         }
 572         /* Indicate that we have seen any state change */
 573         SET_RX_CHANNEL_FLAG(channel, fSTATE, 0);
 574
 575         /* Signal waiting qcom_smd_send() about the interrupt */
 576         if (!GET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR))
 577                 wake_up_interruptible(&channel->fblockread_event);
 578
 579         /* Don't consume any data until we've opened the channel */
 580         if (channel->state != SMD_CHANNEL_OPENED)
 581                 goto out;
 582
 583         /* Indicate that we've seen the new data */
 584         SET_RX_CHANNEL_FLAG(channel, fHEAD, 0);
 585
 586         /* Consume data */
 587         for (;;) {
 588                 avail = qcom_smd_channel_get_rx_avail(channel);
 589
 590                 if (!channel->pkt_size && avail >= SMD_PACKET_HEADER_LEN) {
 591                         qcom_smd_channel_peek(channel, &pktlen, sizeof(pktlen));
 592                         qcom_smd_channel_advance(channel, SMD_PACKET_HEADER_LEN);
 593                         channel->pkt_size = le32_to_cpu(pktlen);
 594                 } else if (channel->pkt_size && avail >= channel->pkt_size) {
 595                         ret = qcom_smd_channel_recv_single(channel);
 596                         if (ret)
 597                                 break;
 598                 } else {
 599                         break;
 600                 }
 601         }
 602
 603         /* Indicate that we have seen and updated tail */
 604         SET_RX_CHANNEL_FLAG(channel, fTAIL, 1);
 605
 606         /* Signal the remote that we've consumed the data (if requested) */
 607         if (!GET_RX_CHANNEL_FLAG(channel, fBLOCKREADINTR)) {
 608                 /* Ensure ordering of channel info updates */
 609                 wmb();
 610
 611                 qcom_smd_signal_channel(channel);
 612         }
 613
 614 out:
 615         return need_state_scan;
 616 }
 617
 618 /*
 619  * The edge interrupts are triggered by the remote processor on state changes,
 620  * channel info updates or when new channels are created.
 621  */
 622 static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
 623 {
 624         struct qcom_smd_edge *edge = data;
 625         struct qcom_smd_channel *channel;
 626         unsigned available;
 627         bool kick_scanner = false;
 628         bool kick_state = false;
 629
 630         /*
 631          * Handle state changes or data on each of the channels on this edge
 632          */
 633         spin_lock(&edge->channels_lock);
 634         list_for_each_entry(channel, &edge->channels, list) {
 635                 spin_lock(&channel->recv_lock);
 636                 kick_state |= qcom_smd_channel_intr(channel);
 637                 spin_unlock(&channel->recv_lock);
 638         }
 639         spin_unlock(&edge->channels_lock);
 640
 641         /*
 642          * Creating a new channel requires allocating an smem entry, so we only
 643          * have to scan if the amount of available space in smem have changed
 644          * since last scan.
 645          */
 646         available = qcom_smem_get_free_space(edge->remote_pid);
 647         if (available != edge->smem_available) {
 648                 edge->smem_available = available;
 649                 kick_scanner = true;
 650         }
 651
 652         if (kick_scanner)
 653                 schedule_work(&edge->scan_work);
 654         if (kick_state)
 655                 schedule_work(&edge->state_work);
 656
 657         return IRQ_HANDLED;
 658 }
 659
 660 /*
 661  * Calculate how much space is available in the tx fifo.
 662  */
 663 static size_t qcom_smd_get_tx_avail(struct qcom_smd_channel *channel)
 664 {
 665         unsigned head;
 666         unsigned tail;
 667         unsigned mask = channel->fifo_size - 1;
 668
 669         head = GET_TX_CHANNEL_INFO(channel, head);
 670         tail = GET_TX_CHANNEL_INFO(channel, tail);
 671
 672         return mask - ((head - tail) & mask);
 673 }
 674
 675 /*
 676  * Write count bytes of data into channel, possibly wrapping in the ring buffer
 677  */
 678 static int qcom_smd_write_fifo(struct qcom_smd_channel *channel,
 679                                const void *data,
 680                                size_t count)
 681 {
 682         bool word_aligned;
 683         unsigned head;
 684         size_t len;
 685
 686         word_aligned = channel->info_word;
 687         head = GET_TX_CHANNEL_INFO(channel, head);
 688
 689         len = min_t(size_t, count, channel->fifo_size - head);
 690         if (len) {
 691                 smd_copy_to_fifo(channel->tx_fifo + head,
 692                                  data,
 693                                  len,
 694                                  word_aligned);
 695         }
 696
 697         if (len != count) {
 698                 smd_copy_to_fifo(channel->tx_fifo,
 699                                  data + len,
 700                                  count - len,
 701                                  word_aligned);
 702         }
 703
 704         head += count;
 705         head &= (channel->fifo_size - 1);
 706         SET_TX_CHANNEL_INFO(channel, head, head);
 707
 708         return count;
 709 }
 710
 711 /**
 712  * qcom_smd_send - write data to smd channel
 713  * @channel:    channel handle
 714  * @data:       buffer of data to write
 715  * @len:        number of bytes to write
 716  *
 717  * This is a blocking write of len bytes into the channel's tx ring buffer and
 718  * signal the remote end. It will sleep until there is enough space available
 719  * in the tx buffer, utilizing the fBLOCKREADINTR signaling mechanism to avoid
 720  * polling.
 721  */
 722 static int __qcom_smd_send(struct qcom_smd_channel *channel, const void *data,
 723                            int len, bool wait)
 724 {
 725         __le32 hdr[5] = { cpu_to_le32(len), };
 726         int tlen = sizeof(hdr) + len;
 727         int ret;
 728
 729         /* Word aligned channels only accept word size aligned data */
 730         if (channel->info_word && len % 4)
 731                 return -EINVAL;
 732
 733         /* Reject packets that are too big */
 734         if (tlen >= channel->fifo_size)
 735                 return -EINVAL;
 736
 737         ret = mutex_lock_interruptible(&channel->tx_lock);
 738         if (ret)
 739                 return ret;
 740
 741         while (qcom_smd_get_tx_avail(channel) < tlen) {
 742                 if (!wait) {
 743                         ret = -EAGAIN;
 744                         goto out;
 745                 }
 746
 747                 if (channel->state != SMD_CHANNEL_OPENED) {
 748                         ret = -EPIPE;
 749                         goto out;
 750                 }
 751
 752                 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 0);
 753
 754                 ret = wait_event_interruptible(channel->fblockread_event,
 755                                        qcom_smd_get_tx_avail(channel) >= tlen ||
 756                                        channel->state != SMD_CHANNEL_OPENED);
 757                 if (ret)
 758                         goto out;
 759
 760                 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 1);
 761         }
 762
 763         SET_TX_CHANNEL_FLAG(channel, fTAIL, 0);
 764
 765         qcom_smd_write_fifo(channel, hdr, sizeof(hdr));
 766         qcom_smd_write_fifo(channel, data, len);
 767
 768         SET_TX_CHANNEL_FLAG(channel, fHEAD, 1);
 769
 770         /* Ensure ordering of channel info updates */
 771         wmb();
 772
 773         qcom_smd_signal_channel(channel);
 774
 775 out:
 776         mutex_unlock(&channel->tx_lock);
 777
 778         return ret;
 779 }
 780
 781 /*
 782  * Helper for opening a channel
 783  */
 784 static int qcom_smd_channel_open(struct qcom_smd_channel *channel,
 785                                  rpmsg_rx_cb_t cb)
 786 {
 787         size_t bb_size;
 788
 789         /*
 790          * Packets are maximum 4k, but reduce if the fifo is smaller
 791          */
 792         bb_size = min(channel->fifo_size, SZ_4K);
 793         channel->bounce_buffer = kmalloc(bb_size, GFP_KERNEL);
 794         if (!channel->bounce_buffer)
 795                 return -ENOMEM;
 796
 797         qcom_smd_channel_set_callback(channel, cb);
 798         qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENING);
 799         qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENED);
 800
 801         return 0;
 802 }
 803
 804 /*
 805  * Helper for closing and resetting a channel
 806  */
 807 static void qcom_smd_channel_close(struct qcom_smd_channel *channel)
 808 {
 809         qcom_smd_channel_set_callback(channel, NULL);
 810
 811         kfree(channel->bounce_buffer);
 812         channel->bounce_buffer = NULL;
 813
 814         qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);
 815         qcom_smd_channel_reset(channel);
 816 }
 817
 818 static struct qcom_smd_channel *
 819 qcom_smd_find_channel(struct qcom_smd_edge *edge, const char *name)
 820 {
 821         struct qcom_smd_channel *channel;
 822         struct qcom_smd_channel *ret = NULL;
 823         unsigned long flags;
 824
 825         spin_lock_irqsave(&edge->channels_lock, flags);
 826         list_for_each_entry(channel, &edge->channels, list) {
 827                 if (!strcmp(channel->name, name)) {
 828                         ret = channel;
 829                         break;
 830                 }
 831         }
 832         spin_unlock_irqrestore(&edge->channels_lock, flags);
 833
 834         return ret;
 835 }
 836
 837 static void __ept_release(struct kref *kref)
 838 {
 839         struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint,
 840                                                   refcount);
 841         kfree(to_smd_endpoint(ept));
 842 }
 843
 844 static struct rpmsg_endpoint *qcom_smd_create_ept(struct rpmsg_device *rpdev,
 845                                                   rpmsg_rx_cb_t cb, void *priv,
 846                                                   struct rpmsg_channel_info chinfo)
 847 {
 848         struct qcom_smd_endpoint *qsept;
 849         struct qcom_smd_channel *channel;
 850         struct qcom_smd_device *qsdev = to_smd_device(rpdev);
 851         struct qcom_smd_edge *edge = qsdev->edge;
 852         struct rpmsg_endpoint *ept;
 853         const char *name = chinfo.name;
 854         int ret;
 855
 856         /* Wait up to HZ for the channel to appear */
 857         ret = wait_event_interruptible_timeout(edge->new_channel_event,
 858                         (channel = qcom_smd_find_channel(edge, name)) != NULL,
 859                         HZ);
 860         if (!ret)
 861                 return NULL;
 862
 863         if (channel->state != SMD_CHANNEL_CLOSED) {
 864                 dev_err(&rpdev->dev, "channel %s is busy\n", channel->name);
 865                 return NULL;
 866         }
 867
 868         qsept = kzalloc(sizeof(*qsept), GFP_KERNEL);
 869         if (!qsept)
 870                 return NULL;
 871
 872         ept = &qsept->ept;
 873
 874         kref_init(&ept->refcount);
 875
 876         ept->rpdev = rpdev;
 877         ept->cb = cb;
 878         ept->priv = priv;
 879         ept->ops = &qcom_smd_endpoint_ops;
 880
 881         channel->qsept = qsept;
 882         qsept->qsch = channel;
 883
 884         ret = qcom_smd_channel_open(channel, cb);
 885         if (ret)
 886                 goto free_ept;
 887
 888         return ept;
 889
 890 free_ept:
 891         channel->qsept = NULL;
 892         kref_put(&ept->refcount, __ept_release);
 893         return NULL;
 894 }
 895
 896 static void qcom_smd_destroy_ept(struct rpmsg_endpoint *ept)
 897 {
 898         struct qcom_smd_endpoint *qsept = to_smd_endpoint(ept);
 899         struct qcom_smd_channel *ch = qsept->qsch;
 900
 901         qcom_smd_channel_close(ch);
 902         ch->qsept = NULL;
 903         kref_put(&ept->refcount, __ept_release);
 904 }
 905
 906 static int qcom_smd_send(struct rpmsg_endpoint *ept, void *data, int len)
 907 {
 908         struct qcom_smd_endpoint *qsept = to_smd_endpoint(ept);
 909
 910         return __qcom_smd_send(qsept->qsch, data, len, true);
 911 }
 912
 913 static int qcom_smd_trysend(struct rpmsg_endpoint *ept, void *data, int len)
 914 {
 915         struct qcom_smd_endpoint *qsept = to_smd_endpoint(ept);
 916
 917         return __qcom_smd_send(qsept->qsch, data, len, false);
 918 }
 919
 920 /*
 921  * Finds the device_node for the smd child interested in this channel.
 922  */
 923 static struct device_node *qcom_smd_match_channel(struct device_node *edge_node,
 924                                                   const char *channel)
 925 {
 926         struct device_node *child;
 927         const char *name;
 928         const char *key;
 929         int ret;
 930
 931         for_each_available_child_of_node(edge_node, child) {
 932                 key = "qcom,smd-channels";
 933                 ret = of_property_read_string(child, key, &name);
 934                 if (ret)
 935                         continue;
 936
 937                 if (strcmp(name, channel) == 0)
 938                         return child;
 939         }
 940
 941         return NULL;
 942 }
 943
 944 static const struct rpmsg_device_ops qcom_smd_device_ops = {
 945         .create_ept = qcom_smd_create_ept,
 946 };
 947
 948 static const struct rpmsg_endpoint_ops qcom_smd_endpoint_ops = {
 949         .destroy_ept = qcom_smd_destroy_ept,
 950         .send = qcom_smd_send,
 951         .trysend = qcom_smd_trysend,
 952 };
 953
 954 /*
 955  * Create a smd client device for channel that is being opened.
 956  */
 957 static int qcom_smd_create_device(struct qcom_smd_channel *channel)
 958 {
 959         struct qcom_smd_device *qsdev;
 960         struct rpmsg_device *rpdev;
 961         struct qcom_smd_edge *edge = channel->edge;
 962
 963         dev_dbg(&edge->dev, "registering '%s'\n", channel->name);
 964
 965         qsdev = kzalloc(sizeof(*qsdev), GFP_KERNEL);
 966         if (!qsdev)
 967                 return -ENOMEM;
 968
 969         /* Link qsdev to our SMD edge */
 970         qsdev->edge = edge;
 971
 972         /* Assign callbacks for rpmsg_device */
 973         qsdev->rpdev.ops = &qcom_smd_device_ops;
 974
 975         /* Assign public information to the rpmsg_device */
 976         rpdev = &qsdev->rpdev;
 977         strncpy(rpdev->id.name, channel->name, RPMSG_NAME_SIZE);
 978         rpdev->src = RPMSG_ADDR_ANY;
 979         rpdev->dst = RPMSG_ADDR_ANY;
 980
 981         rpdev->dev.of_node = qcom_smd_match_channel(edge->of_node, channel->name);
 982         rpdev->dev.parent = &edge->dev;
 983
 984         return rpmsg_register_device(rpdev);
 985 }
 986
 987 /*
 988  * Allocate the qcom_smd_channel object for a newly found smd channel,
 989  * retrieving and validating the smem items involved.
 990  */
 991 static struct qcom_smd_channel *qcom_smd_create_channel(struct qcom_smd_edge *edge,
 992                                                         unsigned smem_info_item,
 993                                                         unsigned smem_fifo_item,
 994                                                         char *name)
 995 {
 996         struct qcom_smd_channel *channel;
 997         size_t fifo_size;
 998         size_t info_size;
 999         void *fifo_base;
1000         void *info;
1001         int ret;
1002
1003         channel = devm_kzalloc(&edge->dev, sizeof(*channel), GFP_KERNEL);
1004         if (!channel)
1005                 return ERR_PTR(-ENOMEM);
1006
1007         channel->edge = edge;
1008         channel->name = devm_kstrdup(&edge->dev, name, GFP_KERNEL);
1009         if (!channel->name)
1010                 return ERR_PTR(-ENOMEM);
1011
1012         mutex_init(&channel->tx_lock);
1013         spin_lock_init(&channel->recv_lock);
1014         init_waitqueue_head(&channel->fblockread_event);
1015
1016         info = qcom_smem_get(edge->remote_pid, smem_info_item, &info_size);
1017         if (IS_ERR(info)) {
1018                 ret = PTR_ERR(info);
1019                 goto free_name_and_channel;
1020         }
1021
1022         /*
1023          * Use the size of the item to figure out which channel info struct to
1024          * use.
1025          */
1026         if (info_size == 2 * sizeof(struct smd_channel_info_word)) {
1027                 channel->info_word = info;
1028         } else if (info_size == 2 * sizeof(struct smd_channel_info)) {
1029                 channel->info = info;
1030         } else {
1031                 dev_err(&edge->dev,
1032                         "channel info of size %zu not supported\n", info_size);
1033                 ret = -EINVAL;
1034                 goto free_name_and_channel;
1035         }
1036
1037         fifo_base = qcom_smem_get(edge->remote_pid, smem_fifo_item, &fifo_size);
1038         if (IS_ERR(fifo_base)) {
1039                 ret =  PTR_ERR(fifo_base);
1040                 goto free_name_and_channel;
1041         }
1042
1043         /* The channel consist of a rx and tx fifo of equal size */
1044         fifo_size /= 2;
1045
1046         dev_dbg(&edge->dev, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1047                           name, info_size, fifo_size);
1048
1049         channel->tx_fifo = fifo_base;
1050         channel->rx_fifo = fifo_base + fifo_size;
1051         channel->fifo_size = fifo_size;
1052
1053         qcom_smd_channel_reset(channel);
1054
1055         return channel;
1056
1057 free_name_and_channel:
1058         devm_kfree(&edge->dev, channel->name);
1059         devm_kfree(&edge->dev, channel);
1060
1061         return ERR_PTR(ret);
1062 }
1063
1064 /*
1065  * Scans the allocation table for any newly allocated channels, calls
1066  * qcom_smd_create_channel() to create representations of these and add
1067  * them to the edge's list of channels.
1068  */
1069 static void qcom_channel_scan_worker(struct work_struct *work)
1070 {
1071         struct qcom_smd_edge *edge = container_of(work, struct qcom_smd_edge, scan_work);
1072         struct qcom_smd_alloc_entry *alloc_tbl;
1073         struct qcom_smd_alloc_entry *entry;
1074         struct qcom_smd_channel *channel;
1075         unsigned long flags;
1076         unsigned fifo_id;
1077         unsigned info_id;
1078         int tbl;
1079         int i;
1080         u32 eflags, cid;
1081
1082         for (tbl = 0; tbl < SMD_ALLOC_TBL_COUNT; tbl++) {
1083                 alloc_tbl = qcom_smem_get(edge->remote_pid,
1084                                     smem_items[tbl].alloc_tbl_id, NULL);
1085                 if (IS_ERR(alloc_tbl))
1086                         continue;
1087
1088                 for (i = 0; i < SMD_ALLOC_TBL_SIZE; i++) {
1089                         entry = &alloc_tbl[i];
1090                         eflags = le32_to_cpu(entry->flags);
1091                         if (test_bit(i, edge->allocated[tbl]))
1092                                 continue;
1093
1094                         if (entry->ref_count == 0)
1095                                 continue;
1096
1097                         if (!entry->name[0])
1098                                 continue;
1099
1100                         if (!(eflags & SMD_CHANNEL_FLAGS_PACKET))
1101                                 continue;
1102
1103                         if ((eflags & SMD_CHANNEL_FLAGS_EDGE_MASK) != edge->edge_id)
1104                                 continue;
1105
1106                         cid = le32_to_cpu(entry->cid);
1107                         info_id = smem_items[tbl].info_base_id + cid;
1108                         fifo_id = smem_items[tbl].fifo_base_id + cid;
1109
1110                         channel = qcom_smd_create_channel(edge, info_id, fifo_id, entry->name);
1111                         if (IS_ERR(channel))
1112                                 continue;
1113
1114                         spin_lock_irqsave(&edge->channels_lock, flags);
1115                         list_add(&channel->list, &edge->channels);
1116                         spin_unlock_irqrestore(&edge->channels_lock, flags);
1117
1118                         dev_dbg(&edge->dev, "new channel found: '%s'\n", channel->name);
1119                         set_bit(i, edge->allocated[tbl]);
1120
1121                         wake_up_interruptible(&edge->new_channel_event);
1122                 }
1123         }
1124
1125         schedule_work(&edge->state_work);
1126 }
1127
1128 /*
1129  * This per edge worker scans smem for any new channels and register these. It
1130  * then scans all registered channels for state changes that should be handled
1131  * by creating or destroying smd client devices for the registered channels.
1132  *
1133  * LOCKING: edge->channels_lock only needs to cover the list operations, as the
1134  * worker is killed before any channels are deallocated
1135  */
1136 static void qcom_channel_state_worker(struct work_struct *work)
1137 {
1138         struct qcom_smd_channel *channel;
1139         struct qcom_smd_edge *edge = container_of(work,
1140                                                   struct qcom_smd_edge,
1141                                                   state_work);
1142         struct rpmsg_channel_info chinfo;
1143         unsigned remote_state;
1144         unsigned long flags;
1145
1146         /*
1147          * Register a device for any closed channel where the remote processor
1148          * is showing interest in opening the channel.
1149          */
1150         spin_lock_irqsave(&edge->channels_lock, flags);
1151         list_for_each_entry(channel, &edge->channels, list) {
1152                 if (channel->state != SMD_CHANNEL_CLOSED)
1153                         continue;
1154
1155                 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1156                 if (remote_state != SMD_CHANNEL_OPENING &&
1157                     remote_state != SMD_CHANNEL_OPENED)
1158                         continue;
1159
1160                 if (channel->registered)
1161                         continue;
1162
1163                 spin_unlock_irqrestore(&edge->channels_lock, flags);
1164                 qcom_smd_create_device(channel);
1165                 channel->registered = true;
1166                 spin_lock_irqsave(&edge->channels_lock, flags);
1167
1168                 channel->registered = true;
1169         }
1170
1171         /*
1172          * Unregister the device for any channel that is opened where the
1173          * remote processor is closing the channel.
1174          */
1175         list_for_each_entry(channel, &edge->channels, list) {
1176                 if (channel->state != SMD_CHANNEL_OPENING &&
1177                     channel->state != SMD_CHANNEL_OPENED)
1178                         continue;
1179
1180                 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1181                 if (remote_state == SMD_CHANNEL_OPENING ||
1182                     remote_state == SMD_CHANNEL_OPENED)
1183                         continue;
1184
1185                 spin_unlock_irqrestore(&edge->channels_lock, flags);
1186
1187                 strncpy(chinfo.name, channel->name, sizeof(chinfo.name));
1188                 chinfo.src = RPMSG_ADDR_ANY;
1189                 chinfo.dst = RPMSG_ADDR_ANY;
1190                 rpmsg_unregister_device(&edge->dev, &chinfo);
1191                 channel->registered = false;
1192                 spin_lock_irqsave(&edge->channels_lock, flags);
1193         }
1194         spin_unlock_irqrestore(&edge->channels_lock, flags);
1195 }
1196
1197 /*
1198  * Parses an of_node describing an edge.
1199  */
1200 static int qcom_smd_parse_edge(struct device *dev,
1201                                struct device_node *node,
1202                                struct qcom_smd_edge *edge)
1203 {
1204         struct device_node *syscon_np;
1205         const char *key;
1206         int irq;
1207         int ret;
1208
1209         INIT_LIST_HEAD(&edge->channels);
1210         spin_lock_init(&edge->channels_lock);
1211
1212         INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
1213         INIT_WORK(&edge->state_work, qcom_channel_state_worker);
1214
1215         edge->of_node = of_node_get(node);
1216
1217         key = "qcom,smd-edge";
1218         ret = of_property_read_u32(node, key, &edge->edge_id);
1219         if (ret) {
1220                 dev_err(dev, "edge missing %s property\n", key);
1221                 return -EINVAL;
1222         }
1223
1224         edge->remote_pid = QCOM_SMEM_HOST_ANY;
1225         key = "qcom,remote-pid";
1226         of_property_read_u32(node, key, &edge->remote_pid);
1227
1228         syscon_np = of_parse_phandle(node, "qcom,ipc", 0);
1229         if (!syscon_np) {
1230                 dev_err(dev, "no qcom,ipc node\n");
1231                 return -ENODEV;
1232         }
1233
1234         edge->ipc_regmap = syscon_node_to_regmap(syscon_np);
1235         if (IS_ERR(edge->ipc_regmap))
1236                 return PTR_ERR(edge->ipc_regmap);
1237
1238         key = "qcom,ipc";
1239         ret = of_property_read_u32_index(node, key, 1, &edge->ipc_offset);
1240         if (ret < 0) {
1241                 dev_err(dev, "no offset in %s\n", key);
1242                 return -EINVAL;
1243         }
1244
1245         ret = of_property_read_u32_index(node, key, 2, &edge->ipc_bit);
1246         if (ret < 0) {
1247                 dev_err(dev, "no bit in %s\n", key);
1248                 return -EINVAL;
1249         }
1250
1251         irq = irq_of_parse_and_map(node, 0);
1252         if (irq < 0) {
1253                 dev_err(dev, "required smd interrupt missing\n");
1254                 return -EINVAL;
1255         }
1256
1257         ret = devm_request_irq(dev, irq,
1258                                qcom_smd_edge_intr, IRQF_TRIGGER_RISING,
1259                                node->name, edge);
1260         if (ret) {
1261                 dev_err(dev, "failed to request smd irq\n");
1262                 return ret;
1263         }
1264
1265         edge->irq = irq;
1266
1267         return 0;
1268 }
1269
1270 /*
1271  * Release function for an edge.
1272   * Reset the state of each associated channel and free the edge context.
1273  */
1274 static void qcom_smd_edge_release(struct device *dev)
1275 {
1276         struct qcom_smd_channel *channel;
1277         struct qcom_smd_edge *edge = to_smd_edge(dev);
1278
1279         list_for_each_entry(channel, &edge->channels, list) {
1280                 SET_RX_CHANNEL_INFO(channel, state, SMD_CHANNEL_CLOSED);
1281                 SET_RX_CHANNEL_INFO(channel, head, 0);
1282                 SET_RX_CHANNEL_INFO(channel, tail, 0);
1283         }
1284
1285         kfree(edge);
1286 }
1287
1288 /**
1289  * qcom_smd_register_edge() - register an edge based on an device_node
1290  * @parent:    parent device for the edge
1291  * @node:      device_node describing the edge
1292  *
1293  * Returns an edge reference, or negative ERR_PTR() on failure.
1294  */
1295 struct qcom_smd_edge *qcom_smd_register_edge(struct device *parent,
1296                                              struct device_node *node)
1297 {
1298         struct qcom_smd_edge *edge;
1299         int ret;
1300
1301         edge = kzalloc(sizeof(*edge), GFP_KERNEL);
1302         if (!edge)
1303                 return ERR_PTR(-ENOMEM);
1304
1305         init_waitqueue_head(&edge->new_channel_event);
1306
1307         edge->dev.parent = parent;
1308         edge->dev.release = qcom_smd_edge_release;
1309         dev_set_name(&edge->dev, "%s:%s", dev_name(parent), node->name);
1310         ret = device_register(&edge->dev);
1311         if (ret) {
1312                 pr_err("failed to register smd edge\n");
1313                 return ERR_PTR(ret);
1314         }
1315
1316         ret = qcom_smd_parse_edge(&edge->dev, node, edge);
1317         if (ret) {
1318                 dev_err(&edge->dev, "failed to parse smd edge\n");
1319                 goto unregister_dev;
1320         }
1321
1322         schedule_work(&edge->scan_work);
1323
1324         return edge;
1325
1326 unregister_dev:
1327         put_device(&edge->dev);
1328         return ERR_PTR(ret);
1329 }
1330 EXPORT_SYMBOL(qcom_smd_register_edge);
1331
1332 static int qcom_smd_remove_device(struct device *dev, void *data)
1333 {
1334         device_unregister(dev);
1335
1336         return 0;
1337 }
1338
1339 /**
1340  * qcom_smd_unregister_edge() - release an edge and its children
1341  * @edge:      edge reference acquired from qcom_smd_register_edge
1342  */
1343 int qcom_smd_unregister_edge(struct qcom_smd_edge *edge)
1344 {
1345         int ret;
1346
1347         disable_irq(edge->irq);
1348         cancel_work_sync(&edge->scan_work);
1349         cancel_work_sync(&edge->state_work);
1350
1351         ret = device_for_each_child(&edge->dev, NULL, qcom_smd_remove_device);
1352         if (ret)
1353                 dev_warn(&edge->dev, "can't remove smd device: %d\n", ret);
1354
1355         device_unregister(&edge->dev);
1356
1357         return 0;
1358 }
1359 EXPORT_SYMBOL(qcom_smd_unregister_edge);
1360
1361 static int qcom_smd_probe(struct platform_device *pdev)
1362 {
1363         struct device_node *node;
1364         void *p;
1365
1366         /* Wait for smem */
1367         p = qcom_smem_get(QCOM_SMEM_HOST_ANY, smem_items[0].alloc_tbl_id, NULL);
1368         if (PTR_ERR(p) == -EPROBE_DEFER)
1369                 return PTR_ERR(p);
1370
1371         for_each_available_child_of_node(pdev->dev.of_node, node)
1372                 qcom_smd_register_edge(&pdev->dev, node);
1373
1374         return 0;
1375 }
1376
1377 static int qcom_smd_remove_edge(struct device *dev, void *data)
1378 {
1379         struct qcom_smd_edge *edge = to_smd_edge(dev);
1380
1381         return qcom_smd_unregister_edge(edge);
1382 }
1383
1384 /*
1385  * Shut down all smd clients by making sure that each edge stops processing
1386  * events and scanning for new channels, then call destroy on the devices.
1387  */
1388 static int qcom_smd_remove(struct platform_device *pdev)
1389 {
1390         int ret;
1391
1392         ret = device_for_each_child(&pdev->dev, NULL, qcom_smd_remove_edge);
1393         if (ret)
1394                 dev_warn(&pdev->dev, "can't remove smd device: %d\n", ret);
1395
1396         return ret;
1397 }
1398
1399 static const struct of_device_id qcom_smd_of_match[] = {
1400         { .compatible = "qcom,smd" },
1401         {}
1402 };
1403 MODULE_DEVICE_TABLE(of, qcom_smd_of_match);
1404
1405 static struct platform_driver qcom_smd_driver = {
1406         .probe = qcom_smd_probe,
1407         .remove = qcom_smd_remove,
1408         .driver = {
1409                 .name = "qcom-smd",
1410                 .of_match_table = qcom_smd_of_match,
1411         },
1412 };
1413
1414 static int __init qcom_smd_init(void)
1415 {
1416         return platform_driver_register(&qcom_smd_driver);
1417 }
1418 subsys_initcall(qcom_smd_init);
1419
1420 static void __exit qcom_smd_exit(void)
1421 {
1422         platform_driver_unregister(&qcom_smd_driver);
1423 }
1424 module_exit(qcom_smd_exit);
1425
1426 MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
1427 MODULE_DESCRIPTION("Qualcomm Shared Memory Driver");
1428 MODULE_LICENSE("GPL v2");