2 * Copyright (c) 2015, Sony Mobile Communications AB.
3 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
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.
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.
15 #include <linux/interrupt.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/smd.h>
26 #include <linux/soc/qcom/smem.h>
27 #include <linux/wait.h>
30 * The Qualcomm Shared Memory communication solution provides point-to-point
31 * channels for clients to send and receive streaming or packet based data.
33 * Each channel consists of a control item (channel info) and a ring buffer
34 * pair. The channel info carry information related to channel state, flow
35 * control and the offsets within the ring buffer.
37 * All allocated channels are listed in an allocation table, identifying the
38 * pair of items by name, type and remote processor.
40 * Upon creating a new channel the remote processor allocates channel info and
41 * ring buffer items from the smem heap and populate the allocation table. An
42 * interrupt is sent to the other end of the channel and a scan for new
43 * channels should be done. A channel never goes away, it will only change
46 * The remote processor signals it intent for bring up the communication
47 * channel by setting the state of its end of the channel to "opening" and
48 * sends out an interrupt. We detect this change and register a smd device to
49 * consume the channel. Upon finding a consumer we finish the handshake and the
52 * Upon closing a channel, the remote processor will update the state of its
53 * end of the channel and signal us, we will then unregister any attached
54 * device and close our end of the channel.
56 * Devices attached to a channel can use the qcom_smd_send function to push
57 * data to the channel, this is done by copying the data into the tx ring
58 * buffer, updating the pointers in the channel info and signaling the remote
61 * The remote processor does the equivalent when it transfer data and upon
62 * receiving the interrupt we check the channel info for new data and delivers
63 * this to the attached device. If the device is not ready to receive the data
64 * we leave it in the ring buffer for now.
67 struct smd_channel_info
;
68 struct smd_channel_info_pair
;
69 struct smd_channel_info_word
;
70 struct smd_channel_info_word_pair
;
72 #define SMD_ALLOC_TBL_COUNT 2
73 #define SMD_ALLOC_TBL_SIZE 64
76 * This lists the various smem heap items relevant for the allocation table and
77 * smd channel entries.
80 unsigned alloc_tbl_id
;
81 unsigned info_base_id
;
82 unsigned fifo_base_id
;
83 } smem_items
[SMD_ALLOC_TBL_COUNT
] = {
97 * struct qcom_smd_edge - representing a remote processor
98 * @smd: handle to qcom_smd
99 * @of_node: of_node handle for information related to this edge
100 * @edge_id: identifier of this edge
101 * @remote_pid: identifier of remote processor
102 * @irq: interrupt for signals on this edge
103 * @ipc_regmap: regmap handle holding the outgoing ipc register
104 * @ipc_offset: offset within @ipc_regmap of the register for ipc
105 * @ipc_bit: bit in the register at @ipc_offset of @ipc_regmap
106 * @channels: list of all channels detected on this edge
107 * @channels_lock: guard for modifications of @channels
108 * @allocated: array of bitmaps representing already allocated channels
109 * @smem_available: last available amount of smem triggering a channel scan
110 * @scan_work: work item for discovering new channels
111 * @state_work: work item for edge state changes
113 struct qcom_smd_edge
{
114 struct qcom_smd
*smd
;
115 struct device_node
*of_node
;
121 struct regmap
*ipc_regmap
;
125 struct list_head channels
;
126 spinlock_t channels_lock
;
128 DECLARE_BITMAP(allocated
[SMD_ALLOC_TBL_COUNT
], SMD_ALLOC_TBL_SIZE
);
130 unsigned smem_available
;
132 wait_queue_head_t new_channel_event
;
134 struct work_struct scan_work
;
135 struct work_struct state_work
;
139 * SMD channel states.
141 enum smd_channel_state
{
145 SMD_CHANNEL_FLUSHING
,
148 SMD_CHANNEL_RESET_OPENING
152 * struct qcom_smd_channel - smd channel struct
153 * @edge: qcom_smd_edge this channel is living on
154 * @qsdev: reference to a associated smd client device
155 * @name: name of the channel
156 * @state: local state of the channel
157 * @remote_state: remote state of the channel
158 * @info: byte aligned outgoing/incoming channel info
159 * @info_word: word aligned outgoing/incoming channel info
160 * @tx_lock: lock to make writes to the channel mutually exclusive
161 * @fblockread_event: wakeup event tied to tx fBLOCKREADINTR
162 * @tx_fifo: pointer to the outgoing ring buffer
163 * @rx_fifo: pointer to the incoming ring buffer
164 * @fifo_size: size of each ring buffer
165 * @bounce_buffer: bounce buffer for reading wrapped packets
166 * @cb: callback function registered for this channel
167 * @recv_lock: guard for rx info modifications and cb pointer
168 * @pkt_size: size of the currently handled packet
169 * @list: lite entry for @channels in qcom_smd_edge
171 struct qcom_smd_channel
{
172 struct qcom_smd_edge
*edge
;
174 struct qcom_smd_device
*qsdev
;
177 enum smd_channel_state state
;
178 enum smd_channel_state remote_state
;
180 struct smd_channel_info_pair
*info
;
181 struct smd_channel_info_word_pair
*info_word
;
183 struct mutex tx_lock
;
184 wait_queue_head_t fblockread_event
;
193 spinlock_t recv_lock
;
199 struct list_head list
;
200 struct list_head dev_list
;
204 * struct qcom_smd - smd struct
205 * @dev: device struct
206 * @num_edges: number of entries in @edges
207 * @edges: array of edges to be handled
213 struct qcom_smd_edge edges
[0];
217 * Format of the smd_info smem items, for byte aligned channels.
219 struct smd_channel_info
{
233 struct smd_channel_info_pair
{
234 struct smd_channel_info tx
;
235 struct smd_channel_info rx
;
239 * Format of the smd_info smem items, for word aligned channels.
241 struct smd_channel_info_word
{
250 __le32 fBLOCKREADINTR
;
255 struct smd_channel_info_word_pair
{
256 struct smd_channel_info_word tx
;
257 struct smd_channel_info_word rx
;
260 #define GET_RX_CHANNEL_FLAG(channel, param) \
262 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
263 channel->info_word ? \
264 le32_to_cpu(channel->info_word->rx.param) : \
265 channel->info->rx.param; \
268 #define GET_RX_CHANNEL_INFO(channel, param) \
270 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
271 le32_to_cpu(channel->info_word ? \
272 channel->info_word->rx.param : \
273 channel->info->rx.param); \
276 #define SET_RX_CHANNEL_FLAG(channel, param, value) \
278 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
279 if (channel->info_word) \
280 channel->info_word->rx.param = cpu_to_le32(value); \
282 channel->info->rx.param = value; \
285 #define SET_RX_CHANNEL_INFO(channel, param, value) \
287 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
288 if (channel->info_word) \
289 channel->info_word->rx.param = cpu_to_le32(value); \
291 channel->info->rx.param = cpu_to_le32(value); \
294 #define GET_TX_CHANNEL_FLAG(channel, param) \
296 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
297 channel->info_word ? \
298 le32_to_cpu(channel->info_word->tx.param) : \
299 channel->info->tx.param; \
302 #define GET_TX_CHANNEL_INFO(channel, param) \
304 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
305 le32_to_cpu(channel->info_word ? \
306 channel->info_word->tx.param : \
307 channel->info->tx.param); \
310 #define SET_TX_CHANNEL_FLAG(channel, param, value) \
312 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
313 if (channel->info_word) \
314 channel->info_word->tx.param = cpu_to_le32(value); \
316 channel->info->tx.param = value; \
319 #define SET_TX_CHANNEL_INFO(channel, param, value) \
321 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
322 if (channel->info_word) \
323 channel->info_word->tx.param = cpu_to_le32(value); \
325 channel->info->tx.param = cpu_to_le32(value); \
329 * struct qcom_smd_alloc_entry - channel allocation entry
330 * @name: channel name
331 * @cid: channel index
332 * @flags: channel flags and edge id
333 * @ref_count: reference count of the channel
335 struct qcom_smd_alloc_entry
{
342 #define SMD_CHANNEL_FLAGS_EDGE_MASK 0xff
343 #define SMD_CHANNEL_FLAGS_STREAM BIT(8)
344 #define SMD_CHANNEL_FLAGS_PACKET BIT(9)
347 * Each smd packet contains a 20 byte header, with the first 4 being the length
350 #define SMD_PACKET_HEADER_LEN 20
353 * Signal the remote processor associated with 'channel'.
355 static void qcom_smd_signal_channel(struct qcom_smd_channel
*channel
)
357 struct qcom_smd_edge
*edge
= channel
->edge
;
359 regmap_write(edge
->ipc_regmap
, edge
->ipc_offset
, BIT(edge
->ipc_bit
));
363 * Initialize the tx channel info
365 static void qcom_smd_channel_reset(struct qcom_smd_channel
*channel
)
367 SET_TX_CHANNEL_INFO(channel
, state
, SMD_CHANNEL_CLOSED
);
368 SET_TX_CHANNEL_FLAG(channel
, fDSR
, 0);
369 SET_TX_CHANNEL_FLAG(channel
, fCTS
, 0);
370 SET_TX_CHANNEL_FLAG(channel
, fCD
, 0);
371 SET_TX_CHANNEL_FLAG(channel
, fRI
, 0);
372 SET_TX_CHANNEL_FLAG(channel
, fHEAD
, 0);
373 SET_TX_CHANNEL_FLAG(channel
, fTAIL
, 0);
374 SET_TX_CHANNEL_FLAG(channel
, fSTATE
, 1);
375 SET_TX_CHANNEL_FLAG(channel
, fBLOCKREADINTR
, 1);
376 SET_TX_CHANNEL_INFO(channel
, head
, 0);
377 SET_TX_CHANNEL_INFO(channel
, tail
, 0);
379 qcom_smd_signal_channel(channel
);
381 channel
->state
= SMD_CHANNEL_CLOSED
;
382 channel
->pkt_size
= 0;
386 * Set the callback for a channel, with appropriate locking
388 static void qcom_smd_channel_set_callback(struct qcom_smd_channel
*channel
,
393 spin_lock_irqsave(&channel
->recv_lock
, flags
);
395 spin_unlock_irqrestore(&channel
->recv_lock
, flags
);
399 * Calculate the amount of data available in the rx fifo
401 static size_t qcom_smd_channel_get_rx_avail(struct qcom_smd_channel
*channel
)
406 head
= GET_RX_CHANNEL_INFO(channel
, head
);
407 tail
= GET_RX_CHANNEL_INFO(channel
, tail
);
409 return (head
- tail
) & (channel
->fifo_size
- 1);
413 * Set tx channel state and inform the remote processor
415 static void qcom_smd_channel_set_state(struct qcom_smd_channel
*channel
,
418 struct qcom_smd_edge
*edge
= channel
->edge
;
419 bool is_open
= state
== SMD_CHANNEL_OPENED
;
421 if (channel
->state
== state
)
424 dev_dbg(edge
->smd
->dev
, "set_state(%s, %d)\n", channel
->name
, state
);
426 SET_TX_CHANNEL_FLAG(channel
, fDSR
, is_open
);
427 SET_TX_CHANNEL_FLAG(channel
, fCTS
, is_open
);
428 SET_TX_CHANNEL_FLAG(channel
, fCD
, is_open
);
430 SET_TX_CHANNEL_INFO(channel
, state
, state
);
431 SET_TX_CHANNEL_FLAG(channel
, fSTATE
, 1);
433 channel
->state
= state
;
434 qcom_smd_signal_channel(channel
);
438 * Copy count bytes of data using 32bit accesses, if that's required.
440 static void smd_copy_to_fifo(void __iomem
*dst
,
446 __iowrite32_copy(dst
, src
, count
/ sizeof(u32
));
448 memcpy_toio(dst
, src
, count
);
453 * Copy count bytes of data using 32bit accesses, if that is required.
455 static void smd_copy_from_fifo(void *dst
,
456 const void __iomem
*src
,
461 __ioread32_copy(dst
, src
, count
/ sizeof(u32
));
463 memcpy_fromio(dst
, src
, count
);
468 * Read count bytes of data from the rx fifo into buf, but don't advance the
471 static size_t qcom_smd_channel_peek(struct qcom_smd_channel
*channel
,
472 void *buf
, size_t count
)
478 word_aligned
= channel
->info_word
;
479 tail
= GET_RX_CHANNEL_INFO(channel
, tail
);
481 len
= min_t(size_t, count
, channel
->fifo_size
- tail
);
483 smd_copy_from_fifo(buf
,
484 channel
->rx_fifo
+ tail
,
490 smd_copy_from_fifo(buf
+ len
,
500 * Advance the rx tail by count bytes.
502 static void qcom_smd_channel_advance(struct qcom_smd_channel
*channel
,
507 tail
= GET_RX_CHANNEL_INFO(channel
, tail
);
509 tail
&= (channel
->fifo_size
- 1);
510 SET_RX_CHANNEL_INFO(channel
, tail
, tail
);
514 * Read out a single packet from the rx fifo and deliver it to the device
516 static int qcom_smd_channel_recv_single(struct qcom_smd_channel
*channel
)
526 tail
= GET_RX_CHANNEL_INFO(channel
, tail
);
528 /* Use bounce buffer if the data wraps */
529 if (tail
+ channel
->pkt_size
>= channel
->fifo_size
) {
530 ptr
= channel
->bounce_buffer
;
531 len
= qcom_smd_channel_peek(channel
, ptr
, channel
->pkt_size
);
533 ptr
= channel
->rx_fifo
+ tail
;
534 len
= channel
->pkt_size
;
537 ret
= channel
->cb(channel
, ptr
, len
);
541 /* Only forward the tail if the client consumed the data */
542 qcom_smd_channel_advance(channel
, len
);
544 channel
->pkt_size
= 0;
550 * Per channel interrupt handling
552 static bool qcom_smd_channel_intr(struct qcom_smd_channel
*channel
)
554 bool need_state_scan
= false;
560 /* Handle state changes */
561 remote_state
= GET_RX_CHANNEL_INFO(channel
, state
);
562 if (remote_state
!= channel
->remote_state
) {
563 channel
->remote_state
= remote_state
;
564 need_state_scan
= true;
566 /* Indicate that we have seen any state change */
567 SET_RX_CHANNEL_FLAG(channel
, fSTATE
, 0);
569 /* Signal waiting qcom_smd_send() about the interrupt */
570 if (!GET_TX_CHANNEL_FLAG(channel
, fBLOCKREADINTR
))
571 wake_up_interruptible(&channel
->fblockread_event
);
573 /* Don't consume any data until we've opened the channel */
574 if (channel
->state
!= SMD_CHANNEL_OPENED
)
577 /* Indicate that we've seen the new data */
578 SET_RX_CHANNEL_FLAG(channel
, fHEAD
, 0);
582 avail
= qcom_smd_channel_get_rx_avail(channel
);
584 if (!channel
->pkt_size
&& avail
>= SMD_PACKET_HEADER_LEN
) {
585 qcom_smd_channel_peek(channel
, &pktlen
, sizeof(pktlen
));
586 qcom_smd_channel_advance(channel
, SMD_PACKET_HEADER_LEN
);
587 channel
->pkt_size
= le32_to_cpu(pktlen
);
588 } else if (channel
->pkt_size
&& avail
>= channel
->pkt_size
) {
589 ret
= qcom_smd_channel_recv_single(channel
);
597 /* Indicate that we have seen and updated tail */
598 SET_RX_CHANNEL_FLAG(channel
, fTAIL
, 1);
600 /* Signal the remote that we've consumed the data (if requested) */
601 if (!GET_RX_CHANNEL_FLAG(channel
, fBLOCKREADINTR
)) {
602 /* Ensure ordering of channel info updates */
605 qcom_smd_signal_channel(channel
);
609 return need_state_scan
;
613 * The edge interrupts are triggered by the remote processor on state changes,
614 * channel info updates or when new channels are created.
616 static irqreturn_t
qcom_smd_edge_intr(int irq
, void *data
)
618 struct qcom_smd_edge
*edge
= data
;
619 struct qcom_smd_channel
*channel
;
621 bool kick_scanner
= false;
622 bool kick_state
= false;
625 * Handle state changes or data on each of the channels on this edge
627 spin_lock(&edge
->channels_lock
);
628 list_for_each_entry(channel
, &edge
->channels
, list
) {
629 spin_lock(&channel
->recv_lock
);
630 kick_state
|= qcom_smd_channel_intr(channel
);
631 spin_unlock(&channel
->recv_lock
);
633 spin_unlock(&edge
->channels_lock
);
636 * Creating a new channel requires allocating an smem entry, so we only
637 * have to scan if the amount of available space in smem have changed
640 available
= qcom_smem_get_free_space(edge
->remote_pid
);
641 if (available
!= edge
->smem_available
) {
642 edge
->smem_available
= available
;
647 schedule_work(&edge
->scan_work
);
649 schedule_work(&edge
->state_work
);
655 * Delivers any outstanding packets in the rx fifo, can be used after probe of
656 * the clients to deliver any packets that wasn't delivered before the client
659 static void qcom_smd_channel_resume(struct qcom_smd_channel
*channel
)
663 spin_lock_irqsave(&channel
->recv_lock
, flags
);
664 qcom_smd_channel_intr(channel
);
665 spin_unlock_irqrestore(&channel
->recv_lock
, flags
);
669 * Calculate how much space is available in the tx fifo.
671 static size_t qcom_smd_get_tx_avail(struct qcom_smd_channel
*channel
)
675 unsigned mask
= channel
->fifo_size
- 1;
677 head
= GET_TX_CHANNEL_INFO(channel
, head
);
678 tail
= GET_TX_CHANNEL_INFO(channel
, tail
);
680 return mask
- ((head
- tail
) & mask
);
684 * Write count bytes of data into channel, possibly wrapping in the ring buffer
686 static int qcom_smd_write_fifo(struct qcom_smd_channel
*channel
,
694 word_aligned
= channel
->info_word
;
695 head
= GET_TX_CHANNEL_INFO(channel
, head
);
697 len
= min_t(size_t, count
, channel
->fifo_size
- head
);
699 smd_copy_to_fifo(channel
->tx_fifo
+ head
,
706 smd_copy_to_fifo(channel
->tx_fifo
,
713 head
&= (channel
->fifo_size
- 1);
714 SET_TX_CHANNEL_INFO(channel
, head
, head
);
720 * qcom_smd_send - write data to smd channel
721 * @channel: channel handle
722 * @data: buffer of data to write
723 * @len: number of bytes to write
725 * This is a blocking write of len bytes into the channel's tx ring buffer and
726 * signal the remote end. It will sleep until there is enough space available
727 * in the tx buffer, utilizing the fBLOCKREADINTR signaling mechanism to avoid
730 int qcom_smd_send(struct qcom_smd_channel
*channel
, const void *data
, int len
)
732 __le32 hdr
[5] = { cpu_to_le32(len
), };
733 int tlen
= sizeof(hdr
) + len
;
736 /* Word aligned channels only accept word size aligned data */
737 if (channel
->info_word
&& len
% 4)
740 /* Reject packets that are too big */
741 if (tlen
>= channel
->fifo_size
)
744 ret
= mutex_lock_interruptible(&channel
->tx_lock
);
748 while (qcom_smd_get_tx_avail(channel
) < tlen
) {
749 if (channel
->state
!= SMD_CHANNEL_OPENED
) {
754 SET_TX_CHANNEL_FLAG(channel
, fBLOCKREADINTR
, 0);
756 ret
= wait_event_interruptible(channel
->fblockread_event
,
757 qcom_smd_get_tx_avail(channel
) >= tlen
||
758 channel
->state
!= SMD_CHANNEL_OPENED
);
762 SET_TX_CHANNEL_FLAG(channel
, fBLOCKREADINTR
, 1);
765 SET_TX_CHANNEL_FLAG(channel
, fTAIL
, 0);
767 qcom_smd_write_fifo(channel
, hdr
, sizeof(hdr
));
768 qcom_smd_write_fifo(channel
, data
, len
);
770 SET_TX_CHANNEL_FLAG(channel
, fHEAD
, 1);
772 /* Ensure ordering of channel info updates */
775 qcom_smd_signal_channel(channel
);
778 mutex_unlock(&channel
->tx_lock
);
782 EXPORT_SYMBOL(qcom_smd_send
);
784 static struct qcom_smd_device
*to_smd_device(struct device
*dev
)
786 return container_of(dev
, struct qcom_smd_device
, dev
);
789 static struct qcom_smd_driver
*to_smd_driver(struct device
*dev
)
791 struct qcom_smd_device
*qsdev
= to_smd_device(dev
);
793 return container_of(qsdev
->dev
.driver
, struct qcom_smd_driver
, driver
);
796 static int qcom_smd_dev_match(struct device
*dev
, struct device_driver
*drv
)
798 struct qcom_smd_device
*qsdev
= to_smd_device(dev
);
799 struct qcom_smd_driver
*qsdrv
= container_of(drv
, struct qcom_smd_driver
, driver
);
800 const struct qcom_smd_id
*match
= qsdrv
->smd_match_table
;
801 const char *name
= qsdev
->channel
->name
;
804 while (match
->name
[0]) {
805 if (!strcmp(match
->name
, name
))
811 return of_driver_match_device(dev
, drv
);
815 * Helper for opening a channel
817 static int qcom_smd_channel_open(struct qcom_smd_channel
*channel
,
823 * Packets are maximum 4k, but reduce if the fifo is smaller
825 bb_size
= min(channel
->fifo_size
, SZ_4K
);
826 channel
->bounce_buffer
= kmalloc(bb_size
, GFP_KERNEL
);
827 if (!channel
->bounce_buffer
)
830 qcom_smd_channel_set_callback(channel
, cb
);
831 qcom_smd_channel_set_state(channel
, SMD_CHANNEL_OPENING
);
832 qcom_smd_channel_set_state(channel
, SMD_CHANNEL_OPENED
);
838 * Helper for closing and resetting a channel
840 static void qcom_smd_channel_close(struct qcom_smd_channel
*channel
)
842 qcom_smd_channel_set_callback(channel
, NULL
);
844 kfree(channel
->bounce_buffer
);
845 channel
->bounce_buffer
= NULL
;
847 qcom_smd_channel_set_state(channel
, SMD_CHANNEL_CLOSED
);
848 qcom_smd_channel_reset(channel
);
852 * Probe the smd client.
854 * The remote side have indicated that it want the channel to be opened, so
855 * complete the state handshake and probe our client driver.
857 static int qcom_smd_dev_probe(struct device
*dev
)
859 struct qcom_smd_device
*qsdev
= to_smd_device(dev
);
860 struct qcom_smd_driver
*qsdrv
= to_smd_driver(dev
);
861 struct qcom_smd_channel
*channel
= qsdev
->channel
;
864 ret
= qcom_smd_channel_open(channel
, qsdrv
->callback
);
868 ret
= qsdrv
->probe(qsdev
);
872 qcom_smd_channel_resume(channel
);
877 dev_err(&qsdev
->dev
, "probe failed\n");
879 qcom_smd_channel_close(channel
);
884 * Remove the smd client.
886 * The channel is going away, for some reason, so remove the smd client and
887 * reset the channel state.
889 static int qcom_smd_dev_remove(struct device
*dev
)
891 struct qcom_smd_device
*qsdev
= to_smd_device(dev
);
892 struct qcom_smd_driver
*qsdrv
= to_smd_driver(dev
);
893 struct qcom_smd_channel
*channel
= qsdev
->channel
;
894 struct qcom_smd_channel
*tmp
;
895 struct qcom_smd_channel
*ch
;
897 qcom_smd_channel_set_state(channel
, SMD_CHANNEL_CLOSING
);
900 * Make sure we don't race with the code receiving data.
902 qcom_smd_channel_set_callback(channel
, NULL
);
904 /* Wake up any sleepers in qcom_smd_send() */
905 wake_up_interruptible(&channel
->fblockread_event
);
908 * We expect that the client might block in remove() waiting for any
909 * outstanding calls to qcom_smd_send() to wake up and finish.
912 qsdrv
->remove(qsdev
);
915 * The client is now gone, close and release all channels associated
918 list_for_each_entry_safe(ch
, tmp
, &channel
->dev_list
, dev_list
) {
919 qcom_smd_channel_close(ch
);
920 list_del(&ch
->dev_list
);
927 static struct bus_type qcom_smd_bus
= {
929 .match
= qcom_smd_dev_match
,
930 .probe
= qcom_smd_dev_probe
,
931 .remove
= qcom_smd_dev_remove
,
935 * Release function for the qcom_smd_device object.
937 static void qcom_smd_release_device(struct device
*dev
)
939 struct qcom_smd_device
*qsdev
= to_smd_device(dev
);
945 * Finds the device_node for the smd child interested in this channel.
947 static struct device_node
*qcom_smd_match_channel(struct device_node
*edge_node
,
950 struct device_node
*child
;
955 for_each_available_child_of_node(edge_node
, child
) {
956 key
= "qcom,smd-channels";
957 ret
= of_property_read_string(child
, key
, &name
);
961 if (strcmp(name
, channel
) == 0)
969 * Create a smd client device for channel that is being opened.
971 static int qcom_smd_create_device(struct qcom_smd_channel
*channel
)
973 struct qcom_smd_device
*qsdev
;
974 struct qcom_smd_edge
*edge
= channel
->edge
;
975 struct device_node
*node
;
976 struct qcom_smd
*smd
= edge
->smd
;
982 dev_dbg(smd
->dev
, "registering '%s'\n", channel
->name
);
984 qsdev
= kzalloc(sizeof(*qsdev
), GFP_KERNEL
);
988 node
= qcom_smd_match_channel(edge
->of_node
, channel
->name
);
989 dev_set_name(&qsdev
->dev
, "%s.%s",
991 node
? node
->name
: channel
->name
);
993 qsdev
->dev
.parent
= smd
->dev
;
994 qsdev
->dev
.bus
= &qcom_smd_bus
;
995 qsdev
->dev
.release
= qcom_smd_release_device
;
996 qsdev
->dev
.of_node
= node
;
998 qsdev
->channel
= channel
;
1000 channel
->qsdev
= qsdev
;
1002 ret
= device_register(&qsdev
->dev
);
1004 dev_err(smd
->dev
, "device_register failed: %d\n", ret
);
1005 put_device(&qsdev
->dev
);
1012 * Destroy a smd client device for a channel that's going away.
1014 static void qcom_smd_destroy_device(struct qcom_smd_channel
*channel
)
1018 BUG_ON(!channel
->qsdev
);
1020 dev
= &channel
->qsdev
->dev
;
1022 device_unregister(dev
);
1023 of_node_put(dev
->of_node
);
1028 * qcom_smd_driver_register - register a smd driver
1029 * @qsdrv: qcom_smd_driver struct
1031 int qcom_smd_driver_register(struct qcom_smd_driver
*qsdrv
)
1033 qsdrv
->driver
.bus
= &qcom_smd_bus
;
1034 return driver_register(&qsdrv
->driver
);
1036 EXPORT_SYMBOL(qcom_smd_driver_register
);
1038 void *qcom_smd_get_drvdata(struct qcom_smd_channel
*channel
)
1040 return channel
->drvdata
;
1042 EXPORT_SYMBOL(qcom_smd_get_drvdata
);
1044 void qcom_smd_set_drvdata(struct qcom_smd_channel
*channel
, void *data
)
1046 channel
->drvdata
= data
;
1048 EXPORT_SYMBOL(qcom_smd_set_drvdata
);
1051 * qcom_smd_driver_unregister - unregister a smd driver
1052 * @qsdrv: qcom_smd_driver struct
1054 void qcom_smd_driver_unregister(struct qcom_smd_driver
*qsdrv
)
1056 driver_unregister(&qsdrv
->driver
);
1058 EXPORT_SYMBOL(qcom_smd_driver_unregister
);
1060 static struct qcom_smd_channel
*
1061 qcom_smd_find_channel(struct qcom_smd_edge
*edge
, const char *name
)
1063 struct qcom_smd_channel
*channel
;
1064 struct qcom_smd_channel
*ret
= NULL
;
1065 unsigned long flags
;
1068 spin_lock_irqsave(&edge
->channels_lock
, flags
);
1069 list_for_each_entry(channel
, &edge
->channels
, list
) {
1070 if (strcmp(channel
->name
, name
))
1073 state
= GET_RX_CHANNEL_INFO(channel
, state
);
1074 if (state
!= SMD_CHANNEL_OPENING
&&
1075 state
!= SMD_CHANNEL_OPENED
)
1081 spin_unlock_irqrestore(&edge
->channels_lock
, flags
);
1087 * qcom_smd_open_channel() - claim additional channels on the same edge
1088 * @sdev: smd_device handle
1089 * @name: channel name
1090 * @cb: callback method to use for incoming data
1092 * Returns a channel handle on success, or -EPROBE_DEFER if the channel isn't
1095 struct qcom_smd_channel
*qcom_smd_open_channel(struct qcom_smd_channel
*parent
,
1099 struct qcom_smd_channel
*channel
;
1100 struct qcom_smd_device
*sdev
= parent
->qsdev
;
1101 struct qcom_smd_edge
*edge
= parent
->edge
;
1104 /* Wait up to HZ for the channel to appear */
1105 ret
= wait_event_interruptible_timeout(edge
->new_channel_event
,
1106 (channel
= qcom_smd_find_channel(edge
, name
)) != NULL
,
1109 return ERR_PTR(-ETIMEDOUT
);
1111 if (channel
->state
!= SMD_CHANNEL_CLOSED
) {
1112 dev_err(&sdev
->dev
, "channel %s is busy\n", channel
->name
);
1113 return ERR_PTR(-EBUSY
);
1116 channel
->qsdev
= sdev
;
1117 ret
= qcom_smd_channel_open(channel
, cb
);
1119 channel
->qsdev
= NULL
;
1120 return ERR_PTR(ret
);
1124 * Append the list of channel to the channels associated with the sdev
1126 list_add_tail(&channel
->dev_list
, &sdev
->channel
->dev_list
);
1130 EXPORT_SYMBOL(qcom_smd_open_channel
);
1133 * Allocate the qcom_smd_channel object for a newly found smd channel,
1134 * retrieving and validating the smem items involved.
1136 static struct qcom_smd_channel
*qcom_smd_create_channel(struct qcom_smd_edge
*edge
,
1137 unsigned smem_info_item
,
1138 unsigned smem_fifo_item
,
1141 struct qcom_smd_channel
*channel
;
1142 struct qcom_smd
*smd
= edge
->smd
;
1149 channel
= devm_kzalloc(smd
->dev
, sizeof(*channel
), GFP_KERNEL
);
1151 return ERR_PTR(-ENOMEM
);
1153 INIT_LIST_HEAD(&channel
->dev_list
);
1154 channel
->edge
= edge
;
1155 channel
->name
= devm_kstrdup(smd
->dev
, name
, GFP_KERNEL
);
1157 return ERR_PTR(-ENOMEM
);
1159 mutex_init(&channel
->tx_lock
);
1160 spin_lock_init(&channel
->recv_lock
);
1161 init_waitqueue_head(&channel
->fblockread_event
);
1163 info
= qcom_smem_get(edge
->remote_pid
, smem_info_item
, &info_size
);
1165 ret
= PTR_ERR(info
);
1166 goto free_name_and_channel
;
1170 * Use the size of the item to figure out which channel info struct to
1173 if (info_size
== 2 * sizeof(struct smd_channel_info_word
)) {
1174 channel
->info_word
= info
;
1175 } else if (info_size
== 2 * sizeof(struct smd_channel_info
)) {
1176 channel
->info
= info
;
1179 "channel info of size %zu not supported\n", info_size
);
1181 goto free_name_and_channel
;
1184 fifo_base
= qcom_smem_get(edge
->remote_pid
, smem_fifo_item
, &fifo_size
);
1185 if (IS_ERR(fifo_base
)) {
1186 ret
= PTR_ERR(fifo_base
);
1187 goto free_name_and_channel
;
1190 /* The channel consist of a rx and tx fifo of equal size */
1193 dev_dbg(smd
->dev
, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1194 name
, info_size
, fifo_size
);
1196 channel
->tx_fifo
= fifo_base
;
1197 channel
->rx_fifo
= fifo_base
+ fifo_size
;
1198 channel
->fifo_size
= fifo_size
;
1200 qcom_smd_channel_reset(channel
);
1204 free_name_and_channel
:
1205 devm_kfree(smd
->dev
, channel
->name
);
1206 devm_kfree(smd
->dev
, channel
);
1208 return ERR_PTR(ret
);
1212 * Scans the allocation table for any newly allocated channels, calls
1213 * qcom_smd_create_channel() to create representations of these and add
1214 * them to the edge's list of channels.
1216 static void qcom_channel_scan_worker(struct work_struct
*work
)
1218 struct qcom_smd_edge
*edge
= container_of(work
, struct qcom_smd_edge
, scan_work
);
1219 struct qcom_smd_alloc_entry
*alloc_tbl
;
1220 struct qcom_smd_alloc_entry
*entry
;
1221 struct qcom_smd_channel
*channel
;
1222 struct qcom_smd
*smd
= edge
->smd
;
1223 unsigned long flags
;
1230 for (tbl
= 0; tbl
< SMD_ALLOC_TBL_COUNT
; tbl
++) {
1231 alloc_tbl
= qcom_smem_get(edge
->remote_pid
,
1232 smem_items
[tbl
].alloc_tbl_id
, NULL
);
1233 if (IS_ERR(alloc_tbl
))
1236 for (i
= 0; i
< SMD_ALLOC_TBL_SIZE
; i
++) {
1237 entry
= &alloc_tbl
[i
];
1238 eflags
= le32_to_cpu(entry
->flags
);
1239 if (test_bit(i
, edge
->allocated
[tbl
]))
1242 if (entry
->ref_count
== 0)
1245 if (!entry
->name
[0])
1248 if (!(eflags
& SMD_CHANNEL_FLAGS_PACKET
))
1251 if ((eflags
& SMD_CHANNEL_FLAGS_EDGE_MASK
) != edge
->edge_id
)
1254 cid
= le32_to_cpu(entry
->cid
);
1255 info_id
= smem_items
[tbl
].info_base_id
+ cid
;
1256 fifo_id
= smem_items
[tbl
].fifo_base_id
+ cid
;
1258 channel
= qcom_smd_create_channel(edge
, info_id
, fifo_id
, entry
->name
);
1259 if (IS_ERR(channel
))
1262 spin_lock_irqsave(&edge
->channels_lock
, flags
);
1263 list_add(&channel
->list
, &edge
->channels
);
1264 spin_unlock_irqrestore(&edge
->channels_lock
, flags
);
1266 dev_dbg(smd
->dev
, "new channel found: '%s'\n", channel
->name
);
1267 set_bit(i
, edge
->allocated
[tbl
]);
1269 wake_up_interruptible(&edge
->new_channel_event
);
1273 schedule_work(&edge
->state_work
);
1277 * This per edge worker scans smem for any new channels and register these. It
1278 * then scans all registered channels for state changes that should be handled
1279 * by creating or destroying smd client devices for the registered channels.
1281 * LOCKING: edge->channels_lock only needs to cover the list operations, as the
1282 * worker is killed before any channels are deallocated
1284 static void qcom_channel_state_worker(struct work_struct
*work
)
1286 struct qcom_smd_channel
*channel
;
1287 struct qcom_smd_edge
*edge
= container_of(work
,
1288 struct qcom_smd_edge
,
1290 unsigned remote_state
;
1291 unsigned long flags
;
1294 * Register a device for any closed channel where the remote processor
1295 * is showing interest in opening the channel.
1297 spin_lock_irqsave(&edge
->channels_lock
, flags
);
1298 list_for_each_entry(channel
, &edge
->channels
, list
) {
1299 if (channel
->state
!= SMD_CHANNEL_CLOSED
)
1302 remote_state
= GET_RX_CHANNEL_INFO(channel
, state
);
1303 if (remote_state
!= SMD_CHANNEL_OPENING
&&
1304 remote_state
!= SMD_CHANNEL_OPENED
)
1307 spin_unlock_irqrestore(&edge
->channels_lock
, flags
);
1308 qcom_smd_create_device(channel
);
1309 spin_lock_irqsave(&edge
->channels_lock
, flags
);
1313 * Unregister the device for any channel that is opened where the
1314 * remote processor is closing the channel.
1316 list_for_each_entry(channel
, &edge
->channels
, list
) {
1317 if (channel
->state
!= SMD_CHANNEL_OPENING
&&
1318 channel
->state
!= SMD_CHANNEL_OPENED
)
1321 remote_state
= GET_RX_CHANNEL_INFO(channel
, state
);
1322 if (remote_state
== SMD_CHANNEL_OPENING
||
1323 remote_state
== SMD_CHANNEL_OPENED
)
1326 spin_unlock_irqrestore(&edge
->channels_lock
, flags
);
1327 qcom_smd_destroy_device(channel
);
1328 spin_lock_irqsave(&edge
->channels_lock
, flags
);
1330 spin_unlock_irqrestore(&edge
->channels_lock
, flags
);
1334 * Parses an of_node describing an edge.
1336 static int qcom_smd_parse_edge(struct device
*dev
,
1337 struct device_node
*node
,
1338 struct qcom_smd_edge
*edge
)
1340 struct device_node
*syscon_np
;
1345 INIT_LIST_HEAD(&edge
->channels
);
1346 spin_lock_init(&edge
->channels_lock
);
1348 INIT_WORK(&edge
->scan_work
, qcom_channel_scan_worker
);
1349 INIT_WORK(&edge
->state_work
, qcom_channel_state_worker
);
1351 edge
->of_node
= of_node_get(node
);
1353 irq
= irq_of_parse_and_map(node
, 0);
1355 dev_err(dev
, "required smd interrupt missing\n");
1359 ret
= devm_request_irq(dev
, irq
,
1360 qcom_smd_edge_intr
, IRQF_TRIGGER_RISING
,
1363 dev_err(dev
, "failed to request smd irq\n");
1369 key
= "qcom,smd-edge";
1370 ret
= of_property_read_u32(node
, key
, &edge
->edge_id
);
1372 dev_err(dev
, "edge missing %s property\n", key
);
1376 edge
->remote_pid
= QCOM_SMEM_HOST_ANY
;
1377 key
= "qcom,remote-pid";
1378 of_property_read_u32(node
, key
, &edge
->remote_pid
);
1380 syscon_np
= of_parse_phandle(node
, "qcom,ipc", 0);
1382 dev_err(dev
, "no qcom,ipc node\n");
1386 edge
->ipc_regmap
= syscon_node_to_regmap(syscon_np
);
1387 if (IS_ERR(edge
->ipc_regmap
))
1388 return PTR_ERR(edge
->ipc_regmap
);
1391 ret
= of_property_read_u32_index(node
, key
, 1, &edge
->ipc_offset
);
1393 dev_err(dev
, "no offset in %s\n", key
);
1397 ret
= of_property_read_u32_index(node
, key
, 2, &edge
->ipc_bit
);
1399 dev_err(dev
, "no bit in %s\n", key
);
1406 static int qcom_smd_probe(struct platform_device
*pdev
)
1408 struct qcom_smd_edge
*edge
;
1409 struct device_node
*node
;
1410 struct qcom_smd
*smd
;
1418 p
= qcom_smem_get(QCOM_SMEM_HOST_ANY
, smem_items
[0].alloc_tbl_id
, NULL
);
1419 if (PTR_ERR(p
) == -EPROBE_DEFER
)
1422 num_edges
= of_get_available_child_count(pdev
->dev
.of_node
);
1423 array_size
= sizeof(*smd
) + num_edges
* sizeof(struct qcom_smd_edge
);
1424 smd
= devm_kzalloc(&pdev
->dev
, array_size
, GFP_KERNEL
);
1427 smd
->dev
= &pdev
->dev
;
1429 smd
->num_edges
= num_edges
;
1430 for_each_available_child_of_node(pdev
->dev
.of_node
, node
) {
1431 edge
= &smd
->edges
[i
++];
1433 init_waitqueue_head(&edge
->new_channel_event
);
1435 ret
= qcom_smd_parse_edge(&pdev
->dev
, node
, edge
);
1439 schedule_work(&edge
->scan_work
);
1442 platform_set_drvdata(pdev
, smd
);
1448 * Shut down all smd clients by making sure that each edge stops processing
1449 * events and scanning for new channels, then call destroy on the devices.
1451 static int qcom_smd_remove(struct platform_device
*pdev
)
1453 struct qcom_smd_channel
*channel
;
1454 struct qcom_smd_edge
*edge
;
1455 struct qcom_smd
*smd
= platform_get_drvdata(pdev
);
1458 for (i
= 0; i
< smd
->num_edges
; i
++) {
1459 edge
= &smd
->edges
[i
];
1461 disable_irq(edge
->irq
);
1462 cancel_work_sync(&edge
->scan_work
);
1463 cancel_work_sync(&edge
->state_work
);
1465 /* No need to lock here, because the writer is gone */
1466 list_for_each_entry(channel
, &edge
->channels
, list
) {
1467 if (!channel
->qsdev
)
1470 qcom_smd_destroy_device(channel
);
1477 static const struct of_device_id qcom_smd_of_match
[] = {
1478 { .compatible
= "qcom,smd" },
1481 MODULE_DEVICE_TABLE(of
, qcom_smd_of_match
);
1483 static struct platform_driver qcom_smd_driver
= {
1484 .probe
= qcom_smd_probe
,
1485 .remove
= qcom_smd_remove
,
1488 .of_match_table
= qcom_smd_of_match
,
1492 static int __init
qcom_smd_init(void)
1496 ret
= bus_register(&qcom_smd_bus
);
1498 pr_err("failed to register smd bus: %d\n", ret
);
1502 return platform_driver_register(&qcom_smd_driver
);
1504 postcore_initcall(qcom_smd_init
);
1506 static void __exit
qcom_smd_exit(void)
1508 platform_driver_unregister(&qcom_smd_driver
);
1509 bus_unregister(&qcom_smd_bus
);
1511 module_exit(qcom_smd_exit
);
1513 MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
1514 MODULE_DESCRIPTION("Qualcomm Shared Memory Driver");
1515 MODULE_LICENSE("GPL v2");