1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/cdev.h>
21#include <linux/debugfs.h>
22#include <linux/completion.h>
23#include <linux/device.h>
24#include <linux/err.h>
25#include <linux/freezer.h>
26#include <linux/fs.h>
27#include <linux/splice.h>
28#include <linux/pagemap.h>
29#include <linux/init.h>
30#include <linux/list.h>
31#include <linux/poll.h>
32#include <linux/sched.h>
33#include <linux/slab.h>
34#include <linux/spinlock.h>
35#include <linux/virtio.h>
36#include <linux/virtio_console.h>
37#include <linux/wait.h>
38#include <linux/workqueue.h>
39#include <linux/module.h>
40#include <linux/dma-mapping.h>
41#include "../tty/hvc/hvc_console.h"
42
43#define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
44
45
46
47
48
49
50
51
52
53struct ports_driver_data {
54
55 struct class *class;
56
57
58 struct dentry *debugfs_dir;
59
60
61 struct list_head portdevs;
62
63
64
65
66
67
68
69
70
71
72
73 unsigned int next_vtermno;
74
75
76 struct list_head consoles;
77};
78static struct ports_driver_data pdrvdata;
79
80static DEFINE_SPINLOCK(pdrvdata_lock);
81static DECLARE_COMPLETION(early_console_added);
82
83
84struct console {
85
86 struct list_head list;
87
88
89 struct hvc_struct *hvc;
90
91
92 struct winsize ws;
93
94
95
96
97
98
99
100
101 u32 vtermno;
102};
103
104struct port_buffer {
105 char *buf;
106
107
108 size_t size;
109
110
111 size_t len;
112
113 size_t offset;
114
115
116 dma_addr_t dma;
117
118
119 struct device *dev;
120
121
122 struct list_head list;
123
124
125 unsigned int sgpages;
126
127
128 struct scatterlist sg[0];
129};
130
131
132
133
134
135struct ports_device {
136
137 struct list_head list;
138
139
140
141
142
143 struct work_struct control_work;
144 struct work_struct config_work;
145
146 struct list_head ports;
147
148
149 spinlock_t ports_lock;
150
151
152 spinlock_t c_ivq_lock;
153 spinlock_t c_ovq_lock;
154
155
156 u32 max_nr_ports;
157
158
159 struct virtio_device *vdev;
160
161
162
163
164
165 struct virtqueue *c_ivq, *c_ovq;
166
167
168
169
170
171 struct virtio_console_control cpkt;
172
173
174 struct virtqueue **in_vqs, **out_vqs;
175
176
177 int chr_major;
178};
179
180struct port_stats {
181 unsigned long bytes_sent, bytes_received, bytes_discarded;
182};
183
184
185struct port {
186
187 struct list_head list;
188
189
190 struct ports_device *portdev;
191
192
193 struct port_buffer *inbuf;
194
195
196
197
198
199
200 spinlock_t inbuf_lock;
201
202
203 spinlock_t outvq_lock;
204
205
206 struct virtqueue *in_vq, *out_vq;
207
208
209 struct dentry *debugfs_file;
210
211
212
213
214
215
216 struct port_stats stats;
217
218
219
220
221
222 struct console cons;
223
224
225 struct cdev *cdev;
226 struct device *dev;
227
228
229 struct kref kref;
230
231
232 wait_queue_head_t waitqueue;
233
234
235 char *name;
236
237
238 struct fasync_struct *async_queue;
239
240
241 u32 id;
242
243 bool outvq_full;
244
245
246 bool host_connected;
247
248
249 bool guest_connected;
250};
251
252
253static int (*early_put_chars)(u32, const char *, int);
254
255static struct port *find_port_by_vtermno(u32 vtermno)
256{
257 struct port *port;
258 struct console *cons;
259 unsigned long flags;
260
261 spin_lock_irqsave(&pdrvdata_lock, flags);
262 list_for_each_entry(cons, &pdrvdata.consoles, list) {
263 if (cons->vtermno == vtermno) {
264 port = container_of(cons, struct port, cons);
265 goto out;
266 }
267 }
268 port = NULL;
269out:
270 spin_unlock_irqrestore(&pdrvdata_lock, flags);
271 return port;
272}
273
274static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
275 dev_t dev)
276{
277 struct port *port;
278 unsigned long flags;
279
280 spin_lock_irqsave(&portdev->ports_lock, flags);
281 list_for_each_entry(port, &portdev->ports, list) {
282 if (port->cdev->dev == dev) {
283 kref_get(&port->kref);
284 goto out;
285 }
286 }
287 port = NULL;
288out:
289 spin_unlock_irqrestore(&portdev->ports_lock, flags);
290
291 return port;
292}
293
294static struct port *find_port_by_devt(dev_t dev)
295{
296 struct ports_device *portdev;
297 struct port *port;
298 unsigned long flags;
299
300 spin_lock_irqsave(&pdrvdata_lock, flags);
301 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
302 port = find_port_by_devt_in_portdev(portdev, dev);
303 if (port)
304 goto out;
305 }
306 port = NULL;
307out:
308 spin_unlock_irqrestore(&pdrvdata_lock, flags);
309 return port;
310}
311
312static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
313{
314 struct port *port;
315 unsigned long flags;
316
317 spin_lock_irqsave(&portdev->ports_lock, flags);
318 list_for_each_entry(port, &portdev->ports, list)
319 if (port->id == id)
320 goto out;
321 port = NULL;
322out:
323 spin_unlock_irqrestore(&portdev->ports_lock, flags);
324
325 return port;
326}
327
328static struct port *find_port_by_vq(struct ports_device *portdev,
329 struct virtqueue *vq)
330{
331 struct port *port;
332 unsigned long flags;
333
334 spin_lock_irqsave(&portdev->ports_lock, flags);
335 list_for_each_entry(port, &portdev->ports, list)
336 if (port->in_vq == vq || port->out_vq == vq)
337 goto out;
338 port = NULL;
339out:
340 spin_unlock_irqrestore(&portdev->ports_lock, flags);
341 return port;
342}
343
344static bool is_console_port(struct port *port)
345{
346 if (port->cons.hvc)
347 return true;
348 return false;
349}
350
351static bool is_rproc_serial(const struct virtio_device *vdev)
352{
353 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
354}
355
356static inline bool use_multiport(struct ports_device *portdev)
357{
358
359
360
361
362 if (!portdev->vdev)
363 return false;
364 return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);
365}
366
367static DEFINE_SPINLOCK(dma_bufs_lock);
368static LIST_HEAD(pending_free_dma_bufs);
369
370static void free_buf(struct port_buffer *buf, bool can_sleep)
371{
372 unsigned int i;
373
374 for (i = 0; i < buf->sgpages; i++) {
375 struct page *page = sg_page(&buf->sg[i]);
376 if (!page)
377 break;
378 put_page(page);
379 }
380
381 if (!buf->dev) {
382 kfree(buf->buf);
383 } else if (is_rproc_enabled) {
384 unsigned long flags;
385
386
387 if (!can_sleep) {
388
389 spin_lock_irqsave(&dma_bufs_lock, flags);
390 list_add_tail(&buf->list, &pending_free_dma_bufs);
391 spin_unlock_irqrestore(&dma_bufs_lock, flags);
392 return;
393 }
394 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
395
396
397 put_device(buf->dev);
398 }
399
400 kfree(buf);
401}
402
403static void reclaim_dma_bufs(void)
404{
405 unsigned long flags;
406 struct port_buffer *buf, *tmp;
407 LIST_HEAD(tmp_list);
408
409 if (list_empty(&pending_free_dma_bufs))
410 return;
411
412
413 spin_lock_irqsave(&dma_bufs_lock, flags);
414 list_cut_position(&tmp_list, &pending_free_dma_bufs,
415 pending_free_dma_bufs.prev);
416 spin_unlock_irqrestore(&dma_bufs_lock, flags);
417
418
419 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
420 list_del(&buf->list);
421 free_buf(buf, true);
422 }
423}
424
425static struct port_buffer *alloc_buf(struct virtio_device *vdev, size_t buf_size,
426 int pages)
427{
428 struct port_buffer *buf;
429
430 reclaim_dma_bufs();
431
432
433
434
435
436 buf = kmalloc(struct_size(buf, sg, pages), GFP_KERNEL);
437 if (!buf)
438 goto fail;
439
440 buf->sgpages = pages;
441 if (pages > 0) {
442 buf->dev = NULL;
443 buf->buf = NULL;
444 return buf;
445 }
446
447 if (is_rproc_serial(vdev)) {
448
449
450
451
452
453
454 if (!vdev->dev.parent || !vdev->dev.parent->parent)
455 goto free_buf;
456 buf->dev = vdev->dev.parent->parent;
457
458
459 get_device(buf->dev);
460 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
461 GFP_KERNEL);
462 } else {
463 buf->dev = NULL;
464 buf->buf = kmalloc(buf_size, GFP_KERNEL);
465 }
466
467 if (!buf->buf)
468 goto free_buf;
469 buf->len = 0;
470 buf->offset = 0;
471 buf->size = buf_size;
472 return buf;
473
474free_buf:
475 kfree(buf);
476fail:
477 return NULL;
478}
479
480
481static struct port_buffer *get_inbuf(struct port *port)
482{
483 struct port_buffer *buf;
484 unsigned int len;
485
486 if (port->inbuf)
487 return port->inbuf;
488
489 buf = virtqueue_get_buf(port->in_vq, &len);
490 if (buf) {
491 buf->len = len;
492 buf->offset = 0;
493 port->stats.bytes_received += len;
494 }
495 return buf;
496}
497
498
499
500
501
502
503
504static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
505{
506 struct scatterlist sg[1];
507 int ret;
508
509 sg_init_one(sg, buf->buf, buf->size);
510
511 ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);
512 virtqueue_kick(vq);
513 if (!ret)
514 ret = vq->num_free;
515 return ret;
516}
517
518
519static void discard_port_data(struct port *port)
520{
521 struct port_buffer *buf;
522 unsigned int err;
523
524 if (!port->portdev) {
525
526 return;
527 }
528 buf = get_inbuf(port);
529
530 err = 0;
531 while (buf) {
532 port->stats.bytes_discarded += buf->len - buf->offset;
533 if (add_inbuf(port->in_vq, buf) < 0) {
534 err++;
535 free_buf(buf, false);
536 }
537 port->inbuf = NULL;
538 buf = get_inbuf(port);
539 }
540 if (err)
541 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
542 err);
543}
544
545static bool port_has_data(struct port *port)
546{
547 unsigned long flags;
548 bool ret;
549
550 ret = false;
551 spin_lock_irqsave(&port->inbuf_lock, flags);
552 port->inbuf = get_inbuf(port);
553 if (port->inbuf)
554 ret = true;
555
556 spin_unlock_irqrestore(&port->inbuf_lock, flags);
557 return ret;
558}
559
560static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
561 unsigned int event, unsigned int value)
562{
563 struct scatterlist sg[1];
564 struct virtqueue *vq;
565 unsigned int len;
566
567 if (!use_multiport(portdev))
568 return 0;
569
570 vq = portdev->c_ovq;
571
572 spin_lock(&portdev->c_ovq_lock);
573
574 portdev->cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);
575 portdev->cpkt.event = cpu_to_virtio16(portdev->vdev, event);
576 portdev->cpkt.value = cpu_to_virtio16(portdev->vdev, value);
577
578 sg_init_one(sg, &portdev->cpkt, sizeof(struct virtio_console_control));
579
580 if (virtqueue_add_outbuf(vq, sg, 1, &portdev->cpkt, GFP_ATOMIC) == 0) {
581 virtqueue_kick(vq);
582 while (!virtqueue_get_buf(vq, &len)
583 && !virtqueue_is_broken(vq))
584 cpu_relax();
585 }
586
587 spin_unlock(&portdev->c_ovq_lock);
588 return 0;
589}
590
591static ssize_t send_control_msg(struct port *port, unsigned int event,
592 unsigned int value)
593{
594
595 if (port->portdev)
596 return __send_control_msg(port->portdev, port->id, event, value);
597 return 0;
598}
599
600
601
602static void reclaim_consumed_buffers(struct port *port)
603{
604 struct port_buffer *buf;
605 unsigned int len;
606
607 if (!port->portdev) {
608
609 return;
610 }
611 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
612 free_buf(buf, false);
613 port->outvq_full = false;
614 }
615}
616
617static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
618 int nents, size_t in_count,
619 void *data, bool nonblock)
620{
621 struct virtqueue *out_vq;
622 int err;
623 unsigned long flags;
624 unsigned int len;
625
626 out_vq = port->out_vq;
627
628 spin_lock_irqsave(&port->outvq_lock, flags);
629
630 reclaim_consumed_buffers(port);
631
632 err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);
633
634
635 virtqueue_kick(out_vq);
636
637 if (err) {
638 in_count = 0;
639 goto done;
640 }
641
642 if (out_vq->num_free == 0)
643 port->outvq_full = true;
644
645 if (nonblock)
646 goto done;
647
648
649
650
651
652
653
654
655
656
657 while (!virtqueue_get_buf(out_vq, &len)
658 && !virtqueue_is_broken(out_vq))
659 cpu_relax();
660done:
661 spin_unlock_irqrestore(&port->outvq_lock, flags);
662
663 port->stats.bytes_sent += in_count;
664
665
666
667
668 return in_count;
669}
670
671
672
673
674
675static ssize_t fill_readbuf(struct port *port, char __user *out_buf,
676 size_t out_count, bool to_user)
677{
678 struct port_buffer *buf;
679 unsigned long flags;
680
681 if (!out_count || !port_has_data(port))
682 return 0;
683
684 buf = port->inbuf;
685 out_count = min(out_count, buf->len - buf->offset);
686
687 if (to_user) {
688 ssize_t ret;
689
690 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
691 if (ret)
692 return -EFAULT;
693 } else {
694 memcpy((__force char *)out_buf, buf->buf + buf->offset,
695 out_count);
696 }
697
698 buf->offset += out_count;
699
700 if (buf->offset == buf->len) {
701
702
703
704
705 spin_lock_irqsave(&port->inbuf_lock, flags);
706 port->inbuf = NULL;
707
708 if (add_inbuf(port->in_vq, buf) < 0)
709 dev_warn(port->dev, "failed add_buf\n");
710
711 spin_unlock_irqrestore(&port->inbuf_lock, flags);
712 }
713
714 return out_count;
715}
716
717
718static bool will_read_block(struct port *port)
719{
720 if (!port->guest_connected) {
721
722 return false;
723 }
724 return !port_has_data(port) && port->host_connected;
725}
726
727static bool will_write_block(struct port *port)
728{
729 bool ret;
730
731 if (!port->guest_connected) {
732
733 return false;
734 }
735 if (!port->host_connected)
736 return true;
737
738 spin_lock_irq(&port->outvq_lock);
739
740
741
742
743 reclaim_consumed_buffers(port);
744 ret = port->outvq_full;
745 spin_unlock_irq(&port->outvq_lock);
746
747 return ret;
748}
749
750static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
751 size_t count, loff_t *offp)
752{
753 struct port *port;
754 ssize_t ret;
755
756 port = filp->private_data;
757
758
759 if (!port->guest_connected)
760 return -ENODEV;
761
762 if (!port_has_data(port)) {
763
764
765
766
767
768 if (!port->host_connected)
769 return 0;
770 if (filp->f_flags & O_NONBLOCK)
771 return -EAGAIN;
772
773 ret = wait_event_freezable(port->waitqueue,
774 !will_read_block(port));
775 if (ret < 0)
776 return ret;
777 }
778
779 if (!port->guest_connected)
780 return -ENODEV;
781
782
783
784
785
786
787
788
789
790
791 if (!port_has_data(port) && !port->host_connected)
792 return 0;
793
794 return fill_readbuf(port, ubuf, count, true);
795}
796
797static int wait_port_writable(struct port *port, bool nonblock)
798{
799 int ret;
800
801 if (will_write_block(port)) {
802 if (nonblock)
803 return -EAGAIN;
804
805 ret = wait_event_freezable(port->waitqueue,
806 !will_write_block(port));
807 if (ret < 0)
808 return ret;
809 }
810
811 if (!port->guest_connected)
812 return -ENODEV;
813
814 return 0;
815}
816
817static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
818 size_t count, loff_t *offp)
819{
820 struct port *port;
821 struct port_buffer *buf;
822 ssize_t ret;
823 bool nonblock;
824 struct scatterlist sg[1];
825
826
827 if (!count)
828 return 0;
829
830 port = filp->private_data;
831
832 nonblock = filp->f_flags & O_NONBLOCK;
833
834 ret = wait_port_writable(port, nonblock);
835 if (ret < 0)
836 return ret;
837
838 count = min((size_t)(32 * 1024), count);
839
840 buf = alloc_buf(port->portdev->vdev, count, 0);
841 if (!buf)
842 return -ENOMEM;
843
844 ret = copy_from_user(buf->buf, ubuf, count);
845 if (ret) {
846 ret = -EFAULT;
847 goto free_buf;
848 }
849
850
851
852
853
854
855
856
857 nonblock = true;
858 sg_init_one(sg, buf->buf, count);
859 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
860
861 if (nonblock && ret > 0)
862 goto out;
863
864free_buf:
865 free_buf(buf, true);
866out:
867 return ret;
868}
869
870struct sg_list {
871 unsigned int n;
872 unsigned int size;
873 size_t len;
874 struct scatterlist *sg;
875};
876
877static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
878 struct splice_desc *sd)
879{
880 struct sg_list *sgl = sd->u.data;
881 unsigned int offset, len;
882
883 if (sgl->n == sgl->size)
884 return 0;
885
886
887 if (pipe_buf_steal(pipe, buf) == 0) {
888
889 get_page(buf->page);
890 unlock_page(buf->page);
891
892 len = min(buf->len, sd->len);
893 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
894 } else {
895
896 struct page *page = alloc_page(GFP_KERNEL);
897 char *src;
898
899 if (!page)
900 return -ENOMEM;
901
902 offset = sd->pos & ~PAGE_MASK;
903
904 len = sd->len;
905 if (len + offset > PAGE_SIZE)
906 len = PAGE_SIZE - offset;
907
908 src = kmap_atomic(buf->page);
909 memcpy(page_address(page) + offset, src + buf->offset, len);
910 kunmap_atomic(src);
911
912 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
913 }
914 sgl->n++;
915 sgl->len += len;
916
917 return len;
918}
919
920
921static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
922 struct file *filp, loff_t *ppos,
923 size_t len, unsigned int flags)
924{
925 struct port *port = filp->private_data;
926 struct sg_list sgl;
927 ssize_t ret;
928 struct port_buffer *buf;
929 struct splice_desc sd = {
930 .total_len = len,
931 .flags = flags,
932 .pos = *ppos,
933 .u.data = &sgl,
934 };
935
936
937
938
939
940
941
942 if (is_rproc_serial(port->out_vq->vdev))
943 return -EINVAL;
944
945
946
947
948
949 pipe_lock(pipe);
950 if (!pipe->nrbufs) {
951 ret = 0;
952 goto error_out;
953 }
954
955 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
956 if (ret < 0)
957 goto error_out;
958
959 buf = alloc_buf(port->portdev->vdev, 0, pipe->nrbufs);
960 if (!buf) {
961 ret = -ENOMEM;
962 goto error_out;
963 }
964
965 sgl.n = 0;
966 sgl.len = 0;
967 sgl.size = pipe->nrbufs;
968 sgl.sg = buf->sg;
969 sg_init_table(sgl.sg, sgl.size);
970 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
971 pipe_unlock(pipe);
972 if (likely(ret > 0))
973 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
974
975 if (unlikely(ret <= 0))
976 free_buf(buf, true);
977 return ret;
978
979error_out:
980 pipe_unlock(pipe);
981 return ret;
982}
983
984static __poll_t port_fops_poll(struct file *filp, poll_table *wait)
985{
986 struct port *port;
987 __poll_t ret;
988
989 port = filp->private_data;
990 poll_wait(filp, &port->waitqueue, wait);
991
992 if (!port->guest_connected) {
993
994 return EPOLLHUP;
995 }
996 ret = 0;
997 if (!will_read_block(port))
998 ret |= EPOLLIN | EPOLLRDNORM;
999 if (!will_write_block(port))
1000 ret |= EPOLLOUT;
1001 if (!port->host_connected)
1002 ret |= EPOLLHUP;
1003
1004 return ret;
1005}
1006
1007static void remove_port(struct kref *kref);
1008
1009static int port_fops_release(struct inode *inode, struct file *filp)
1010{
1011 struct port *port;
1012
1013 port = filp->private_data;
1014
1015
1016 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1017
1018 spin_lock_irq(&port->inbuf_lock);
1019 port->guest_connected = false;
1020
1021 discard_port_data(port);
1022
1023 spin_unlock_irq(&port->inbuf_lock);
1024
1025 spin_lock_irq(&port->outvq_lock);
1026 reclaim_consumed_buffers(port);
1027 spin_unlock_irq(&port->outvq_lock);
1028
1029 reclaim_dma_bufs();
1030
1031
1032
1033
1034
1035
1036
1037
1038 kref_put(&port->kref, remove_port);
1039
1040 return 0;
1041}
1042
1043static int port_fops_open(struct inode *inode, struct file *filp)
1044{
1045 struct cdev *cdev = inode->i_cdev;
1046 struct port *port;
1047 int ret;
1048
1049
1050 port = find_port_by_devt(cdev->dev);
1051 if (!port) {
1052
1053 return -ENXIO;
1054 }
1055 filp->private_data = port;
1056
1057
1058
1059
1060
1061 if (is_console_port(port)) {
1062 ret = -ENXIO;
1063 goto out;
1064 }
1065
1066
1067 spin_lock_irq(&port->inbuf_lock);
1068 if (port->guest_connected) {
1069 spin_unlock_irq(&port->inbuf_lock);
1070 ret = -EBUSY;
1071 goto out;
1072 }
1073
1074 port->guest_connected = true;
1075 spin_unlock_irq(&port->inbuf_lock);
1076
1077 spin_lock_irq(&port->outvq_lock);
1078
1079
1080
1081
1082
1083 reclaim_consumed_buffers(port);
1084 spin_unlock_irq(&port->outvq_lock);
1085
1086 nonseekable_open(inode, filp);
1087
1088
1089 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1090
1091 return 0;
1092out:
1093 kref_put(&port->kref, remove_port);
1094 return ret;
1095}
1096
1097static int port_fops_fasync(int fd, struct file *filp, int mode)
1098{
1099 struct port *port;
1100
1101 port = filp->private_data;
1102 return fasync_helper(fd, filp, mode, &port->async_queue);
1103}
1104
1105
1106
1107
1108
1109
1110
1111static const struct file_operations port_fops = {
1112 .owner = THIS_MODULE,
1113 .open = port_fops_open,
1114 .read = port_fops_read,
1115 .write = port_fops_write,
1116 .splice_write = port_fops_splice_write,
1117 .poll = port_fops_poll,
1118 .release = port_fops_release,
1119 .fasync = port_fops_fasync,
1120 .llseek = no_llseek,
1121};
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131static int put_chars(u32 vtermno, const char *buf, int count)
1132{
1133 struct port *port;
1134 struct scatterlist sg[1];
1135 void *data;
1136 int ret;
1137
1138 if (unlikely(early_put_chars))
1139 return early_put_chars(vtermno, buf, count);
1140
1141 port = find_port_by_vtermno(vtermno);
1142 if (!port)
1143 return -EPIPE;
1144
1145 data = kmemdup(buf, count, GFP_ATOMIC);
1146 if (!data)
1147 return -ENOMEM;
1148
1149 sg_init_one(sg, data, count);
1150 ret = __send_to_port(port, sg, 1, count, data, false);
1151 kfree(data);
1152 return ret;
1153}
1154
1155
1156
1157
1158
1159
1160
1161
1162static int get_chars(u32 vtermno, char *buf, int count)
1163{
1164 struct port *port;
1165
1166
1167 if (unlikely(early_put_chars))
1168 return 0;
1169
1170 port = find_port_by_vtermno(vtermno);
1171 if (!port)
1172 return -EPIPE;
1173
1174
1175 BUG_ON(!port->in_vq);
1176
1177 return fill_readbuf(port, (__force char __user *)buf, count, false);
1178}
1179
1180static void resize_console(struct port *port)
1181{
1182 struct virtio_device *vdev;
1183
1184
1185 if (!port || !is_console_port(port))
1186 return;
1187
1188 vdev = port->portdev->vdev;
1189
1190
1191 if (!is_rproc_serial(vdev) &&
1192 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
1193 hvc_resize(port->cons.hvc, port->cons.ws);
1194}
1195
1196
1197static int notifier_add_vio(struct hvc_struct *hp, int data)
1198{
1199 struct port *port;
1200
1201 port = find_port_by_vtermno(hp->vtermno);
1202 if (!port)
1203 return -EINVAL;
1204
1205 hp->irq_requested = 1;
1206 resize_console(port);
1207
1208 return 0;
1209}
1210
1211static void notifier_del_vio(struct hvc_struct *hp, int data)
1212{
1213 hp->irq_requested = 0;
1214}
1215
1216
1217static const struct hv_ops hv_ops = {
1218 .get_chars = get_chars,
1219 .put_chars = put_chars,
1220 .notifier_add = notifier_add_vio,
1221 .notifier_del = notifier_del_vio,
1222 .notifier_hangup = notifier_del_vio,
1223};
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1235{
1236 early_put_chars = put_chars;
1237 return hvc_instantiate(0, 0, &hv_ops);
1238}
1239
1240static int init_port_console(struct port *port)
1241{
1242 int ret;
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261 port->cons.vtermno = pdrvdata.next_vtermno;
1262
1263 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1264 if (IS_ERR(port->cons.hvc)) {
1265 ret = PTR_ERR(port->cons.hvc);
1266 dev_err(port->dev,
1267 "error %d allocating hvc for port\n", ret);
1268 port->cons.hvc = NULL;
1269 return ret;
1270 }
1271 spin_lock_irq(&pdrvdata_lock);
1272 pdrvdata.next_vtermno++;
1273 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1274 spin_unlock_irq(&pdrvdata_lock);
1275 port->guest_connected = true;
1276
1277
1278
1279
1280
1281 if (early_put_chars)
1282 early_put_chars = NULL;
1283
1284
1285 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1286
1287 return 0;
1288}
1289
1290static ssize_t show_port_name(struct device *dev,
1291 struct device_attribute *attr, char *buffer)
1292{
1293 struct port *port;
1294
1295 port = dev_get_drvdata(dev);
1296
1297 return sprintf(buffer, "%s\n", port->name);
1298}
1299
1300static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1301
1302static struct attribute *port_sysfs_entries[] = {
1303 &dev_attr_name.attr,
1304 NULL
1305};
1306
1307static const struct attribute_group port_attribute_group = {
1308 .name = NULL,
1309 .attrs = port_sysfs_entries,
1310};
1311
1312static int debugfs_show(struct seq_file *s, void *data)
1313{
1314 struct port *port = s->private;
1315
1316 seq_printf(s, "name: %s\n", port->name ? port->name : "");
1317 seq_printf(s, "guest_connected: %d\n", port->guest_connected);
1318 seq_printf(s, "host_connected: %d\n", port->host_connected);
1319 seq_printf(s, "outvq_full: %d\n", port->outvq_full);
1320 seq_printf(s, "bytes_sent: %lu\n", port->stats.bytes_sent);
1321 seq_printf(s, "bytes_received: %lu\n", port->stats.bytes_received);
1322 seq_printf(s, "bytes_discarded: %lu\n", port->stats.bytes_discarded);
1323 seq_printf(s, "is_console: %s\n",
1324 is_console_port(port) ? "yes" : "no");
1325 seq_printf(s, "console_vtermno: %u\n", port->cons.vtermno);
1326
1327 return 0;
1328}
1329
1330static int debugfs_open(struct inode *inode, struct file *file)
1331{
1332 return single_open(file, debugfs_show, inode->i_private);
1333}
1334
1335static const struct file_operations port_debugfs_ops = {
1336 .owner = THIS_MODULE,
1337 .open = debugfs_open,
1338 .read = seq_read,
1339 .llseek = seq_lseek,
1340 .release = single_release,
1341};
1342
1343static void set_console_size(struct port *port, u16 rows, u16 cols)
1344{
1345 if (!port || !is_console_port(port))
1346 return;
1347
1348 port->cons.ws.ws_row = rows;
1349 port->cons.ws.ws_col = cols;
1350}
1351
1352static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1353{
1354 struct port_buffer *buf;
1355 unsigned int nr_added_bufs;
1356 int ret;
1357
1358 nr_added_bufs = 0;
1359 do {
1360 buf = alloc_buf(vq->vdev, PAGE_SIZE, 0);
1361 if (!buf)
1362 break;
1363
1364 spin_lock_irq(lock);
1365 ret = add_inbuf(vq, buf);
1366 if (ret < 0) {
1367 spin_unlock_irq(lock);
1368 free_buf(buf, true);
1369 break;
1370 }
1371 nr_added_bufs++;
1372 spin_unlock_irq(lock);
1373 } while (ret > 0);
1374
1375 return nr_added_bufs;
1376}
1377
1378static void send_sigio_to_port(struct port *port)
1379{
1380 if (port->async_queue && port->guest_connected)
1381 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1382}
1383
1384static int add_port(struct ports_device *portdev, u32 id)
1385{
1386 char debugfs_name[16];
1387 struct port *port;
1388 dev_t devt;
1389 unsigned int nr_added_bufs;
1390 int err;
1391
1392 port = kmalloc(sizeof(*port), GFP_KERNEL);
1393 if (!port) {
1394 err = -ENOMEM;
1395 goto fail;
1396 }
1397 kref_init(&port->kref);
1398
1399 port->portdev = portdev;
1400 port->id = id;
1401
1402 port->name = NULL;
1403 port->inbuf = NULL;
1404 port->cons.hvc = NULL;
1405 port->async_queue = NULL;
1406
1407 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1408
1409 port->host_connected = port->guest_connected = false;
1410 port->stats = (struct port_stats) { 0 };
1411
1412 port->outvq_full = false;
1413
1414 port->in_vq = portdev->in_vqs[port->id];
1415 port->out_vq = portdev->out_vqs[port->id];
1416
1417 port->cdev = cdev_alloc();
1418 if (!port->cdev) {
1419 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1420 err = -ENOMEM;
1421 goto free_port;
1422 }
1423 port->cdev->ops = &port_fops;
1424
1425 devt = MKDEV(portdev->chr_major, id);
1426 err = cdev_add(port->cdev, devt, 1);
1427 if (err < 0) {
1428 dev_err(&port->portdev->vdev->dev,
1429 "Error %d adding cdev for port %u\n", err, id);
1430 goto free_cdev;
1431 }
1432 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1433 devt, port, "vport%up%u",
1434 port->portdev->vdev->index, id);
1435 if (IS_ERR(port->dev)) {
1436 err = PTR_ERR(port->dev);
1437 dev_err(&port->portdev->vdev->dev,
1438 "Error %d creating device for port %u\n",
1439 err, id);
1440 goto free_cdev;
1441 }
1442
1443 spin_lock_init(&port->inbuf_lock);
1444 spin_lock_init(&port->outvq_lock);
1445 init_waitqueue_head(&port->waitqueue);
1446
1447
1448 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1449 if (!nr_added_bufs) {
1450 dev_err(port->dev, "Error allocating inbufs\n");
1451 err = -ENOMEM;
1452 goto free_device;
1453 }
1454
1455 if (is_rproc_serial(port->portdev->vdev))
1456
1457
1458
1459
1460
1461 port->host_connected = true;
1462 else if (!use_multiport(port->portdev)) {
1463
1464
1465
1466
1467 err = init_port_console(port);
1468 if (err)
1469 goto free_inbufs;
1470 }
1471
1472 spin_lock_irq(&portdev->ports_lock);
1473 list_add_tail(&port->list, &port->portdev->ports);
1474 spin_unlock_irq(&portdev->ports_lock);
1475
1476
1477
1478
1479
1480
1481 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1482
1483 if (pdrvdata.debugfs_dir) {
1484
1485
1486
1487
1488 snprintf(debugfs_name, sizeof(debugfs_name), "vport%up%u",
1489 port->portdev->vdev->index, id);
1490 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1491 pdrvdata.debugfs_dir,
1492 port,
1493 &port_debugfs_ops);
1494 }
1495 return 0;
1496
1497free_inbufs:
1498free_device:
1499 device_destroy(pdrvdata.class, port->dev->devt);
1500free_cdev:
1501 cdev_del(port->cdev);
1502free_port:
1503 kfree(port);
1504fail:
1505
1506 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
1507 return err;
1508}
1509
1510
1511static void remove_port(struct kref *kref)
1512{
1513 struct port *port;
1514
1515 port = container_of(kref, struct port, kref);
1516
1517 kfree(port);
1518}
1519
1520static void remove_port_data(struct port *port)
1521{
1522 spin_lock_irq(&port->inbuf_lock);
1523
1524 discard_port_data(port);
1525 spin_unlock_irq(&port->inbuf_lock);
1526
1527 spin_lock_irq(&port->outvq_lock);
1528 reclaim_consumed_buffers(port);
1529 spin_unlock_irq(&port->outvq_lock);
1530}
1531
1532
1533
1534
1535
1536
1537static void unplug_port(struct port *port)
1538{
1539 spin_lock_irq(&port->portdev->ports_lock);
1540 list_del(&port->list);
1541 spin_unlock_irq(&port->portdev->ports_lock);
1542
1543 spin_lock_irq(&port->inbuf_lock);
1544 if (port->guest_connected) {
1545
1546 send_sigio_to_port(port);
1547
1548
1549 port->guest_connected = false;
1550 port->host_connected = false;
1551
1552 wake_up_interruptible(&port->waitqueue);
1553 }
1554 spin_unlock_irq(&port->inbuf_lock);
1555
1556 if (is_console_port(port)) {
1557 spin_lock_irq(&pdrvdata_lock);
1558 list_del(&port->cons.list);
1559 spin_unlock_irq(&pdrvdata_lock);
1560 hvc_remove(port->cons.hvc);
1561 }
1562
1563 remove_port_data(port);
1564
1565
1566
1567
1568
1569
1570 port->portdev = NULL;
1571
1572 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1573 device_destroy(pdrvdata.class, port->dev->devt);
1574 cdev_del(port->cdev);
1575
1576 debugfs_remove(port->debugfs_file);
1577 kfree(port->name);
1578
1579
1580
1581
1582
1583
1584 kref_put(&port->kref, remove_port);
1585}
1586
1587
1588static void handle_control_message(struct virtio_device *vdev,
1589 struct ports_device *portdev,
1590 struct port_buffer *buf)
1591{
1592 struct virtio_console_control *cpkt;
1593 struct port *port;
1594 size_t name_size;
1595 int err;
1596
1597 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1598
1599 port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
1600 if (!port &&
1601 cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
1602
1603 dev_dbg(&portdev->vdev->dev,
1604 "Invalid index %u in control packet\n", cpkt->id);
1605 return;
1606 }
1607
1608 switch (virtio16_to_cpu(vdev, cpkt->event)) {
1609 case VIRTIO_CONSOLE_PORT_ADD:
1610 if (port) {
1611 dev_dbg(&portdev->vdev->dev,
1612 "Port %u already added\n", port->id);
1613 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1614 break;
1615 }
1616 if (virtio32_to_cpu(vdev, cpkt->id) >=
1617 portdev->max_nr_ports) {
1618 dev_warn(&portdev->vdev->dev,
1619 "Request for adding port with "
1620 "out-of-bound id %u, max. supported id: %u\n",
1621 cpkt->id, portdev->max_nr_ports - 1);
1622 break;
1623 }
1624 add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
1625 break;
1626 case VIRTIO_CONSOLE_PORT_REMOVE:
1627 unplug_port(port);
1628 break;
1629 case VIRTIO_CONSOLE_CONSOLE_PORT:
1630 if (!cpkt->value)
1631 break;
1632 if (is_console_port(port))
1633 break;
1634
1635 init_port_console(port);
1636 complete(&early_console_added);
1637
1638
1639
1640
1641 break;
1642 case VIRTIO_CONSOLE_RESIZE: {
1643 struct {
1644 __u16 rows;
1645 __u16 cols;
1646 } size;
1647
1648 if (!is_console_port(port))
1649 break;
1650
1651 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1652 sizeof(size));
1653 set_console_size(port, size.rows, size.cols);
1654
1655 port->cons.hvc->irq_requested = 1;
1656 resize_console(port);
1657 break;
1658 }
1659 case VIRTIO_CONSOLE_PORT_OPEN:
1660 port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
1661 wake_up_interruptible(&port->waitqueue);
1662
1663
1664
1665
1666
1667 spin_lock_irq(&port->outvq_lock);
1668 reclaim_consumed_buffers(port);
1669 spin_unlock_irq(&port->outvq_lock);
1670
1671
1672
1673
1674
1675 spin_lock_irq(&port->inbuf_lock);
1676 send_sigio_to_port(port);
1677 spin_unlock_irq(&port->inbuf_lock);
1678 break;
1679 case VIRTIO_CONSOLE_PORT_NAME:
1680
1681
1682
1683
1684 if (port->name)
1685 break;
1686
1687
1688
1689
1690
1691 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1692
1693 port->name = kmalloc(name_size, GFP_KERNEL);
1694 if (!port->name) {
1695 dev_err(port->dev,
1696 "Not enough space to store port name\n");
1697 break;
1698 }
1699 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1700 name_size - 1);
1701 port->name[name_size - 1] = 0;
1702
1703
1704
1705
1706
1707 err = sysfs_create_group(&port->dev->kobj,
1708 &port_attribute_group);
1709 if (err) {
1710 dev_err(port->dev,
1711 "Error %d creating sysfs device attributes\n",
1712 err);
1713 } else {
1714
1715
1716
1717
1718
1719 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1720 }
1721 break;
1722 }
1723}
1724
1725static void control_work_handler(struct work_struct *work)
1726{
1727 struct ports_device *portdev;
1728 struct virtqueue *vq;
1729 struct port_buffer *buf;
1730 unsigned int len;
1731
1732 portdev = container_of(work, struct ports_device, control_work);
1733 vq = portdev->c_ivq;
1734
1735 spin_lock(&portdev->c_ivq_lock);
1736 while ((buf = virtqueue_get_buf(vq, &len))) {
1737 spin_unlock(&portdev->c_ivq_lock);
1738
1739 buf->len = len;
1740 buf->offset = 0;
1741
1742 handle_control_message(vq->vdev, portdev, buf);
1743
1744 spin_lock(&portdev->c_ivq_lock);
1745 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1746 dev_warn(&portdev->vdev->dev,
1747 "Error adding buffer to queue\n");
1748 free_buf(buf, false);
1749 }
1750 }
1751 spin_unlock(&portdev->c_ivq_lock);
1752}
1753
1754static void flush_bufs(struct virtqueue *vq, bool can_sleep)
1755{
1756 struct port_buffer *buf;
1757 unsigned int len;
1758
1759 while ((buf = virtqueue_get_buf(vq, &len)))
1760 free_buf(buf, can_sleep);
1761}
1762
1763static void out_intr(struct virtqueue *vq)
1764{
1765 struct port *port;
1766
1767 port = find_port_by_vq(vq->vdev->priv, vq);
1768 if (!port) {
1769 flush_bufs(vq, false);
1770 return;
1771 }
1772
1773 wake_up_interruptible(&port->waitqueue);
1774}
1775
1776static void in_intr(struct virtqueue *vq)
1777{
1778 struct port *port;
1779 unsigned long flags;
1780
1781 port = find_port_by_vq(vq->vdev->priv, vq);
1782 if (!port) {
1783 flush_bufs(vq, false);
1784 return;
1785 }
1786
1787 spin_lock_irqsave(&port->inbuf_lock, flags);
1788 port->inbuf = get_inbuf(port);
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
1808 discard_port_data(port);
1809
1810
1811 send_sigio_to_port(port);
1812
1813 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1814
1815 wake_up_interruptible(&port->waitqueue);
1816
1817 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1818 hvc_kick();
1819}
1820
1821static void control_intr(struct virtqueue *vq)
1822{
1823 struct ports_device *portdev;
1824
1825 portdev = vq->vdev->priv;
1826 schedule_work(&portdev->control_work);
1827}
1828
1829static void config_intr(struct virtio_device *vdev)
1830{
1831 struct ports_device *portdev;
1832
1833 portdev = vdev->priv;
1834
1835 if (!use_multiport(portdev))
1836 schedule_work(&portdev->config_work);
1837}
1838
1839static void config_work_handler(struct work_struct *work)
1840{
1841 struct ports_device *portdev;
1842
1843 portdev = container_of(work, struct ports_device, config_work);
1844 if (!use_multiport(portdev)) {
1845 struct virtio_device *vdev;
1846 struct port *port;
1847 u16 rows, cols;
1848
1849 vdev = portdev->vdev;
1850 virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1851 virtio_cread(vdev, struct virtio_console_config, rows, &rows);
1852
1853 port = find_port_by_id(portdev, 0);
1854 set_console_size(port, rows, cols);
1855
1856
1857
1858
1859
1860
1861
1862
1863 resize_console(port);
1864 }
1865}
1866
1867static int init_vqs(struct ports_device *portdev)
1868{
1869 vq_callback_t **io_callbacks;
1870 char **io_names;
1871 struct virtqueue **vqs;
1872 u32 i, j, nr_ports, nr_queues;
1873 int err;
1874
1875 nr_ports = portdev->max_nr_ports;
1876 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
1877
1878 vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL);
1879 io_callbacks = kmalloc_array(nr_queues, sizeof(vq_callback_t *),
1880 GFP_KERNEL);
1881 io_names = kmalloc_array(nr_queues, sizeof(char *), GFP_KERNEL);
1882 portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1883 GFP_KERNEL);
1884 portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1885 GFP_KERNEL);
1886 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
1887 !portdev->out_vqs) {
1888 err = -ENOMEM;
1889 goto free;
1890 }
1891
1892
1893
1894
1895
1896
1897 j = 0;
1898 io_callbacks[j] = in_intr;
1899 io_callbacks[j + 1] = out_intr;
1900 io_names[j] = "input";
1901 io_names[j + 1] = "output";
1902 j += 2;
1903
1904 if (use_multiport(portdev)) {
1905 io_callbacks[j] = control_intr;
1906 io_callbacks[j + 1] = NULL;
1907 io_names[j] = "control-i";
1908 io_names[j + 1] = "control-o";
1909
1910 for (i = 1; i < nr_ports; i++) {
1911 j += 2;
1912 io_callbacks[j] = in_intr;
1913 io_callbacks[j + 1] = out_intr;
1914 io_names[j] = "input";
1915 io_names[j + 1] = "output";
1916 }
1917 }
1918
1919 err = virtio_find_vqs(portdev->vdev, nr_queues, vqs,
1920 io_callbacks,
1921 (const char **)io_names, NULL);
1922 if (err)
1923 goto free;
1924
1925 j = 0;
1926 portdev->in_vqs[0] = vqs[0];
1927 portdev->out_vqs[0] = vqs[1];
1928 j += 2;
1929 if (use_multiport(portdev)) {
1930 portdev->c_ivq = vqs[j];
1931 portdev->c_ovq = vqs[j + 1];
1932
1933 for (i = 1; i < nr_ports; i++) {
1934 j += 2;
1935 portdev->in_vqs[i] = vqs[j];
1936 portdev->out_vqs[i] = vqs[j + 1];
1937 }
1938 }
1939 kfree(io_names);
1940 kfree(io_callbacks);
1941 kfree(vqs);
1942
1943 return 0;
1944
1945free:
1946 kfree(portdev->out_vqs);
1947 kfree(portdev->in_vqs);
1948 kfree(io_names);
1949 kfree(io_callbacks);
1950 kfree(vqs);
1951
1952 return err;
1953}
1954
1955static const struct file_operations portdev_fops = {
1956 .owner = THIS_MODULE,
1957};
1958
1959static void remove_vqs(struct ports_device *portdev)
1960{
1961 struct virtqueue *vq;
1962
1963 virtio_device_for_each_vq(portdev->vdev, vq) {
1964 struct port_buffer *buf;
1965
1966 flush_bufs(vq, true);
1967 while ((buf = virtqueue_detach_unused_buf(vq)))
1968 free_buf(buf, true);
1969 }
1970 portdev->vdev->config->del_vqs(portdev->vdev);
1971 kfree(portdev->in_vqs);
1972 kfree(portdev->out_vqs);
1973}
1974
1975static void virtcons_remove(struct virtio_device *vdev)
1976{
1977 struct ports_device *portdev;
1978 struct port *port, *port2;
1979
1980 portdev = vdev->priv;
1981
1982 spin_lock_irq(&pdrvdata_lock);
1983 list_del(&portdev->list);
1984 spin_unlock_irq(&pdrvdata_lock);
1985
1986
1987 vdev->config->reset(vdev);
1988
1989 if (use_multiport(portdev))
1990 cancel_work_sync(&portdev->control_work);
1991 else
1992 cancel_work_sync(&portdev->config_work);
1993
1994 list_for_each_entry_safe(port, port2, &portdev->ports, list)
1995 unplug_port(port);
1996
1997 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007 remove_vqs(portdev);
2008 kfree(portdev);
2009}
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019static int virtcons_probe(struct virtio_device *vdev)
2020{
2021 struct ports_device *portdev;
2022 int err;
2023 bool multiport;
2024 bool early = early_put_chars != NULL;
2025
2026
2027 if (!vdev->config->get &&
2028 (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)
2029 || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {
2030 dev_err(&vdev->dev, "%s failure: config access disabled\n",
2031 __func__);
2032 return -EINVAL;
2033 }
2034
2035
2036 barrier();
2037
2038 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
2039 if (!portdev) {
2040 err = -ENOMEM;
2041 goto fail;
2042 }
2043
2044
2045 portdev->vdev = vdev;
2046 vdev->priv = portdev;
2047
2048 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
2049 &portdev_fops);
2050 if (portdev->chr_major < 0) {
2051 dev_err(&vdev->dev,
2052 "Error %d registering chrdev for device %u\n",
2053 portdev->chr_major, vdev->index);
2054 err = portdev->chr_major;
2055 goto free;
2056 }
2057
2058 multiport = false;
2059 portdev->max_nr_ports = 1;
2060
2061
2062 if (!is_rproc_serial(vdev) &&
2063 virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2064 struct virtio_console_config, max_nr_ports,
2065 &portdev->max_nr_ports) == 0) {
2066 multiport = true;
2067 }
2068
2069 err = init_vqs(portdev);
2070 if (err < 0) {
2071 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
2072 goto free_chrdev;
2073 }
2074
2075 spin_lock_init(&portdev->ports_lock);
2076 INIT_LIST_HEAD(&portdev->ports);
2077 INIT_LIST_HEAD(&portdev->list);
2078
2079 virtio_device_ready(portdev->vdev);
2080
2081 INIT_WORK(&portdev->config_work, &config_work_handler);
2082 INIT_WORK(&portdev->control_work, &control_work_handler);
2083
2084 if (multiport) {
2085 unsigned int nr_added_bufs;
2086
2087 spin_lock_init(&portdev->c_ivq_lock);
2088 spin_lock_init(&portdev->c_ovq_lock);
2089
2090 nr_added_bufs = fill_queue(portdev->c_ivq,
2091 &portdev->c_ivq_lock);
2092 if (!nr_added_bufs) {
2093 dev_err(&vdev->dev,
2094 "Error allocating buffers for control queue\n");
2095
2096
2097
2098
2099 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2100 VIRTIO_CONSOLE_DEVICE_READY, 0);
2101
2102 virtcons_remove(vdev);
2103 return -ENOMEM;
2104 }
2105 } else {
2106
2107
2108
2109
2110 add_port(portdev, 0);
2111 }
2112
2113 spin_lock_irq(&pdrvdata_lock);
2114 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2115 spin_unlock_irq(&pdrvdata_lock);
2116
2117 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2118 VIRTIO_CONSOLE_DEVICE_READY, 1);
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129 if (multiport && early)
2130 wait_for_completion(&early_console_added);
2131
2132 return 0;
2133
2134free_chrdev:
2135 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2136free:
2137 kfree(portdev);
2138fail:
2139 return err;
2140}
2141
2142static struct virtio_device_id id_table[] = {
2143 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2144 { 0 },
2145};
2146
2147static unsigned int features[] = {
2148 VIRTIO_CONSOLE_F_SIZE,
2149 VIRTIO_CONSOLE_F_MULTIPORT,
2150};
2151
2152static struct virtio_device_id rproc_serial_id_table[] = {
2153#if IS_ENABLED(CONFIG_REMOTEPROC)
2154 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2155#endif
2156 { 0 },
2157};
2158
2159static unsigned int rproc_serial_features[] = {
2160};
2161
2162#ifdef CONFIG_PM_SLEEP
2163static int virtcons_freeze(struct virtio_device *vdev)
2164{
2165 struct ports_device *portdev;
2166 struct port *port;
2167
2168 portdev = vdev->priv;
2169
2170 vdev->config->reset(vdev);
2171
2172 if (use_multiport(portdev))
2173 virtqueue_disable_cb(portdev->c_ivq);
2174 cancel_work_sync(&portdev->control_work);
2175 cancel_work_sync(&portdev->config_work);
2176
2177
2178
2179
2180 if (use_multiport(portdev))
2181 virtqueue_disable_cb(portdev->c_ivq);
2182
2183 list_for_each_entry(port, &portdev->ports, list) {
2184 virtqueue_disable_cb(port->in_vq);
2185 virtqueue_disable_cb(port->out_vq);
2186
2187
2188
2189
2190 port->host_connected = false;
2191 remove_port_data(port);
2192 }
2193 remove_vqs(portdev);
2194
2195 return 0;
2196}
2197
2198static int virtcons_restore(struct virtio_device *vdev)
2199{
2200 struct ports_device *portdev;
2201 struct port *port;
2202 int ret;
2203
2204 portdev = vdev->priv;
2205
2206 ret = init_vqs(portdev);
2207 if (ret)
2208 return ret;
2209
2210 virtio_device_ready(portdev->vdev);
2211
2212 if (use_multiport(portdev))
2213 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2214
2215 list_for_each_entry(port, &portdev->ports, list) {
2216 port->in_vq = portdev->in_vqs[port->id];
2217 port->out_vq = portdev->out_vqs[port->id];
2218
2219 fill_queue(port->in_vq, &port->inbuf_lock);
2220
2221
2222 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
2223
2224
2225
2226
2227
2228 if (port->guest_connected)
2229 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
2230 }
2231 return 0;
2232}
2233#endif
2234
2235static struct virtio_driver virtio_console = {
2236 .feature_table = features,
2237 .feature_table_size = ARRAY_SIZE(features),
2238 .driver.name = KBUILD_MODNAME,
2239 .driver.owner = THIS_MODULE,
2240 .id_table = id_table,
2241 .probe = virtcons_probe,
2242 .remove = virtcons_remove,
2243 .config_changed = config_intr,
2244#ifdef CONFIG_PM_SLEEP
2245 .freeze = virtcons_freeze,
2246 .restore = virtcons_restore,
2247#endif
2248};
2249
2250static struct virtio_driver virtio_rproc_serial = {
2251 .feature_table = rproc_serial_features,
2252 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2253 .driver.name = "virtio_rproc_serial",
2254 .driver.owner = THIS_MODULE,
2255 .id_table = rproc_serial_id_table,
2256 .probe = virtcons_probe,
2257 .remove = virtcons_remove,
2258};
2259
2260static int __init init(void)
2261{
2262 int err;
2263
2264 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2265 if (IS_ERR(pdrvdata.class)) {
2266 err = PTR_ERR(pdrvdata.class);
2267 pr_err("Error %d creating virtio-ports class\n", err);
2268 return err;
2269 }
2270
2271 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2272 if (!pdrvdata.debugfs_dir)
2273 pr_warn("Error creating debugfs dir for virtio-ports\n");
2274 INIT_LIST_HEAD(&pdrvdata.consoles);
2275 INIT_LIST_HEAD(&pdrvdata.portdevs);
2276
2277 err = register_virtio_driver(&virtio_console);
2278 if (err < 0) {
2279 pr_err("Error %d registering virtio driver\n", err);
2280 goto free;
2281 }
2282 err = register_virtio_driver(&virtio_rproc_serial);
2283 if (err < 0) {
2284 pr_err("Error %d registering virtio rproc serial driver\n",
2285 err);
2286 goto unregister;
2287 }
2288 return 0;
2289unregister:
2290 unregister_virtio_driver(&virtio_console);
2291free:
2292 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2293 class_destroy(pdrvdata.class);
2294 return err;
2295}
2296
2297static void __exit fini(void)
2298{
2299 reclaim_dma_bufs();
2300
2301 unregister_virtio_driver(&virtio_console);
2302 unregister_virtio_driver(&virtio_rproc_serial);
2303
2304 class_destroy(pdrvdata.class);
2305 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2306}
2307module_init(init);
2308module_exit(fini);
2309
2310MODULE_DEVICE_TABLE(virtio, id_table);
2311MODULE_DESCRIPTION("Virtio console driver");
2312MODULE_LICENSE("GPL");
2313