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 * @dev: device for this edge
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 {
116 struct device_node *of_node;
122 struct regmap *ipc_regmap;
126 struct list_head channels;
127 spinlock_t channels_lock;
129 DECLARE_BITMAP(allocated[SMD_ALLOC_TBL_COUNT], SMD_ALLOC_TBL_SIZE);
131 unsigned smem_available;
133 wait_queue_head_t new_channel_event;
135 struct work_struct scan_work;
136 struct work_struct state_work;
139 #define to_smd_edge(d) container_of(d, struct qcom_smd_edge, dev)
142 * SMD channel states.
144 enum smd_channel_state {
148 SMD_CHANNEL_FLUSHING,
151 SMD_CHANNEL_RESET_OPENING
155 * struct qcom_smd_channel - smd channel struct
156 * @edge: qcom_smd_edge this channel is living on
157 * @qsdev: reference to a associated smd client device
158 * @name: name of the channel
159 * @state: local state of the channel
160 * @remote_state: remote state of the channel
161 * @info: byte aligned outgoing/incoming channel info
162 * @info_word: word aligned outgoing/incoming channel info
163 * @tx_lock: lock to make writes to the channel mutually exclusive
164 * @fblockread_event: wakeup event tied to tx fBLOCKREADINTR
165 * @tx_fifo: pointer to the outgoing ring buffer
166 * @rx_fifo: pointer to the incoming ring buffer
167 * @fifo_size: size of each ring buffer
168 * @bounce_buffer: bounce buffer for reading wrapped packets
169 * @cb: callback function registered for this channel
170 * @recv_lock: guard for rx info modifications and cb pointer
171 * @pkt_size: size of the currently handled packet
172 * @list: lite entry for @channels in qcom_smd_edge
174 struct qcom_smd_channel {
175 struct qcom_smd_edge *edge;
177 struct qcom_smd_device *qsdev;
180 enum smd_channel_state state;
181 enum smd_channel_state remote_state;
183 struct smd_channel_info_pair *info;
184 struct smd_channel_info_word_pair *info_word;
186 struct mutex tx_lock;
187 wait_queue_head_t fblockread_event;
196 spinlock_t recv_lock;
202 struct list_head list;
206 * Format of the smd_info smem items, for byte aligned channels.
208 struct smd_channel_info {
222 struct smd_channel_info_pair {
223 struct smd_channel_info tx;
224 struct smd_channel_info rx;
228 * Format of the smd_info smem items, for word aligned channels.
230 struct smd_channel_info_word {
239 __le32 fBLOCKREADINTR;
244 struct smd_channel_info_word_pair {
245 struct smd_channel_info_word tx;
246 struct smd_channel_info_word rx;
249 #define GET_RX_CHANNEL_FLAG(channel, param) \
251 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
252 channel->info_word ? \
253 le32_to_cpu(channel->info_word->rx.param) : \
254 channel->info->rx.param; \
257 #define GET_RX_CHANNEL_INFO(channel, param) \
259 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
260 le32_to_cpu(channel->info_word ? \
261 channel->info_word->rx.param : \
262 channel->info->rx.param); \
265 #define SET_RX_CHANNEL_FLAG(channel, param, value) \
267 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u8)); \
268 if (channel->info_word) \
269 channel->info_word->rx.param = cpu_to_le32(value); \
271 channel->info->rx.param = value; \
274 #define SET_RX_CHANNEL_INFO(channel, param, value) \
276 BUILD_BUG_ON(sizeof(channel->info->rx.param) != sizeof(u32)); \
277 if (channel->info_word) \
278 channel->info_word->rx.param = cpu_to_le32(value); \
280 channel->info->rx.param = cpu_to_le32(value); \
283 #define GET_TX_CHANNEL_FLAG(channel, param) \
285 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
286 channel->info_word ? \
287 le32_to_cpu(channel->info_word->tx.param) : \
288 channel->info->tx.param; \
291 #define GET_TX_CHANNEL_INFO(channel, param) \
293 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
294 le32_to_cpu(channel->info_word ? \
295 channel->info_word->tx.param : \
296 channel->info->tx.param); \
299 #define SET_TX_CHANNEL_FLAG(channel, param, value) \
301 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u8)); \
302 if (channel->info_word) \
303 channel->info_word->tx.param = cpu_to_le32(value); \
305 channel->info->tx.param = value; \
308 #define SET_TX_CHANNEL_INFO(channel, param, value) \
310 BUILD_BUG_ON(sizeof(channel->info->tx.param) != sizeof(u32)); \
311 if (channel->info_word) \
312 channel->info_word->tx.param = cpu_to_le32(value); \
314 channel->info->tx.param = cpu_to_le32(value); \
318 * struct qcom_smd_alloc_entry - channel allocation entry
319 * @name: channel name
320 * @cid: channel index
321 * @flags: channel flags and edge id
322 * @ref_count: reference count of the channel
324 struct qcom_smd_alloc_entry {
331 #define SMD_CHANNEL_FLAGS_EDGE_MASK 0xff
332 #define SMD_CHANNEL_FLAGS_STREAM BIT(8)
333 #define SMD_CHANNEL_FLAGS_PACKET BIT(9)
336 * Each smd packet contains a 20 byte header, with the first 4 being the length
339 #define SMD_PACKET_HEADER_LEN 20
342 * Signal the remote processor associated with 'channel'.
344 static void qcom_smd_signal_channel(struct qcom_smd_channel *channel)
346 struct qcom_smd_edge *edge = channel->edge;
348 regmap_write(edge->ipc_regmap, edge->ipc_offset, BIT(edge->ipc_bit));
352 * Initialize the tx channel info
354 static void qcom_smd_channel_reset(struct qcom_smd_channel *channel)
356 SET_TX_CHANNEL_INFO(channel, state, SMD_CHANNEL_CLOSED);
357 SET_TX_CHANNEL_FLAG(channel, fDSR, 0);
358 SET_TX_CHANNEL_FLAG(channel, fCTS, 0);
359 SET_TX_CHANNEL_FLAG(channel, fCD, 0);
360 SET_TX_CHANNEL_FLAG(channel, fRI, 0);
361 SET_TX_CHANNEL_FLAG(channel, fHEAD, 0);
362 SET_TX_CHANNEL_FLAG(channel, fTAIL, 0);
363 SET_TX_CHANNEL_FLAG(channel, fSTATE, 1);
364 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 1);
365 SET_TX_CHANNEL_INFO(channel, head, 0);
366 SET_RX_CHANNEL_INFO(channel, tail, 0);
368 qcom_smd_signal_channel(channel);
370 channel->state = SMD_CHANNEL_CLOSED;
371 channel->pkt_size = 0;
375 * Set the callback for a channel, with appropriate locking
377 static void qcom_smd_channel_set_callback(struct qcom_smd_channel *channel,
382 spin_lock_irqsave(&channel->recv_lock, flags);
384 spin_unlock_irqrestore(&channel->recv_lock, flags);
388 * Calculate the amount of data available in the rx fifo
390 static size_t qcom_smd_channel_get_rx_avail(struct qcom_smd_channel *channel)
395 head = GET_RX_CHANNEL_INFO(channel, head);
396 tail = GET_RX_CHANNEL_INFO(channel, tail);
398 return (head - tail) & (channel->fifo_size - 1);
402 * Set tx channel state and inform the remote processor
404 static void qcom_smd_channel_set_state(struct qcom_smd_channel *channel,
407 struct qcom_smd_edge *edge = channel->edge;
408 bool is_open = state == SMD_CHANNEL_OPENED;
410 if (channel->state == state)
413 dev_dbg(&edge->dev, "set_state(%s, %d)\n", channel->name, state);
415 SET_TX_CHANNEL_FLAG(channel, fDSR, is_open);
416 SET_TX_CHANNEL_FLAG(channel, fCTS, is_open);
417 SET_TX_CHANNEL_FLAG(channel, fCD, is_open);
419 SET_TX_CHANNEL_INFO(channel, state, state);
420 SET_TX_CHANNEL_FLAG(channel, fSTATE, 1);
422 channel->state = state;
423 qcom_smd_signal_channel(channel);
427 * Copy count bytes of data using 32bit accesses, if that's required.
429 static void smd_copy_to_fifo(void __iomem *dst,
435 __iowrite32_copy(dst, src, count / sizeof(u32));
437 memcpy_toio(dst, src, count);
442 * Copy count bytes of data using 32bit accesses, if that is required.
444 static void smd_copy_from_fifo(void *dst,
445 const void __iomem *src,
450 __ioread32_copy(dst, src, count / sizeof(u32));
452 memcpy_fromio(dst, src, count);
457 * Read count bytes of data from the rx fifo into buf, but don't advance the
460 static size_t qcom_smd_channel_peek(struct qcom_smd_channel *channel,
461 void *buf, size_t count)
467 word_aligned = channel->info_word;
468 tail = GET_RX_CHANNEL_INFO(channel, tail);
470 len = min_t(size_t, count, channel->fifo_size - tail);
472 smd_copy_from_fifo(buf,
473 channel->rx_fifo + tail,
479 smd_copy_from_fifo(buf + len,
489 * Advance the rx tail by count bytes.
491 static void qcom_smd_channel_advance(struct qcom_smd_channel *channel,
496 tail = GET_RX_CHANNEL_INFO(channel, tail);
498 tail &= (channel->fifo_size - 1);
499 SET_RX_CHANNEL_INFO(channel, tail, tail);
503 * Read out a single packet from the rx fifo and deliver it to the device
505 static int qcom_smd_channel_recv_single(struct qcom_smd_channel *channel)
515 tail = GET_RX_CHANNEL_INFO(channel, tail);
517 /* Use bounce buffer if the data wraps */
518 if (tail + channel->pkt_size >= channel->fifo_size) {
519 ptr = channel->bounce_buffer;
520 len = qcom_smd_channel_peek(channel, ptr, channel->pkt_size);
522 ptr = channel->rx_fifo + tail;
523 len = channel->pkt_size;
526 ret = channel->cb(channel, ptr, len);
530 /* Only forward the tail if the client consumed the data */
531 qcom_smd_channel_advance(channel, len);
533 channel->pkt_size = 0;
539 * Per channel interrupt handling
541 static bool qcom_smd_channel_intr(struct qcom_smd_channel *channel)
543 bool need_state_scan = false;
549 /* Handle state changes */
550 remote_state = GET_RX_CHANNEL_INFO(channel, state);
551 if (remote_state != channel->remote_state) {
552 channel->remote_state = remote_state;
553 need_state_scan = true;
555 /* Indicate that we have seen any state change */
556 SET_RX_CHANNEL_FLAG(channel, fSTATE, 0);
558 /* Signal waiting qcom_smd_send() about the interrupt */
559 if (!GET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR))
560 wake_up_interruptible(&channel->fblockread_event);
562 /* Don't consume any data until we've opened the channel */
563 if (channel->state != SMD_CHANNEL_OPENED)
566 /* Indicate that we've seen the new data */
567 SET_RX_CHANNEL_FLAG(channel, fHEAD, 0);
571 avail = qcom_smd_channel_get_rx_avail(channel);
573 if (!channel->pkt_size && avail >= SMD_PACKET_HEADER_LEN) {
574 qcom_smd_channel_peek(channel, &pktlen, sizeof(pktlen));
575 qcom_smd_channel_advance(channel, SMD_PACKET_HEADER_LEN);
576 channel->pkt_size = le32_to_cpu(pktlen);
577 } else if (channel->pkt_size && avail >= channel->pkt_size) {
578 ret = qcom_smd_channel_recv_single(channel);
586 /* Indicate that we have seen and updated tail */
587 SET_RX_CHANNEL_FLAG(channel, fTAIL, 1);
589 /* Signal the remote that we've consumed the data (if requested) */
590 if (!GET_RX_CHANNEL_FLAG(channel, fBLOCKREADINTR)) {
591 /* Ensure ordering of channel info updates */
594 qcom_smd_signal_channel(channel);
598 return need_state_scan;
602 * The edge interrupts are triggered by the remote processor on state changes,
603 * channel info updates or when new channels are created.
605 static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
607 struct qcom_smd_edge *edge = data;
608 struct qcom_smd_channel *channel;
610 bool kick_scanner = false;
611 bool kick_state = false;
614 * Handle state changes or data on each of the channels on this edge
616 spin_lock(&edge->channels_lock);
617 list_for_each_entry(channel, &edge->channels, list) {
618 spin_lock(&channel->recv_lock);
619 kick_state |= qcom_smd_channel_intr(channel);
620 spin_unlock(&channel->recv_lock);
622 spin_unlock(&edge->channels_lock);
625 * Creating a new channel requires allocating an smem entry, so we only
626 * have to scan if the amount of available space in smem have changed
629 available = qcom_smem_get_free_space(edge->remote_pid);
630 if (available != edge->smem_available) {
631 edge->smem_available = available;
636 schedule_work(&edge->scan_work);
638 schedule_work(&edge->state_work);
644 * Delivers any outstanding packets in the rx fifo, can be used after probe of
645 * the clients to deliver any packets that wasn't delivered before the client
648 static void qcom_smd_channel_resume(struct qcom_smd_channel *channel)
652 spin_lock_irqsave(&channel->recv_lock, flags);
653 qcom_smd_channel_intr(channel);
654 spin_unlock_irqrestore(&channel->recv_lock, flags);
658 * Calculate how much space is available in the tx fifo.
660 static size_t qcom_smd_get_tx_avail(struct qcom_smd_channel *channel)
664 unsigned mask = channel->fifo_size - 1;
666 head = GET_TX_CHANNEL_INFO(channel, head);
667 tail = GET_TX_CHANNEL_INFO(channel, tail);
669 return mask - ((head - tail) & mask);
673 * Write count bytes of data into channel, possibly wrapping in the ring buffer
675 static int qcom_smd_write_fifo(struct qcom_smd_channel *channel,
683 word_aligned = channel->info_word;
684 head = GET_TX_CHANNEL_INFO(channel, head);
686 len = min_t(size_t, count, channel->fifo_size - head);
688 smd_copy_to_fifo(channel->tx_fifo + head,
695 smd_copy_to_fifo(channel->tx_fifo,
702 head &= (channel->fifo_size - 1);
703 SET_TX_CHANNEL_INFO(channel, head, head);
709 * qcom_smd_send - write data to smd channel
710 * @channel: channel handle
711 * @data: buffer of data to write
712 * @len: number of bytes to write
714 * This is a blocking write of len bytes into the channel's tx ring buffer and
715 * signal the remote end. It will sleep until there is enough space available
716 * in the tx buffer, utilizing the fBLOCKREADINTR signaling mechanism to avoid
719 int qcom_smd_send(struct qcom_smd_channel *channel, const void *data, int len)
721 __le32 hdr[5] = { cpu_to_le32(len), };
722 int tlen = sizeof(hdr) + len;
725 /* Word aligned channels only accept word size aligned data */
726 if (channel->info_word && len % 4)
729 /* Reject packets that are too big */
730 if (tlen >= channel->fifo_size)
733 ret = mutex_lock_interruptible(&channel->tx_lock);
737 while (qcom_smd_get_tx_avail(channel) < tlen) {
738 if (channel->state != SMD_CHANNEL_OPENED) {
743 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 0);
745 ret = wait_event_interruptible(channel->fblockread_event,
746 qcom_smd_get_tx_avail(channel) >= tlen ||
747 channel->state != SMD_CHANNEL_OPENED);
751 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 1);
754 SET_TX_CHANNEL_FLAG(channel, fTAIL, 0);
756 qcom_smd_write_fifo(channel, hdr, sizeof(hdr));
757 qcom_smd_write_fifo(channel, data, len);
759 SET_TX_CHANNEL_FLAG(channel, fHEAD, 1);
761 /* Ensure ordering of channel info updates */
764 qcom_smd_signal_channel(channel);
767 mutex_unlock(&channel->tx_lock);
771 EXPORT_SYMBOL(qcom_smd_send);
773 static struct qcom_smd_device *to_smd_device(struct device *dev)
775 return container_of(dev, struct qcom_smd_device, dev);
778 static struct qcom_smd_driver *to_smd_driver(struct device *dev)
780 struct qcom_smd_device *qsdev = to_smd_device(dev);
782 return container_of(qsdev->dev.driver, struct qcom_smd_driver, driver);
785 static int qcom_smd_dev_match(struct device *dev, struct device_driver *drv)
787 struct qcom_smd_device *qsdev = to_smd_device(dev);
788 struct qcom_smd_driver *qsdrv = container_of(drv, struct qcom_smd_driver, driver);
789 const struct qcom_smd_id *match = qsdrv->smd_match_table;
790 const char *name = qsdev->channel->name;
793 while (match->name[0]) {
794 if (!strcmp(match->name, name))
800 return of_driver_match_device(dev, drv);
804 * Helper for opening a channel
806 static int qcom_smd_channel_open(struct qcom_smd_channel *channel,
812 * Packets are maximum 4k, but reduce if the fifo is smaller
814 bb_size = min(channel->fifo_size, SZ_4K);
815 channel->bounce_buffer = kmalloc(bb_size, GFP_KERNEL);
816 if (!channel->bounce_buffer)
819 qcom_smd_channel_set_callback(channel, cb);
820 qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENING);
821 qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENED);
827 * Helper for closing and resetting a channel
829 static void qcom_smd_channel_close(struct qcom_smd_channel *channel)
831 qcom_smd_channel_set_callback(channel, NULL);
833 kfree(channel->bounce_buffer);
834 channel->bounce_buffer = NULL;
836 qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);
837 qcom_smd_channel_reset(channel);
841 * Probe the smd client.
843 * The remote side have indicated that it want the channel to be opened, so
844 * complete the state handshake and probe our client driver.
846 static int qcom_smd_dev_probe(struct device *dev)
848 struct qcom_smd_device *qsdev = to_smd_device(dev);
849 struct qcom_smd_driver *qsdrv = to_smd_driver(dev);
850 struct qcom_smd_channel *channel = qsdev->channel;
853 ret = qcom_smd_channel_open(channel, qsdrv->callback);
857 ret = qsdrv->probe(qsdev);
861 qcom_smd_channel_resume(channel);
866 dev_err(&qsdev->dev, "probe failed\n");
868 qcom_smd_channel_close(channel);
873 * Remove the smd client.
875 * The channel is going away, for some reason, so remove the smd client and
876 * reset the channel state.
878 static int qcom_smd_dev_remove(struct device *dev)
880 struct qcom_smd_device *qsdev = to_smd_device(dev);
881 struct qcom_smd_driver *qsdrv = to_smd_driver(dev);
882 struct qcom_smd_channel *channel = qsdev->channel;
884 qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSING);
887 * Make sure we don't race with the code receiving data.
889 qcom_smd_channel_set_callback(channel, NULL);
891 /* Wake up any sleepers in qcom_smd_send() */
892 wake_up_interruptible(&channel->fblockread_event);
895 * We expect that the client might block in remove() waiting for any
896 * outstanding calls to qcom_smd_send() to wake up and finish.
899 qsdrv->remove(qsdev);
901 /* The client is now gone, close the primary channel */
902 qcom_smd_channel_close(channel);
903 channel->qsdev = NULL;
908 static struct bus_type qcom_smd_bus = {
910 .match = qcom_smd_dev_match,
911 .probe = qcom_smd_dev_probe,
912 .remove = qcom_smd_dev_remove,
916 * Release function for the qcom_smd_device object.
918 static void qcom_smd_release_device(struct device *dev)
920 struct qcom_smd_device *qsdev = to_smd_device(dev);
926 * Finds the device_node for the smd child interested in this channel.
928 static struct device_node *qcom_smd_match_channel(struct device_node *edge_node,
931 struct device_node *child;
936 for_each_available_child_of_node(edge_node, child) {
937 key = "qcom,smd-channels";
938 ret = of_property_read_string(child, key, &name);
942 if (strcmp(name, channel) == 0)
950 * Create a smd client device for channel that is being opened.
952 static int qcom_smd_create_device(struct qcom_smd_channel *channel)
954 struct qcom_smd_device *qsdev;
955 struct qcom_smd_edge *edge = channel->edge;
956 struct device_node *node;
962 dev_dbg(&edge->dev, "registering '%s'\n", channel->name);
964 qsdev = kzalloc(sizeof(*qsdev), GFP_KERNEL);
968 node = qcom_smd_match_channel(edge->of_node, channel->name);
969 dev_set_name(&qsdev->dev, "%s.%s",
971 node ? node->name : channel->name);
973 qsdev->dev.parent = &edge->dev;
974 qsdev->dev.bus = &qcom_smd_bus;
975 qsdev->dev.release = qcom_smd_release_device;
976 qsdev->dev.of_node = node;
978 qsdev->channel = channel;
980 channel->qsdev = qsdev;
982 ret = device_register(&qsdev->dev);
984 dev_err(&edge->dev, "device_register failed: %d\n", ret);
985 put_device(&qsdev->dev);
992 * Destroy a smd client device for a channel that's going away.
994 static void qcom_smd_destroy_device(struct qcom_smd_channel *channel)
998 BUG_ON(!channel->qsdev);
1000 dev = &channel->qsdev->dev;
1002 device_unregister(dev);
1003 of_node_put(dev->of_node);
1008 * qcom_smd_driver_register - register a smd driver
1009 * @qsdrv: qcom_smd_driver struct
1011 int qcom_smd_driver_register(struct qcom_smd_driver *qsdrv)
1013 qsdrv->driver.bus = &qcom_smd_bus;
1014 return driver_register(&qsdrv->driver);
1016 EXPORT_SYMBOL(qcom_smd_driver_register);
1018 void *qcom_smd_get_drvdata(struct qcom_smd_channel *channel)
1020 return channel->drvdata;
1022 EXPORT_SYMBOL(qcom_smd_get_drvdata);
1024 void qcom_smd_set_drvdata(struct qcom_smd_channel *channel, void *data)
1026 channel->drvdata = data;
1028 EXPORT_SYMBOL(qcom_smd_set_drvdata);
1031 * qcom_smd_driver_unregister - unregister a smd driver
1032 * @qsdrv: qcom_smd_driver struct
1034 void qcom_smd_driver_unregister(struct qcom_smd_driver *qsdrv)
1036 driver_unregister(&qsdrv->driver);
1038 EXPORT_SYMBOL(qcom_smd_driver_unregister);
1040 static struct qcom_smd_channel *
1041 qcom_smd_find_channel(struct qcom_smd_edge *edge, const char *name)
1043 struct qcom_smd_channel *channel;
1044 struct qcom_smd_channel *ret = NULL;
1045 unsigned long flags;
1048 spin_lock_irqsave(&edge->channels_lock, flags);
1049 list_for_each_entry(channel, &edge->channels, list) {
1050 if (strcmp(channel->name, name))
1053 state = GET_RX_CHANNEL_INFO(channel, state);
1054 if (state != SMD_CHANNEL_OPENING &&
1055 state != SMD_CHANNEL_OPENED)
1061 spin_unlock_irqrestore(&edge->channels_lock, flags);
1067 * qcom_smd_open_channel() - claim additional channels on the same edge
1068 * @sdev: smd_device handle
1069 * @name: channel name
1070 * @cb: callback method to use for incoming data
1072 * Returns a channel handle on success, or -EPROBE_DEFER if the channel isn't
1075 * Any channels returned must be closed with a call to qcom_smd_close_channel()
1077 struct qcom_smd_channel *qcom_smd_open_channel(struct qcom_smd_channel *parent,
1081 struct qcom_smd_channel *channel;
1082 struct qcom_smd_device *sdev = parent->qsdev;
1083 struct qcom_smd_edge *edge = parent->edge;
1086 /* Wait up to HZ for the channel to appear */
1087 ret = wait_event_interruptible_timeout(edge->new_channel_event,
1088 (channel = qcom_smd_find_channel(edge, name)) != NULL,
1091 return ERR_PTR(-ETIMEDOUT);
1093 if (channel->state != SMD_CHANNEL_CLOSED) {
1094 dev_err(&sdev->dev, "channel %s is busy\n", channel->name);
1095 return ERR_PTR(-EBUSY);
1098 channel->qsdev = sdev;
1099 ret = qcom_smd_channel_open(channel, cb);
1101 channel->qsdev = NULL;
1102 return ERR_PTR(ret);
1107 EXPORT_SYMBOL(qcom_smd_open_channel);
1110 * qcom_smd_close_channel() - close an additionally opened channel
1111 * @channel: channel handle, returned by qcom_smd_open_channel()
1113 void qcom_smd_close_channel(struct qcom_smd_channel *channel)
1115 qcom_smd_channel_close(channel);
1116 channel->qsdev = NULL;
1118 EXPORT_SYMBOL(qcom_smd_close_channel);
1121 * Allocate the qcom_smd_channel object for a newly found smd channel,
1122 * retrieving and validating the smem items involved.
1124 static struct qcom_smd_channel *qcom_smd_create_channel(struct qcom_smd_edge *edge,
1125 unsigned smem_info_item,
1126 unsigned smem_fifo_item,
1129 struct qcom_smd_channel *channel;
1136 channel = devm_kzalloc(&edge->dev, sizeof(*channel), GFP_KERNEL);
1138 return ERR_PTR(-ENOMEM);
1140 channel->edge = edge;
1141 channel->name = devm_kstrdup(&edge->dev, name, GFP_KERNEL);
1143 return ERR_PTR(-ENOMEM);
1145 mutex_init(&channel->tx_lock);
1146 spin_lock_init(&channel->recv_lock);
1147 init_waitqueue_head(&channel->fblockread_event);
1149 info = qcom_smem_get(edge->remote_pid, smem_info_item, &info_size);
1151 ret = PTR_ERR(info);
1152 goto free_name_and_channel;
1156 * Use the size of the item to figure out which channel info struct to
1159 if (info_size == 2 * sizeof(struct smd_channel_info_word)) {
1160 channel->info_word = info;
1161 } else if (info_size == 2 * sizeof(struct smd_channel_info)) {
1162 channel->info = info;
1165 "channel info of size %zu not supported\n", info_size);
1167 goto free_name_and_channel;
1170 fifo_base = qcom_smem_get(edge->remote_pid, smem_fifo_item, &fifo_size);
1171 if (IS_ERR(fifo_base)) {
1172 ret = PTR_ERR(fifo_base);
1173 goto free_name_and_channel;
1176 /* The channel consist of a rx and tx fifo of equal size */
1179 dev_dbg(&edge->dev, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1180 name, info_size, fifo_size);
1182 channel->tx_fifo = fifo_base;
1183 channel->rx_fifo = fifo_base + fifo_size;
1184 channel->fifo_size = fifo_size;
1186 qcom_smd_channel_reset(channel);
1190 free_name_and_channel:
1191 devm_kfree(&edge->dev, channel->name);
1192 devm_kfree(&edge->dev, channel);
1194 return ERR_PTR(ret);
1198 * Scans the allocation table for any newly allocated channels, calls
1199 * qcom_smd_create_channel() to create representations of these and add
1200 * them to the edge's list of channels.
1202 static void qcom_channel_scan_worker(struct work_struct *work)
1204 struct qcom_smd_edge *edge = container_of(work, struct qcom_smd_edge, scan_work);
1205 struct qcom_smd_alloc_entry *alloc_tbl;
1206 struct qcom_smd_alloc_entry *entry;
1207 struct qcom_smd_channel *channel;
1208 unsigned long flags;
1215 for (tbl = 0; tbl < SMD_ALLOC_TBL_COUNT; tbl++) {
1216 alloc_tbl = qcom_smem_get(edge->remote_pid,
1217 smem_items[tbl].alloc_tbl_id, NULL);
1218 if (IS_ERR(alloc_tbl))
1221 for (i = 0; i < SMD_ALLOC_TBL_SIZE; i++) {
1222 entry = &alloc_tbl[i];
1223 eflags = le32_to_cpu(entry->flags);
1224 if (test_bit(i, edge->allocated[tbl]))
1227 if (entry->ref_count == 0)
1230 if (!entry->name[0])
1233 if (!(eflags & SMD_CHANNEL_FLAGS_PACKET))
1236 if ((eflags & SMD_CHANNEL_FLAGS_EDGE_MASK) != edge->edge_id)
1239 cid = le32_to_cpu(entry->cid);
1240 info_id = smem_items[tbl].info_base_id + cid;
1241 fifo_id = smem_items[tbl].fifo_base_id + cid;
1243 channel = qcom_smd_create_channel(edge, info_id, fifo_id, entry->name);
1244 if (IS_ERR(channel))
1247 spin_lock_irqsave(&edge->channels_lock, flags);
1248 list_add(&channel->list, &edge->channels);
1249 spin_unlock_irqrestore(&edge->channels_lock, flags);
1251 dev_dbg(&edge->dev, "new channel found: '%s'\n", channel->name);
1252 set_bit(i, edge->allocated[tbl]);
1254 wake_up_interruptible(&edge->new_channel_event);
1258 schedule_work(&edge->state_work);
1262 * This per edge worker scans smem for any new channels and register these. It
1263 * then scans all registered channels for state changes that should be handled
1264 * by creating or destroying smd client devices for the registered channels.
1266 * LOCKING: edge->channels_lock only needs to cover the list operations, as the
1267 * worker is killed before any channels are deallocated
1269 static void qcom_channel_state_worker(struct work_struct *work)
1271 struct qcom_smd_channel *channel;
1272 struct qcom_smd_edge *edge = container_of(work,
1273 struct qcom_smd_edge,
1275 unsigned remote_state;
1276 unsigned long flags;
1279 * Register a device for any closed channel where the remote processor
1280 * is showing interest in opening the channel.
1282 spin_lock_irqsave(&edge->channels_lock, flags);
1283 list_for_each_entry(channel, &edge->channels, list) {
1284 if (channel->state != SMD_CHANNEL_CLOSED)
1287 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1288 if (remote_state != SMD_CHANNEL_OPENING &&
1289 remote_state != SMD_CHANNEL_OPENED)
1292 spin_unlock_irqrestore(&edge->channels_lock, flags);
1293 qcom_smd_create_device(channel);
1294 spin_lock_irqsave(&edge->channels_lock, flags);
1298 * Unregister the device for any channel that is opened where the
1299 * remote processor is closing the channel.
1301 list_for_each_entry(channel, &edge->channels, list) {
1302 if (channel->state != SMD_CHANNEL_OPENING &&
1303 channel->state != SMD_CHANNEL_OPENED)
1306 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1307 if (remote_state == SMD_CHANNEL_OPENING ||
1308 remote_state == SMD_CHANNEL_OPENED)
1311 spin_unlock_irqrestore(&edge->channels_lock, flags);
1312 qcom_smd_destroy_device(channel);
1313 spin_lock_irqsave(&edge->channels_lock, flags);
1315 spin_unlock_irqrestore(&edge->channels_lock, flags);
1319 * Parses an of_node describing an edge.
1321 static int qcom_smd_parse_edge(struct device *dev,
1322 struct device_node *node,
1323 struct qcom_smd_edge *edge)
1325 struct device_node *syscon_np;
1330 INIT_LIST_HEAD(&edge->channels);
1331 spin_lock_init(&edge->channels_lock);
1333 INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
1334 INIT_WORK(&edge->state_work, qcom_channel_state_worker);
1336 edge->of_node = of_node_get(node);
1338 key = "qcom,smd-edge";
1339 ret = of_property_read_u32(node, key, &edge->edge_id);
1341 dev_err(dev, "edge missing %s property\n", key);
1345 edge->remote_pid = QCOM_SMEM_HOST_ANY;
1346 key = "qcom,remote-pid";
1347 of_property_read_u32(node, key, &edge->remote_pid);
1349 syscon_np = of_parse_phandle(node, "qcom,ipc", 0);
1351 dev_err(dev, "no qcom,ipc node\n");
1355 edge->ipc_regmap = syscon_node_to_regmap(syscon_np);
1356 if (IS_ERR(edge->ipc_regmap))
1357 return PTR_ERR(edge->ipc_regmap);
1360 ret = of_property_read_u32_index(node, key, 1, &edge->ipc_offset);
1362 dev_err(dev, "no offset in %s\n", key);
1366 ret = of_property_read_u32_index(node, key, 2, &edge->ipc_bit);
1368 dev_err(dev, "no bit in %s\n", key);
1372 irq = irq_of_parse_and_map(node, 0);
1374 dev_err(dev, "required smd interrupt missing\n");
1378 ret = devm_request_irq(dev, irq,
1379 qcom_smd_edge_intr, IRQF_TRIGGER_RISING,
1382 dev_err(dev, "failed to request smd irq\n");
1392 * Release function for an edge.
1393 * Reset the state of each associated channel and free the edge context.
1395 static void qcom_smd_edge_release(struct device *dev)
1397 struct qcom_smd_channel *channel;
1398 struct qcom_smd_edge *edge = to_smd_edge(dev);
1400 list_for_each_entry(channel, &edge->channels, list) {
1401 SET_RX_CHANNEL_INFO(channel, state, SMD_CHANNEL_CLOSED);
1402 SET_RX_CHANNEL_INFO(channel, head, 0);
1403 SET_RX_CHANNEL_INFO(channel, tail, 0);
1410 * qcom_smd_register_edge() - register an edge based on an device_node
1411 * @parent: parent device for the edge
1412 * @node: device_node describing the edge
1414 * Returns an edge reference, or negative ERR_PTR() on failure.
1416 struct qcom_smd_edge *qcom_smd_register_edge(struct device *parent,
1417 struct device_node *node)
1419 struct qcom_smd_edge *edge;
1422 edge = kzalloc(sizeof(*edge), GFP_KERNEL);
1424 return ERR_PTR(-ENOMEM);
1426 init_waitqueue_head(&edge->new_channel_event);
1428 edge->dev.parent = parent;
1429 edge->dev.release = qcom_smd_edge_release;
1430 dev_set_name(&edge->dev, "%s:%s", dev_name(parent), node->name);
1431 ret = device_register(&edge->dev);
1433 pr_err("failed to register smd edge\n");
1434 return ERR_PTR(ret);
1437 ret = qcom_smd_parse_edge(&edge->dev, node, edge);
1439 dev_err(&edge->dev, "failed to parse smd edge\n");
1440 goto unregister_dev;
1443 schedule_work(&edge->scan_work);
1448 put_device(&edge->dev);
1449 return ERR_PTR(ret);
1451 EXPORT_SYMBOL(qcom_smd_register_edge);
1453 static int qcom_smd_remove_device(struct device *dev, void *data)
1455 device_unregister(dev);
1456 of_node_put(dev->of_node);
1463 * qcom_smd_unregister_edge() - release an edge and its children
1464 * @edge: edge reference acquired from qcom_smd_register_edge
1466 int qcom_smd_unregister_edge(struct qcom_smd_edge *edge)
1470 disable_irq(edge->irq);
1471 cancel_work_sync(&edge->scan_work);
1472 cancel_work_sync(&edge->state_work);
1474 ret = device_for_each_child(&edge->dev, NULL, qcom_smd_remove_device);
1476 dev_warn(&edge->dev, "can't remove smd device: %d\n", ret);
1478 device_unregister(&edge->dev);
1482 EXPORT_SYMBOL(qcom_smd_unregister_edge);
1484 static int qcom_smd_probe(struct platform_device *pdev)
1486 struct device_node *node;
1490 p = qcom_smem_get(QCOM_SMEM_HOST_ANY, smem_items[0].alloc_tbl_id, NULL);
1491 if (PTR_ERR(p) == -EPROBE_DEFER)
1494 for_each_available_child_of_node(pdev->dev.of_node, node)
1495 qcom_smd_register_edge(&pdev->dev, node);
1500 static int qcom_smd_remove_edge(struct device *dev, void *data)
1502 struct qcom_smd_edge *edge = to_smd_edge(dev);
1504 return qcom_smd_unregister_edge(edge);
1508 * Shut down all smd clients by making sure that each edge stops processing
1509 * events and scanning for new channels, then call destroy on the devices.
1511 static int qcom_smd_remove(struct platform_device *pdev)
1515 ret = device_for_each_child(&pdev->dev, NULL, qcom_smd_remove_edge);
1517 dev_warn(&pdev->dev, "can't remove smd device: %d\n", ret);
1522 static const struct of_device_id qcom_smd_of_match[] = {
1523 { .compatible = "qcom,smd" },
1526 MODULE_DEVICE_TABLE(of, qcom_smd_of_match);
1528 static struct platform_driver qcom_smd_driver = {
1529 .probe = qcom_smd_probe,
1530 .remove = qcom_smd_remove,
1533 .of_match_table = qcom_smd_of_match,
1537 static int __init qcom_smd_init(void)
1541 ret = bus_register(&qcom_smd_bus);
1543 pr_err("failed to register smd bus: %d\n", ret);
1547 return platform_driver_register(&qcom_smd_driver);
1549 postcore_initcall(qcom_smd_init);
1551 static void __exit qcom_smd_exit(void)
1553 platform_driver_unregister(&qcom_smd_driver);
1554 bus_unregister(&qcom_smd_bus);
1556 module_exit(qcom_smd_exit);
1558 MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
1559 MODULE_DESCRIPTION("Qualcomm Shared Memory Driver");
1560 MODULE_LICENSE("GPL v2");