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