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