1
2
3
4
5
6
7
8
9
10
11
12
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/smd.h>
26#include <linux/soc/qcom/smem.h>
27#include <linux/wait.h>
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67struct smd_channel_info;
68struct smd_channel_info_pair;
69struct smd_channel_info_word;
70struct smd_channel_info_word_pair;
71
72#define SMD_ALLOC_TBL_COUNT 2
73#define SMD_ALLOC_TBL_SIZE 64
74
75
76
77
78
79static const struct {
80 unsigned alloc_tbl_id;
81 unsigned info_base_id;
82 unsigned fifo_base_id;
83} smem_items[SMD_ALLOC_TBL_COUNT] = {
84 {
85 .alloc_tbl_id = 13,
86 .info_base_id = 14,
87 .fifo_base_id = 338
88 },
89 {
90 .alloc_tbl_id = 266,
91 .info_base_id = 138,
92 .fifo_base_id = 202,
93 },
94};
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113struct qcom_smd_edge {
114 struct qcom_smd *smd;
115 struct device_node *of_node;
116 unsigned edge_id;
117 unsigned remote_pid;
118
119 int irq;
120
121 struct regmap *ipc_regmap;
122 int ipc_offset;
123 int ipc_bit;
124
125 struct list_head channels;
126 spinlock_t channels_lock;
127
128 DECLARE_BITMAP(allocated[SMD_ALLOC_TBL_COUNT], SMD_ALLOC_TBL_SIZE);
129
130 unsigned smem_available;
131
132 wait_queue_head_t new_channel_event;
133
134 struct work_struct scan_work;
135 struct work_struct state_work;
136};
137
138
139
140
141enum smd_channel_state {
142 SMD_CHANNEL_CLOSED,
143 SMD_CHANNEL_OPENING,
144 SMD_CHANNEL_OPENED,
145 SMD_CHANNEL_FLUSHING,
146 SMD_CHANNEL_CLOSING,
147 SMD_CHANNEL_RESET,
148 SMD_CHANNEL_RESET_OPENING
149};
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171struct qcom_smd_channel {
172 struct qcom_smd_edge *edge;
173
174 struct qcom_smd_device *qsdev;
175
176 char *name;
177 enum smd_channel_state state;
178 enum smd_channel_state remote_state;
179
180 struct smd_channel_info_pair *info;
181 struct smd_channel_info_word_pair *info_word;
182
183 struct mutex tx_lock;
184 wait_queue_head_t fblockread_event;
185
186 void *tx_fifo;
187 void *rx_fifo;
188 int fifo_size;
189
190 void *bounce_buffer;
191 qcom_smd_cb_t cb;
192
193 spinlock_t recv_lock;
194
195 int pkt_size;
196
197 void *drvdata;
198
199 struct list_head list;
200 struct list_head dev_list;
201};
202
203
204
205
206
207
208
209struct qcom_smd {
210 struct device *dev;
211
212 unsigned num_edges;
213 struct qcom_smd_edge edges[0];
214};
215
216
217
218
219struct smd_channel_info {
220 __le32 state;
221 u8 fDSR;
222 u8 fCTS;
223 u8 fCD;
224 u8 fRI;
225 u8 fHEAD;
226 u8 fTAIL;
227 u8 fSTATE;
228 u8 fBLOCKREADINTR;
229 __le32 tail;
230 __le32 head;
231};
232
233struct smd_channel_info_pair {
234 struct smd_channel_info tx;
235 struct smd_channel_info rx;
236};
237
238
239
240
241struct smd_channel_info_word {
242 __le32 state;
243 __le32 fDSR;
244 __le32 fCTS;
245 __le32 fCD;
246 __le32 fRI;
247 __le32 fHEAD;
248 __le32 fTAIL;
249 __le32 fSTATE;
250 __le32 fBLOCKREADINTR;
251 __le32 tail;
252 __le32 head;
253};
254
255struct smd_channel_info_word_pair {
256 struct smd_channel_info_word tx;
257 struct smd_channel_info_word rx;
258};
259
260#define GET_RX_CHANNEL_FLAG(channel, param) \
261 ({ \
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; \
266 })
267
268#define GET_RX_CHANNEL_INFO(channel, param) \
269 ({ \
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); \
274 })
275
276#define SET_RX_CHANNEL_FLAG(channel, param, value) \
277 ({ \
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); \
281 else \
282 channel->info->rx.param = value; \
283 })
284
285#define SET_RX_CHANNEL_INFO(channel, param, value) \
286 ({ \
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); \
290 else \
291 channel->info->rx.param = cpu_to_le32(value); \
292 })
293
294#define GET_TX_CHANNEL_FLAG(channel, param) \
295 ({ \
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; \
300 })
301
302#define GET_TX_CHANNEL_INFO(channel, param) \
303 ({ \
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); \
308 })
309
310#define SET_TX_CHANNEL_FLAG(channel, param, value) \
311 ({ \
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); \
315 else \
316 channel->info->tx.param = value; \
317 })
318
319#define SET_TX_CHANNEL_INFO(channel, param, value) \
320 ({ \
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); \
324 else \
325 channel->info->tx.param = cpu_to_le32(value); \
326 })
327
328
329
330
331
332
333
334
335struct qcom_smd_alloc_entry {
336 u8 name[20];
337 __le32 cid;
338 __le32 flags;
339 __le32 ref_count;
340} __packed;
341
342#define SMD_CHANNEL_FLAGS_EDGE_MASK 0xff
343#define SMD_CHANNEL_FLAGS_STREAM BIT(8)
344#define SMD_CHANNEL_FLAGS_PACKET BIT(9)
345
346
347
348
349
350#define SMD_PACKET_HEADER_LEN 20
351
352
353
354
355static void qcom_smd_signal_channel(struct qcom_smd_channel *channel)
356{
357 struct qcom_smd_edge *edge = channel->edge;
358
359 regmap_write(edge->ipc_regmap, edge->ipc_offset, BIT(edge->ipc_bit));
360}
361
362
363
364
365static void qcom_smd_channel_reset(struct qcom_smd_channel *channel)
366{
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);
378
379 qcom_smd_signal_channel(channel);
380
381 channel->state = SMD_CHANNEL_CLOSED;
382 channel->pkt_size = 0;
383}
384
385
386
387
388static void qcom_smd_channel_set_callback(struct qcom_smd_channel *channel,
389 qcom_smd_cb_t cb)
390{
391 unsigned long flags;
392
393 spin_lock_irqsave(&channel->recv_lock, flags);
394 channel->cb = cb;
395 spin_unlock_irqrestore(&channel->recv_lock, flags);
396};
397
398
399
400
401static size_t qcom_smd_channel_get_rx_avail(struct qcom_smd_channel *channel)
402{
403 unsigned head;
404 unsigned tail;
405
406 head = GET_RX_CHANNEL_INFO(channel, head);
407 tail = GET_RX_CHANNEL_INFO(channel, tail);
408
409 return (head - tail) & (channel->fifo_size - 1);
410}
411
412
413
414
415static void qcom_smd_channel_set_state(struct qcom_smd_channel *channel,
416 int state)
417{
418 struct qcom_smd_edge *edge = channel->edge;
419 bool is_open = state == SMD_CHANNEL_OPENED;
420
421 if (channel->state == state)
422 return;
423
424 dev_dbg(edge->smd->dev, "set_state(%s, %d)\n", channel->name, state);
425
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);
429
430 SET_TX_CHANNEL_INFO(channel, state, state);
431 SET_TX_CHANNEL_FLAG(channel, fSTATE, 1);
432
433 channel->state = state;
434 qcom_smd_signal_channel(channel);
435}
436
437
438
439
440static void smd_copy_to_fifo(void __iomem *dst,
441 const void *src,
442 size_t count,
443 bool word_aligned)
444{
445 if (word_aligned) {
446 __iowrite32_copy(dst, src, count / sizeof(u32));
447 } else {
448 memcpy_toio(dst, src, count);
449 }
450}
451
452
453
454
455static void smd_copy_from_fifo(void *dst,
456 const void __iomem *src,
457 size_t count,
458 bool word_aligned)
459{
460 if (word_aligned) {
461 __ioread32_copy(dst, src, count / sizeof(u32));
462 } else {
463 memcpy_fromio(dst, src, count);
464 }
465}
466
467
468
469
470
471static size_t qcom_smd_channel_peek(struct qcom_smd_channel *channel,
472 void *buf, size_t count)
473{
474 bool word_aligned;
475 unsigned tail;
476 size_t len;
477
478 word_aligned = channel->info_word;
479 tail = GET_RX_CHANNEL_INFO(channel, tail);
480
481 len = min_t(size_t, count, channel->fifo_size - tail);
482 if (len) {
483 smd_copy_from_fifo(buf,
484 channel->rx_fifo + tail,
485 len,
486 word_aligned);
487 }
488
489 if (len != count) {
490 smd_copy_from_fifo(buf + len,
491 channel->rx_fifo,
492 count - len,
493 word_aligned);
494 }
495
496 return count;
497}
498
499
500
501
502static void qcom_smd_channel_advance(struct qcom_smd_channel *channel,
503 size_t count)
504{
505 unsigned tail;
506
507 tail = GET_RX_CHANNEL_INFO(channel, tail);
508 tail += count;
509 tail &= (channel->fifo_size - 1);
510 SET_RX_CHANNEL_INFO(channel, tail, tail);
511}
512
513
514
515
516static int qcom_smd_channel_recv_single(struct qcom_smd_channel *channel)
517{
518 unsigned tail;
519 size_t len;
520 void *ptr;
521 int ret;
522
523 if (!channel->cb)
524 return 0;
525
526 tail = GET_RX_CHANNEL_INFO(channel, tail);
527
528
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);
532 } else {
533 ptr = channel->rx_fifo + tail;
534 len = channel->pkt_size;
535 }
536
537 ret = channel->cb(channel, ptr, len);
538 if (ret < 0)
539 return ret;
540
541
542 qcom_smd_channel_advance(channel, len);
543
544 channel->pkt_size = 0;
545
546 return 0;
547}
548
549
550
551
552static bool qcom_smd_channel_intr(struct qcom_smd_channel *channel)
553{
554 bool need_state_scan = false;
555 int remote_state;
556 __le32 pktlen;
557 int avail;
558 int ret;
559
560
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;
565 }
566
567 SET_RX_CHANNEL_FLAG(channel, fSTATE, 0);
568
569
570 if (!GET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR))
571 wake_up_interruptible(&channel->fblockread_event);
572
573
574 if (channel->state != SMD_CHANNEL_OPENED)
575 goto out;
576
577
578 SET_RX_CHANNEL_FLAG(channel, fHEAD, 0);
579
580
581 for (;;) {
582 avail = qcom_smd_channel_get_rx_avail(channel);
583
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);
590 if (ret)
591 break;
592 } else {
593 break;
594 }
595 }
596
597
598 SET_RX_CHANNEL_FLAG(channel, fTAIL, 1);
599
600
601 if (!GET_RX_CHANNEL_FLAG(channel, fBLOCKREADINTR)) {
602
603 wmb();
604
605 qcom_smd_signal_channel(channel);
606 }
607
608out:
609 return need_state_scan;
610}
611
612
613
614
615
616static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
617{
618 struct qcom_smd_edge *edge = data;
619 struct qcom_smd_channel *channel;
620 unsigned available;
621 bool kick_scanner = false;
622 bool kick_state = false;
623
624
625
626
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);
632 }
633 spin_unlock(&edge->channels_lock);
634
635
636
637
638
639
640 available = qcom_smem_get_free_space(edge->remote_pid);
641 if (available != edge->smem_available) {
642 edge->smem_available = available;
643 kick_scanner = true;
644 }
645
646 if (kick_scanner)
647 schedule_work(&edge->scan_work);
648 if (kick_state)
649 schedule_work(&edge->state_work);
650
651 return IRQ_HANDLED;
652}
653
654
655
656
657
658
659static void qcom_smd_channel_resume(struct qcom_smd_channel *channel)
660{
661 unsigned long flags;
662
663 spin_lock_irqsave(&channel->recv_lock, flags);
664 qcom_smd_channel_intr(channel);
665 spin_unlock_irqrestore(&channel->recv_lock, flags);
666}
667
668
669
670
671static size_t qcom_smd_get_tx_avail(struct qcom_smd_channel *channel)
672{
673 unsigned head;
674 unsigned tail;
675 unsigned mask = channel->fifo_size - 1;
676
677 head = GET_TX_CHANNEL_INFO(channel, head);
678 tail = GET_TX_CHANNEL_INFO(channel, tail);
679
680 return mask - ((head - tail) & mask);
681}
682
683
684
685
686static int qcom_smd_write_fifo(struct qcom_smd_channel *channel,
687 const void *data,
688 size_t count)
689{
690 bool word_aligned;
691 unsigned head;
692 size_t len;
693
694 word_aligned = channel->info_word;
695 head = GET_TX_CHANNEL_INFO(channel, head);
696
697 len = min_t(size_t, count, channel->fifo_size - head);
698 if (len) {
699 smd_copy_to_fifo(channel->tx_fifo + head,
700 data,
701 len,
702 word_aligned);
703 }
704
705 if (len != count) {
706 smd_copy_to_fifo(channel->tx_fifo,
707 data + len,
708 count - len,
709 word_aligned);
710 }
711
712 head += count;
713 head &= (channel->fifo_size - 1);
714 SET_TX_CHANNEL_INFO(channel, head, head);
715
716 return count;
717}
718
719
720
721
722
723
724
725
726
727
728
729
730int qcom_smd_send(struct qcom_smd_channel *channel, const void *data, int len)
731{
732 __le32 hdr[5] = { cpu_to_le32(len), };
733 int tlen = sizeof(hdr) + len;
734 int ret;
735
736
737 if (channel->info_word && len % 4)
738 return -EINVAL;
739
740
741 if (tlen >= channel->fifo_size)
742 return -EINVAL;
743
744 ret = mutex_lock_interruptible(&channel->tx_lock);
745 if (ret)
746 return ret;
747
748 while (qcom_smd_get_tx_avail(channel) < tlen) {
749 if (channel->state != SMD_CHANNEL_OPENED) {
750 ret = -EPIPE;
751 goto out;
752 }
753
754 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 0);
755
756 ret = wait_event_interruptible(channel->fblockread_event,
757 qcom_smd_get_tx_avail(channel) >= tlen ||
758 channel->state != SMD_CHANNEL_OPENED);
759 if (ret)
760 goto out;
761
762 SET_TX_CHANNEL_FLAG(channel, fBLOCKREADINTR, 1);
763 }
764
765 SET_TX_CHANNEL_FLAG(channel, fTAIL, 0);
766
767 qcom_smd_write_fifo(channel, hdr, sizeof(hdr));
768 qcom_smd_write_fifo(channel, data, len);
769
770 SET_TX_CHANNEL_FLAG(channel, fHEAD, 1);
771
772
773 wmb();
774
775 qcom_smd_signal_channel(channel);
776
777out:
778 mutex_unlock(&channel->tx_lock);
779
780 return ret;
781}
782EXPORT_SYMBOL(qcom_smd_send);
783
784static struct qcom_smd_device *to_smd_device(struct device *dev)
785{
786 return container_of(dev, struct qcom_smd_device, dev);
787}
788
789static struct qcom_smd_driver *to_smd_driver(struct device *dev)
790{
791 struct qcom_smd_device *qsdev = to_smd_device(dev);
792
793 return container_of(qsdev->dev.driver, struct qcom_smd_driver, driver);
794}
795
796static int qcom_smd_dev_match(struct device *dev, struct device_driver *drv)
797{
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;
802
803 if (match) {
804 while (match->name[0]) {
805 if (!strcmp(match->name, name))
806 return 1;
807 match++;
808 }
809 }
810
811 return of_driver_match_device(dev, drv);
812}
813
814
815
816
817static int qcom_smd_channel_open(struct qcom_smd_channel *channel,
818 qcom_smd_cb_t cb)
819{
820 size_t bb_size;
821
822
823
824
825 bb_size = min(channel->fifo_size, SZ_4K);
826 channel->bounce_buffer = kmalloc(bb_size, GFP_KERNEL);
827 if (!channel->bounce_buffer)
828 return -ENOMEM;
829
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);
833
834 return 0;
835}
836
837
838
839
840static void qcom_smd_channel_close(struct qcom_smd_channel *channel)
841{
842 qcom_smd_channel_set_callback(channel, NULL);
843
844 kfree(channel->bounce_buffer);
845 channel->bounce_buffer = NULL;
846
847 qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);
848 qcom_smd_channel_reset(channel);
849}
850
851
852
853
854
855
856
857static int qcom_smd_dev_probe(struct device *dev)
858{
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;
862 int ret;
863
864 ret = qcom_smd_channel_open(channel, qsdrv->callback);
865 if (ret)
866 return ret;
867
868 ret = qsdrv->probe(qsdev);
869 if (ret)
870 goto err;
871
872 qcom_smd_channel_resume(channel);
873
874 return 0;
875
876err:
877 dev_err(&qsdev->dev, "probe failed\n");
878
879 qcom_smd_channel_close(channel);
880 return ret;
881}
882
883
884
885
886
887
888
889static int qcom_smd_dev_remove(struct device *dev)
890{
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;
896
897 qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSING);
898
899
900
901
902 qcom_smd_channel_set_callback(channel, NULL);
903
904
905 wake_up_interruptible(&channel->fblockread_event);
906
907
908
909
910
911 if (qsdrv->remove)
912 qsdrv->remove(qsdev);
913
914
915
916
917
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);
921 ch->qsdev = NULL;
922 }
923
924 return 0;
925}
926
927static struct bus_type qcom_smd_bus = {
928 .name = "qcom_smd",
929 .match = qcom_smd_dev_match,
930 .probe = qcom_smd_dev_probe,
931 .remove = qcom_smd_dev_remove,
932};
933
934
935
936
937static void qcom_smd_release_device(struct device *dev)
938{
939 struct qcom_smd_device *qsdev = to_smd_device(dev);
940
941 kfree(qsdev);
942}
943
944
945
946
947static struct device_node *qcom_smd_match_channel(struct device_node *edge_node,
948 const char *channel)
949{
950 struct device_node *child;
951 const char *name;
952 const char *key;
953 int ret;
954
955 for_each_available_child_of_node(edge_node, child) {
956 key = "qcom,smd-channels";
957 ret = of_property_read_string(child, key, &name);
958 if (ret)
959 continue;
960
961 if (strcmp(name, channel) == 0)
962 return child;
963 }
964
965 return NULL;
966}
967
968
969
970
971static int qcom_smd_create_device(struct qcom_smd_channel *channel)
972{
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;
977 int ret;
978
979 if (channel->qsdev)
980 return -EEXIST;
981
982 dev_dbg(smd->dev, "registering '%s'\n", channel->name);
983
984 qsdev = kzalloc(sizeof(*qsdev), GFP_KERNEL);
985 if (!qsdev)
986 return -ENOMEM;
987
988 node = qcom_smd_match_channel(edge->of_node, channel->name);
989 dev_set_name(&qsdev->dev, "%s.%s",
990 edge->of_node->name,
991 node ? node->name : channel->name);
992
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;
997
998 qsdev->channel = channel;
999
1000 channel->qsdev = qsdev;
1001
1002 ret = device_register(&qsdev->dev);
1003 if (ret) {
1004 dev_err(smd->dev, "device_register failed: %d\n", ret);
1005 put_device(&qsdev->dev);
1006 }
1007
1008 return ret;
1009}
1010
1011
1012
1013
1014static void qcom_smd_destroy_device(struct qcom_smd_channel *channel)
1015{
1016 struct device *dev;
1017
1018 BUG_ON(!channel->qsdev);
1019
1020 dev = &channel->qsdev->dev;
1021
1022 device_unregister(dev);
1023 of_node_put(dev->of_node);
1024 put_device(dev);
1025}
1026
1027
1028
1029
1030
1031int qcom_smd_driver_register(struct qcom_smd_driver *qsdrv)
1032{
1033 qsdrv->driver.bus = &qcom_smd_bus;
1034 return driver_register(&qsdrv->driver);
1035}
1036EXPORT_SYMBOL(qcom_smd_driver_register);
1037
1038void *qcom_smd_get_drvdata(struct qcom_smd_channel *channel)
1039{
1040 return channel->drvdata;
1041}
1042EXPORT_SYMBOL(qcom_smd_get_drvdata);
1043
1044void qcom_smd_set_drvdata(struct qcom_smd_channel *channel, void *data)
1045{
1046 channel->drvdata = data;
1047}
1048EXPORT_SYMBOL(qcom_smd_set_drvdata);
1049
1050
1051
1052
1053
1054void qcom_smd_driver_unregister(struct qcom_smd_driver *qsdrv)
1055{
1056 driver_unregister(&qsdrv->driver);
1057}
1058EXPORT_SYMBOL(qcom_smd_driver_unregister);
1059
1060static struct qcom_smd_channel *
1061qcom_smd_find_channel(struct qcom_smd_edge *edge, const char *name)
1062{
1063 struct qcom_smd_channel *channel;
1064 struct qcom_smd_channel *ret = NULL;
1065 unsigned long flags;
1066 unsigned state;
1067
1068 spin_lock_irqsave(&edge->channels_lock, flags);
1069 list_for_each_entry(channel, &edge->channels, list) {
1070 if (strcmp(channel->name, name))
1071 continue;
1072
1073 state = GET_RX_CHANNEL_INFO(channel, state);
1074 if (state != SMD_CHANNEL_OPENING &&
1075 state != SMD_CHANNEL_OPENED)
1076 continue;
1077
1078 ret = channel;
1079 break;
1080 }
1081 spin_unlock_irqrestore(&edge->channels_lock, flags);
1082
1083 return ret;
1084}
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095struct qcom_smd_channel *qcom_smd_open_channel(struct qcom_smd_channel *parent,
1096 const char *name,
1097 qcom_smd_cb_t cb)
1098{
1099 struct qcom_smd_channel *channel;
1100 struct qcom_smd_device *sdev = parent->qsdev;
1101 struct qcom_smd_edge *edge = parent->edge;
1102 int ret;
1103
1104
1105 ret = wait_event_interruptible_timeout(edge->new_channel_event,
1106 (channel = qcom_smd_find_channel(edge, name)) != NULL,
1107 HZ);
1108 if (!ret)
1109 return ERR_PTR(-ETIMEDOUT);
1110
1111 if (channel->state != SMD_CHANNEL_CLOSED) {
1112 dev_err(&sdev->dev, "channel %s is busy\n", channel->name);
1113 return ERR_PTR(-EBUSY);
1114 }
1115
1116 channel->qsdev = sdev;
1117 ret = qcom_smd_channel_open(channel, cb);
1118 if (ret) {
1119 channel->qsdev = NULL;
1120 return ERR_PTR(ret);
1121 }
1122
1123
1124
1125
1126 list_add_tail(&channel->dev_list, &sdev->channel->dev_list);
1127
1128 return channel;
1129}
1130EXPORT_SYMBOL(qcom_smd_open_channel);
1131
1132
1133
1134
1135
1136static struct qcom_smd_channel *qcom_smd_create_channel(struct qcom_smd_edge *edge,
1137 unsigned smem_info_item,
1138 unsigned smem_fifo_item,
1139 char *name)
1140{
1141 struct qcom_smd_channel *channel;
1142 struct qcom_smd *smd = edge->smd;
1143 size_t fifo_size;
1144 size_t info_size;
1145 void *fifo_base;
1146 void *info;
1147 int ret;
1148
1149 channel = devm_kzalloc(smd->dev, sizeof(*channel), GFP_KERNEL);
1150 if (!channel)
1151 return ERR_PTR(-ENOMEM);
1152
1153 INIT_LIST_HEAD(&channel->dev_list);
1154 channel->edge = edge;
1155 channel->name = devm_kstrdup(smd->dev, name, GFP_KERNEL);
1156 if (!channel->name)
1157 return ERR_PTR(-ENOMEM);
1158
1159 mutex_init(&channel->tx_lock);
1160 spin_lock_init(&channel->recv_lock);
1161 init_waitqueue_head(&channel->fblockread_event);
1162
1163 info = qcom_smem_get(edge->remote_pid, smem_info_item, &info_size);
1164 if (IS_ERR(info)) {
1165 ret = PTR_ERR(info);
1166 goto free_name_and_channel;
1167 }
1168
1169
1170
1171
1172
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;
1177 } else {
1178 dev_err(smd->dev,
1179 "channel info of size %zu not supported\n", info_size);
1180 ret = -EINVAL;
1181 goto free_name_and_channel;
1182 }
1183
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;
1188 }
1189
1190
1191 fifo_size /= 2;
1192
1193 dev_dbg(smd->dev, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1194 name, info_size, fifo_size);
1195
1196 channel->tx_fifo = fifo_base;
1197 channel->rx_fifo = fifo_base + fifo_size;
1198 channel->fifo_size = fifo_size;
1199
1200 qcom_smd_channel_reset(channel);
1201
1202 return channel;
1203
1204free_name_and_channel:
1205 devm_kfree(smd->dev, channel->name);
1206 devm_kfree(smd->dev, channel);
1207
1208 return ERR_PTR(ret);
1209}
1210
1211
1212
1213
1214
1215
1216static void qcom_channel_scan_worker(struct work_struct *work)
1217{
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;
1224 unsigned fifo_id;
1225 unsigned info_id;
1226 int tbl;
1227 int i;
1228 u32 eflags, cid;
1229
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))
1234 continue;
1235
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]))
1240 continue;
1241
1242 if (entry->ref_count == 0)
1243 continue;
1244
1245 if (!entry->name[0])
1246 continue;
1247
1248 if (!(eflags & SMD_CHANNEL_FLAGS_PACKET))
1249 continue;
1250
1251 if ((eflags & SMD_CHANNEL_FLAGS_EDGE_MASK) != edge->edge_id)
1252 continue;
1253
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;
1257
1258 channel = qcom_smd_create_channel(edge, info_id, fifo_id, entry->name);
1259 if (IS_ERR(channel))
1260 continue;
1261
1262 spin_lock_irqsave(&edge->channels_lock, flags);
1263 list_add(&channel->list, &edge->channels);
1264 spin_unlock_irqrestore(&edge->channels_lock, flags);
1265
1266 dev_dbg(smd->dev, "new channel found: '%s'\n", channel->name);
1267 set_bit(i, edge->allocated[tbl]);
1268
1269 wake_up_interruptible(&edge->new_channel_event);
1270 }
1271 }
1272
1273 schedule_work(&edge->state_work);
1274}
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284static void qcom_channel_state_worker(struct work_struct *work)
1285{
1286 struct qcom_smd_channel *channel;
1287 struct qcom_smd_edge *edge = container_of(work,
1288 struct qcom_smd_edge,
1289 state_work);
1290 unsigned remote_state;
1291 unsigned long flags;
1292
1293
1294
1295
1296
1297 spin_lock_irqsave(&edge->channels_lock, flags);
1298 list_for_each_entry(channel, &edge->channels, list) {
1299 if (channel->state != SMD_CHANNEL_CLOSED)
1300 continue;
1301
1302 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1303 if (remote_state != SMD_CHANNEL_OPENING &&
1304 remote_state != SMD_CHANNEL_OPENED)
1305 continue;
1306
1307 spin_unlock_irqrestore(&edge->channels_lock, flags);
1308 qcom_smd_create_device(channel);
1309 spin_lock_irqsave(&edge->channels_lock, flags);
1310 }
1311
1312
1313
1314
1315
1316 list_for_each_entry(channel, &edge->channels, list) {
1317 if (channel->state != SMD_CHANNEL_OPENING &&
1318 channel->state != SMD_CHANNEL_OPENED)
1319 continue;
1320
1321 remote_state = GET_RX_CHANNEL_INFO(channel, state);
1322 if (remote_state == SMD_CHANNEL_OPENING ||
1323 remote_state == SMD_CHANNEL_OPENED)
1324 continue;
1325
1326 spin_unlock_irqrestore(&edge->channels_lock, flags);
1327 qcom_smd_destroy_device(channel);
1328 spin_lock_irqsave(&edge->channels_lock, flags);
1329 }
1330 spin_unlock_irqrestore(&edge->channels_lock, flags);
1331}
1332
1333
1334
1335
1336static int qcom_smd_parse_edge(struct device *dev,
1337 struct device_node *node,
1338 struct qcom_smd_edge *edge)
1339{
1340 struct device_node *syscon_np;
1341 const char *key;
1342 int irq;
1343 int ret;
1344
1345 INIT_LIST_HEAD(&edge->channels);
1346 spin_lock_init(&edge->channels_lock);
1347
1348 INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
1349 INIT_WORK(&edge->state_work, qcom_channel_state_worker);
1350
1351 edge->of_node = of_node_get(node);
1352
1353 irq = irq_of_parse_and_map(node, 0);
1354 if (irq < 0) {
1355 dev_err(dev, "required smd interrupt missing\n");
1356 return -EINVAL;
1357 }
1358
1359 ret = devm_request_irq(dev, irq,
1360 qcom_smd_edge_intr, IRQF_TRIGGER_RISING,
1361 node->name, edge);
1362 if (ret) {
1363 dev_err(dev, "failed to request smd irq\n");
1364 return ret;
1365 }
1366
1367 edge->irq = irq;
1368
1369 key = "qcom,smd-edge";
1370 ret = of_property_read_u32(node, key, &edge->edge_id);
1371 if (ret) {
1372 dev_err(dev, "edge missing %s property\n", key);
1373 return -EINVAL;
1374 }
1375
1376 edge->remote_pid = QCOM_SMEM_HOST_ANY;
1377 key = "qcom,remote-pid";
1378 of_property_read_u32(node, key, &edge->remote_pid);
1379
1380 syscon_np = of_parse_phandle(node, "qcom,ipc", 0);
1381 if (!syscon_np) {
1382 dev_err(dev, "no qcom,ipc node\n");
1383 return -ENODEV;
1384 }
1385
1386 edge->ipc_regmap = syscon_node_to_regmap(syscon_np);
1387 if (IS_ERR(edge->ipc_regmap))
1388 return PTR_ERR(edge->ipc_regmap);
1389
1390 key = "qcom,ipc";
1391 ret = of_property_read_u32_index(node, key, 1, &edge->ipc_offset);
1392 if (ret < 0) {
1393 dev_err(dev, "no offset in %s\n", key);
1394 return -EINVAL;
1395 }
1396
1397 ret = of_property_read_u32_index(node, key, 2, &edge->ipc_bit);
1398 if (ret < 0) {
1399 dev_err(dev, "no bit in %s\n", key);
1400 return -EINVAL;
1401 }
1402
1403 return 0;
1404}
1405
1406static int qcom_smd_probe(struct platform_device *pdev)
1407{
1408 struct qcom_smd_edge *edge;
1409 struct device_node *node;
1410 struct qcom_smd *smd;
1411 size_t array_size;
1412 int num_edges;
1413 int ret;
1414 int i = 0;
1415 void *p;
1416
1417
1418 p = qcom_smem_get(QCOM_SMEM_HOST_ANY, smem_items[0].alloc_tbl_id, NULL);
1419 if (PTR_ERR(p) == -EPROBE_DEFER)
1420 return PTR_ERR(p);
1421
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);
1425 if (!smd)
1426 return -ENOMEM;
1427 smd->dev = &pdev->dev;
1428
1429 smd->num_edges = num_edges;
1430 for_each_available_child_of_node(pdev->dev.of_node, node) {
1431 edge = &smd->edges[i++];
1432 edge->smd = smd;
1433 init_waitqueue_head(&edge->new_channel_event);
1434
1435 ret = qcom_smd_parse_edge(&pdev->dev, node, edge);
1436 if (ret)
1437 continue;
1438
1439 schedule_work(&edge->scan_work);
1440 }
1441
1442 platform_set_drvdata(pdev, smd);
1443
1444 return 0;
1445}
1446
1447
1448
1449
1450
1451static int qcom_smd_remove(struct platform_device *pdev)
1452{
1453 struct qcom_smd_channel *channel;
1454 struct qcom_smd_edge *edge;
1455 struct qcom_smd *smd = platform_get_drvdata(pdev);
1456 int i;
1457
1458 for (i = 0; i < smd->num_edges; i++) {
1459 edge = &smd->edges[i];
1460
1461 disable_irq(edge->irq);
1462 cancel_work_sync(&edge->scan_work);
1463 cancel_work_sync(&edge->state_work);
1464
1465
1466 list_for_each_entry(channel, &edge->channels, list) {
1467 if (!channel->qsdev)
1468 continue;
1469
1470 qcom_smd_destroy_device(channel);
1471 }
1472 }
1473
1474 return 0;
1475}
1476
1477static const struct of_device_id qcom_smd_of_match[] = {
1478 { .compatible = "qcom,smd" },
1479 {}
1480};
1481MODULE_DEVICE_TABLE(of, qcom_smd_of_match);
1482
1483static struct platform_driver qcom_smd_driver = {
1484 .probe = qcom_smd_probe,
1485 .remove = qcom_smd_remove,
1486 .driver = {
1487 .name = "qcom-smd",
1488 .of_match_table = qcom_smd_of_match,
1489 },
1490};
1491
1492static int __init qcom_smd_init(void)
1493{
1494 int ret;
1495
1496 ret = bus_register(&qcom_smd_bus);
1497 if (ret) {
1498 pr_err("failed to register smd bus: %d\n", ret);
1499 return ret;
1500 }
1501
1502 return platform_driver_register(&qcom_smd_driver);
1503}
1504postcore_initcall(qcom_smd_init);
1505
1506static void __exit qcom_smd_exit(void)
1507{
1508 platform_driver_unregister(&qcom_smd_driver);
1509 bus_unregister(&qcom_smd_bus);
1510}
1511module_exit(qcom_smd_exit);
1512
1513MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
1514MODULE_DESCRIPTION("Qualcomm Shared Memory Driver");
1515MODULE_LICENSE("GPL v2");
1516