This source file includes following definitions.
- find_port_by_vtermno
- find_port_by_devt_in_portdev
- find_port_by_devt
- find_port_by_id
- find_port_by_vq
- is_console_port
- is_rproc_serial
- use_multiport
- free_buf
- reclaim_dma_bufs
- alloc_buf
- get_inbuf
- add_inbuf
- discard_port_data
- port_has_data
- __send_control_msg
- send_control_msg
- reclaim_consumed_buffers
- __send_to_port
- fill_readbuf
- will_read_block
- will_write_block
- port_fops_read
- wait_port_writable
- port_fops_write
- pipe_to_sg
- port_fops_splice_write
- port_fops_poll
- port_fops_release
- port_fops_open
- port_fops_fasync
- put_chars
- get_chars
- resize_console
- notifier_add_vio
- notifier_del_vio
- virtio_cons_early_init
- init_port_console
- show_port_name
- port_debugfs_show
- set_console_size
- fill_queue
- send_sigio_to_port
- add_port
- remove_port
- remove_port_data
- unplug_port
- handle_control_message
- control_work_handler
- flush_bufs
- out_intr
- in_intr
- control_intr
- config_intr
- config_work_handler
- init_vqs
- remove_vqs
- virtcons_remove
- virtcons_probe
- virtcons_freeze
- virtcons_restore
- fini
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
40 struct 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 };
65 static struct ports_driver_data pdrvdata = { .next_vtermno = 1};
66
67 static DEFINE_SPINLOCK(pdrvdata_lock);
68 static DECLARE_COMPLETION(early_console_added);
69
70
71 struct 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
91 struct 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[0];
116 };
117
118
119
120
121
122 struct 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
167 struct port_stats {
168 unsigned long bytes_sent, bytes_received, bytes_discarded;
169 };
170
171
172 struct 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
240 static int (*early_put_chars)(u32, const char *, int);
241
242 static 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;
256 out:
257 spin_unlock_irqrestore(&pdrvdata_lock, flags);
258 return port;
259 }
260
261 static 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;
275 out:
276 spin_unlock_irqrestore(&portdev->ports_lock, flags);
277
278 return port;
279 }
280
281 static 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;
294 out:
295 spin_unlock_irqrestore(&pdrvdata_lock, flags);
296 return port;
297 }
298
299 static 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;
309 out:
310 spin_unlock_irqrestore(&portdev->ports_lock, flags);
311
312 return port;
313 }
314
315 static 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;
326 out:
327 spin_unlock_irqrestore(&portdev->ports_lock, flags);
328 return port;
329 }
330
331 static bool is_console_port(struct port *port)
332 {
333 if (port->cons.hvc)
334 return true;
335 return false;
336 }
337
338 static bool is_rproc_serial(const struct virtio_device *vdev)
339 {
340 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
341 }
342
343 static 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
354 static DEFINE_SPINLOCK(dma_bufs_lock);
355 static LIST_HEAD(pending_free_dma_bufs);
356
357 static 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
390 static 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
412 static 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 if (!vdev->dev.parent || !vdev->dev.parent->parent)
442 goto free_buf;
443 buf->dev = vdev->dev.parent->parent;
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
461 free_buf:
462 kfree(buf);
463 fail:
464 return NULL;
465 }
466
467
468 static 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 = len;
479 buf->offset = 0;
480 port->stats.bytes_received += len;
481 }
482 return buf;
483 }
484
485
486
487
488
489
490
491 static 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
506 static 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
532 static 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
547 static 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
578 static 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
589 static 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
604 static 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();
647 done:
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
662 static 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
705 static 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
714 static 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
737 static 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
784 static 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
804 static 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
851 free_buf:
852 free_buf(buf, true);
853 out:
854 return ret;
855 }
856
857 struct sg_list {
858 unsigned int n;
859 unsigned int size;
860 size_t len;
861 struct scatterlist *sg;
862 };
863
864 static 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_steal(pipe, buf) == 0) {
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
908 static 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
923
924
925
926
927
928
929 if (is_rproc_serial(port->out_vq->vdev))
930 return -EINVAL;
931
932
933
934
935
936 pipe_lock(pipe);
937 if (!pipe->nrbufs) {
938 ret = 0;
939 goto error_out;
940 }
941
942 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
943 if (ret < 0)
944 goto error_out;
945
946 buf = alloc_buf(port->portdev->vdev, 0, pipe->nrbufs);
947 if (!buf) {
948 ret = -ENOMEM;
949 goto error_out;
950 }
951
952 sgl.n = 0;
953 sgl.len = 0;
954 sgl.size = pipe->nrbufs;
955 sgl.sg = buf->sg;
956 sg_init_table(sgl.sg, sgl.size);
957 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
958 pipe_unlock(pipe);
959 if (likely(ret > 0))
960 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
961
962 if (unlikely(ret <= 0))
963 free_buf(buf, true);
964 return ret;
965
966 error_out:
967 pipe_unlock(pipe);
968 return ret;
969 }
970
971 static __poll_t port_fops_poll(struct file *filp, poll_table *wait)
972 {
973 struct port *port;
974 __poll_t ret;
975
976 port = filp->private_data;
977 poll_wait(filp, &port->waitqueue, wait);
978
979 if (!port->guest_connected) {
980
981 return EPOLLHUP;
982 }
983 ret = 0;
984 if (!will_read_block(port))
985 ret |= EPOLLIN | EPOLLRDNORM;
986 if (!will_write_block(port))
987 ret |= EPOLLOUT;
988 if (!port->host_connected)
989 ret |= EPOLLHUP;
990
991 return ret;
992 }
993
994 static void remove_port(struct kref *kref);
995
996 static int port_fops_release(struct inode *inode, struct file *filp)
997 {
998 struct port *port;
999
1000 port = filp->private_data;
1001
1002
1003 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1004
1005 spin_lock_irq(&port->inbuf_lock);
1006 port->guest_connected = false;
1007
1008 discard_port_data(port);
1009
1010 spin_unlock_irq(&port->inbuf_lock);
1011
1012 spin_lock_irq(&port->outvq_lock);
1013 reclaim_consumed_buffers(port);
1014 spin_unlock_irq(&port->outvq_lock);
1015
1016 reclaim_dma_bufs();
1017
1018
1019
1020
1021
1022
1023
1024
1025 kref_put(&port->kref, remove_port);
1026
1027 return 0;
1028 }
1029
1030 static int port_fops_open(struct inode *inode, struct file *filp)
1031 {
1032 struct cdev *cdev = inode->i_cdev;
1033 struct port *port;
1034 int ret;
1035
1036
1037 port = find_port_by_devt(cdev->dev);
1038 if (!port) {
1039
1040 return -ENXIO;
1041 }
1042 filp->private_data = port;
1043
1044
1045
1046
1047
1048 if (is_console_port(port)) {
1049 ret = -ENXIO;
1050 goto out;
1051 }
1052
1053
1054 spin_lock_irq(&port->inbuf_lock);
1055 if (port->guest_connected) {
1056 spin_unlock_irq(&port->inbuf_lock);
1057 ret = -EBUSY;
1058 goto out;
1059 }
1060
1061 port->guest_connected = true;
1062 spin_unlock_irq(&port->inbuf_lock);
1063
1064 spin_lock_irq(&port->outvq_lock);
1065
1066
1067
1068
1069
1070 reclaim_consumed_buffers(port);
1071 spin_unlock_irq(&port->outvq_lock);
1072
1073 nonseekable_open(inode, filp);
1074
1075
1076 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1077
1078 return 0;
1079 out:
1080 kref_put(&port->kref, remove_port);
1081 return ret;
1082 }
1083
1084 static int port_fops_fasync(int fd, struct file *filp, int mode)
1085 {
1086 struct port *port;
1087
1088 port = filp->private_data;
1089 return fasync_helper(fd, filp, mode, &port->async_queue);
1090 }
1091
1092
1093
1094
1095
1096
1097
1098 static const struct file_operations port_fops = {
1099 .owner = THIS_MODULE,
1100 .open = port_fops_open,
1101 .read = port_fops_read,
1102 .write = port_fops_write,
1103 .splice_write = port_fops_splice_write,
1104 .poll = port_fops_poll,
1105 .release = port_fops_release,
1106 .fasync = port_fops_fasync,
1107 .llseek = no_llseek,
1108 };
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118 static int put_chars(u32 vtermno, const char *buf, int count)
1119 {
1120 struct port *port;
1121 struct scatterlist sg[1];
1122 void *data;
1123 int ret;
1124
1125 if (unlikely(early_put_chars))
1126 return early_put_chars(vtermno, buf, count);
1127
1128 port = find_port_by_vtermno(vtermno);
1129 if (!port)
1130 return -EPIPE;
1131
1132 data = kmemdup(buf, count, GFP_ATOMIC);
1133 if (!data)
1134 return -ENOMEM;
1135
1136 sg_init_one(sg, data, count);
1137 ret = __send_to_port(port, sg, 1, count, data, false);
1138 kfree(data);
1139 return ret;
1140 }
1141
1142
1143
1144
1145
1146
1147
1148
1149 static int get_chars(u32 vtermno, char *buf, int count)
1150 {
1151 struct port *port;
1152
1153
1154 if (unlikely(early_put_chars))
1155 return 0;
1156
1157 port = find_port_by_vtermno(vtermno);
1158 if (!port)
1159 return -EPIPE;
1160
1161
1162 BUG_ON(!port->in_vq);
1163
1164 return fill_readbuf(port, (__force char __user *)buf, count, false);
1165 }
1166
1167 static void resize_console(struct port *port)
1168 {
1169 struct virtio_device *vdev;
1170
1171
1172 if (!port || !is_console_port(port))
1173 return;
1174
1175 vdev = port->portdev->vdev;
1176
1177
1178 if (!is_rproc_serial(vdev) &&
1179 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
1180 hvc_resize(port->cons.hvc, port->cons.ws);
1181 }
1182
1183
1184 static int notifier_add_vio(struct hvc_struct *hp, int data)
1185 {
1186 struct port *port;
1187
1188 port = find_port_by_vtermno(hp->vtermno);
1189 if (!port)
1190 return -EINVAL;
1191
1192 hp->irq_requested = 1;
1193 resize_console(port);
1194
1195 return 0;
1196 }
1197
1198 static void notifier_del_vio(struct hvc_struct *hp, int data)
1199 {
1200 hp->irq_requested = 0;
1201 }
1202
1203
1204 static const struct hv_ops hv_ops = {
1205 .get_chars = get_chars,
1206 .put_chars = put_chars,
1207 .notifier_add = notifier_add_vio,
1208 .notifier_del = notifier_del_vio,
1209 .notifier_hangup = notifier_del_vio,
1210 };
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1222 {
1223 early_put_chars = put_chars;
1224 return hvc_instantiate(0, 0, &hv_ops);
1225 }
1226
1227 static int init_port_console(struct port *port)
1228 {
1229 int ret;
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248 port->cons.vtermno = pdrvdata.next_vtermno;
1249
1250 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1251 if (IS_ERR(port->cons.hvc)) {
1252 ret = PTR_ERR(port->cons.hvc);
1253 dev_err(port->dev,
1254 "error %d allocating hvc for port\n", ret);
1255 port->cons.hvc = NULL;
1256 return ret;
1257 }
1258 spin_lock_irq(&pdrvdata_lock);
1259 pdrvdata.next_vtermno++;
1260 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1261 spin_unlock_irq(&pdrvdata_lock);
1262 port->guest_connected = true;
1263
1264
1265
1266
1267
1268 if (early_put_chars)
1269 early_put_chars = NULL;
1270
1271
1272 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1273
1274 return 0;
1275 }
1276
1277 static ssize_t show_port_name(struct device *dev,
1278 struct device_attribute *attr, char *buffer)
1279 {
1280 struct port *port;
1281
1282 port = dev_get_drvdata(dev);
1283
1284 return sprintf(buffer, "%s\n", port->name);
1285 }
1286
1287 static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1288
1289 static struct attribute *port_sysfs_entries[] = {
1290 &dev_attr_name.attr,
1291 NULL
1292 };
1293
1294 static const struct attribute_group port_attribute_group = {
1295 .name = NULL,
1296 .attrs = port_sysfs_entries,
1297 };
1298
1299 static int port_debugfs_show(struct seq_file *s, void *data)
1300 {
1301 struct port *port = s->private;
1302
1303 seq_printf(s, "name: %s\n", port->name ? port->name : "");
1304 seq_printf(s, "guest_connected: %d\n", port->guest_connected);
1305 seq_printf(s, "host_connected: %d\n", port->host_connected);
1306 seq_printf(s, "outvq_full: %d\n", port->outvq_full);
1307 seq_printf(s, "bytes_sent: %lu\n", port->stats.bytes_sent);
1308 seq_printf(s, "bytes_received: %lu\n", port->stats.bytes_received);
1309 seq_printf(s, "bytes_discarded: %lu\n", port->stats.bytes_discarded);
1310 seq_printf(s, "is_console: %s\n",
1311 is_console_port(port) ? "yes" : "no");
1312 seq_printf(s, "console_vtermno: %u\n", port->cons.vtermno);
1313
1314 return 0;
1315 }
1316
1317 DEFINE_SHOW_ATTRIBUTE(port_debugfs);
1318
1319 static void set_console_size(struct port *port, u16 rows, u16 cols)
1320 {
1321 if (!port || !is_console_port(port))
1322 return;
1323
1324 port->cons.ws.ws_row = rows;
1325 port->cons.ws.ws_col = cols;
1326 }
1327
1328 static int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1329 {
1330 struct port_buffer *buf;
1331 int nr_added_bufs;
1332 int ret;
1333
1334 nr_added_bufs = 0;
1335 do {
1336 buf = alloc_buf(vq->vdev, PAGE_SIZE, 0);
1337 if (!buf)
1338 return -ENOMEM;
1339
1340 spin_lock_irq(lock);
1341 ret = add_inbuf(vq, buf);
1342 if (ret < 0) {
1343 spin_unlock_irq(lock);
1344 free_buf(buf, true);
1345 return ret;
1346 }
1347 nr_added_bufs++;
1348 spin_unlock_irq(lock);
1349 } while (ret > 0);
1350
1351 return nr_added_bufs;
1352 }
1353
1354 static void send_sigio_to_port(struct port *port)
1355 {
1356 if (port->async_queue && port->guest_connected)
1357 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1358 }
1359
1360 static int add_port(struct ports_device *portdev, u32 id)
1361 {
1362 char debugfs_name[16];
1363 struct port *port;
1364 dev_t devt;
1365 int err;
1366
1367 port = kmalloc(sizeof(*port), GFP_KERNEL);
1368 if (!port) {
1369 err = -ENOMEM;
1370 goto fail;
1371 }
1372 kref_init(&port->kref);
1373
1374 port->portdev = portdev;
1375 port->id = id;
1376
1377 port->name = NULL;
1378 port->inbuf = NULL;
1379 port->cons.hvc = NULL;
1380 port->async_queue = NULL;
1381
1382 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1383 port->cons.vtermno = 0;
1384
1385 port->host_connected = port->guest_connected = false;
1386 port->stats = (struct port_stats) { 0 };
1387
1388 port->outvq_full = false;
1389
1390 port->in_vq = portdev->in_vqs[port->id];
1391 port->out_vq = portdev->out_vqs[port->id];
1392
1393 port->cdev = cdev_alloc();
1394 if (!port->cdev) {
1395 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1396 err = -ENOMEM;
1397 goto free_port;
1398 }
1399 port->cdev->ops = &port_fops;
1400
1401 devt = MKDEV(portdev->chr_major, id);
1402 err = cdev_add(port->cdev, devt, 1);
1403 if (err < 0) {
1404 dev_err(&port->portdev->vdev->dev,
1405 "Error %d adding cdev for port %u\n", err, id);
1406 goto free_cdev;
1407 }
1408 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1409 devt, port, "vport%up%u",
1410 port->portdev->vdev->index, id);
1411 if (IS_ERR(port->dev)) {
1412 err = PTR_ERR(port->dev);
1413 dev_err(&port->portdev->vdev->dev,
1414 "Error %d creating device for port %u\n",
1415 err, id);
1416 goto free_cdev;
1417 }
1418
1419 spin_lock_init(&port->inbuf_lock);
1420 spin_lock_init(&port->outvq_lock);
1421 init_waitqueue_head(&port->waitqueue);
1422
1423
1424
1425
1426
1427 err = fill_queue(port->in_vq, &port->inbuf_lock);
1428 if (err < 0 && err != -ENOSPC) {
1429 dev_err(port->dev, "Error allocating inbufs\n");
1430 goto free_device;
1431 }
1432
1433 if (is_rproc_serial(port->portdev->vdev))
1434
1435
1436
1437
1438
1439 port->host_connected = true;
1440 else if (!use_multiport(port->portdev)) {
1441
1442
1443
1444
1445 err = init_port_console(port);
1446 if (err)
1447 goto free_inbufs;
1448 }
1449
1450 spin_lock_irq(&portdev->ports_lock);
1451 list_add_tail(&port->list, &port->portdev->ports);
1452 spin_unlock_irq(&portdev->ports_lock);
1453
1454
1455
1456
1457
1458
1459 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1460
1461 if (pdrvdata.debugfs_dir) {
1462
1463
1464
1465
1466 snprintf(debugfs_name, sizeof(debugfs_name), "vport%up%u",
1467 port->portdev->vdev->index, id);
1468 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1469 pdrvdata.debugfs_dir,
1470 port,
1471 &port_debugfs_fops);
1472 }
1473 return 0;
1474
1475 free_inbufs:
1476 free_device:
1477 device_destroy(pdrvdata.class, port->dev->devt);
1478 free_cdev:
1479 cdev_del(port->cdev);
1480 free_port:
1481 kfree(port);
1482 fail:
1483
1484 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
1485 return err;
1486 }
1487
1488
1489 static void remove_port(struct kref *kref)
1490 {
1491 struct port *port;
1492
1493 port = container_of(kref, struct port, kref);
1494
1495 kfree(port);
1496 }
1497
1498 static void remove_port_data(struct port *port)
1499 {
1500 spin_lock_irq(&port->inbuf_lock);
1501
1502 discard_port_data(port);
1503 spin_unlock_irq(&port->inbuf_lock);
1504
1505 spin_lock_irq(&port->outvq_lock);
1506 reclaim_consumed_buffers(port);
1507 spin_unlock_irq(&port->outvq_lock);
1508 }
1509
1510
1511
1512
1513
1514
1515 static void unplug_port(struct port *port)
1516 {
1517 spin_lock_irq(&port->portdev->ports_lock);
1518 list_del(&port->list);
1519 spin_unlock_irq(&port->portdev->ports_lock);
1520
1521 spin_lock_irq(&port->inbuf_lock);
1522 if (port->guest_connected) {
1523
1524 send_sigio_to_port(port);
1525
1526
1527 port->guest_connected = false;
1528 port->host_connected = false;
1529
1530 wake_up_interruptible(&port->waitqueue);
1531 }
1532 spin_unlock_irq(&port->inbuf_lock);
1533
1534 if (is_console_port(port)) {
1535 spin_lock_irq(&pdrvdata_lock);
1536 list_del(&port->cons.list);
1537 spin_unlock_irq(&pdrvdata_lock);
1538 hvc_remove(port->cons.hvc);
1539 }
1540
1541 remove_port_data(port);
1542
1543
1544
1545
1546
1547
1548 port->portdev = NULL;
1549
1550 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1551 device_destroy(pdrvdata.class, port->dev->devt);
1552 cdev_del(port->cdev);
1553
1554 debugfs_remove(port->debugfs_file);
1555 kfree(port->name);
1556
1557
1558
1559
1560
1561
1562 kref_put(&port->kref, remove_port);
1563 }
1564
1565
1566 static void handle_control_message(struct virtio_device *vdev,
1567 struct ports_device *portdev,
1568 struct port_buffer *buf)
1569 {
1570 struct virtio_console_control *cpkt;
1571 struct port *port;
1572 size_t name_size;
1573 int err;
1574
1575 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1576
1577 port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
1578 if (!port &&
1579 cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
1580
1581 dev_dbg(&portdev->vdev->dev,
1582 "Invalid index %u in control packet\n", cpkt->id);
1583 return;
1584 }
1585
1586 switch (virtio16_to_cpu(vdev, cpkt->event)) {
1587 case VIRTIO_CONSOLE_PORT_ADD:
1588 if (port) {
1589 dev_dbg(&portdev->vdev->dev,
1590 "Port %u already added\n", port->id);
1591 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1592 break;
1593 }
1594 if (virtio32_to_cpu(vdev, cpkt->id) >=
1595 portdev->max_nr_ports) {
1596 dev_warn(&portdev->vdev->dev,
1597 "Request for adding port with "
1598 "out-of-bound id %u, max. supported id: %u\n",
1599 cpkt->id, portdev->max_nr_ports - 1);
1600 break;
1601 }
1602 add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
1603 break;
1604 case VIRTIO_CONSOLE_PORT_REMOVE:
1605 unplug_port(port);
1606 break;
1607 case VIRTIO_CONSOLE_CONSOLE_PORT:
1608 if (!cpkt->value)
1609 break;
1610 if (is_console_port(port))
1611 break;
1612
1613 init_port_console(port);
1614 complete(&early_console_added);
1615
1616
1617
1618
1619 break;
1620 case VIRTIO_CONSOLE_RESIZE: {
1621 struct {
1622 __u16 rows;
1623 __u16 cols;
1624 } size;
1625
1626 if (!is_console_port(port))
1627 break;
1628
1629 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1630 sizeof(size));
1631 set_console_size(port, size.rows, size.cols);
1632
1633 port->cons.hvc->irq_requested = 1;
1634 resize_console(port);
1635 break;
1636 }
1637 case VIRTIO_CONSOLE_PORT_OPEN:
1638 port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
1639 wake_up_interruptible(&port->waitqueue);
1640
1641
1642
1643
1644
1645 spin_lock_irq(&port->outvq_lock);
1646 reclaim_consumed_buffers(port);
1647 spin_unlock_irq(&port->outvq_lock);
1648
1649
1650
1651
1652
1653 spin_lock_irq(&port->inbuf_lock);
1654 send_sigio_to_port(port);
1655 spin_unlock_irq(&port->inbuf_lock);
1656 break;
1657 case VIRTIO_CONSOLE_PORT_NAME:
1658
1659
1660
1661
1662 if (port->name)
1663 break;
1664
1665
1666
1667
1668
1669 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1670
1671 port->name = kmalloc(name_size, GFP_KERNEL);
1672 if (!port->name) {
1673 dev_err(port->dev,
1674 "Not enough space to store port name\n");
1675 break;
1676 }
1677 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1678 name_size - 1);
1679 port->name[name_size - 1] = 0;
1680
1681
1682
1683
1684
1685 err = sysfs_create_group(&port->dev->kobj,
1686 &port_attribute_group);
1687 if (err) {
1688 dev_err(port->dev,
1689 "Error %d creating sysfs device attributes\n",
1690 err);
1691 } else {
1692
1693
1694
1695
1696
1697 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1698 }
1699 break;
1700 }
1701 }
1702
1703 static void control_work_handler(struct work_struct *work)
1704 {
1705 struct ports_device *portdev;
1706 struct virtqueue *vq;
1707 struct port_buffer *buf;
1708 unsigned int len;
1709
1710 portdev = container_of(work, struct ports_device, control_work);
1711 vq = portdev->c_ivq;
1712
1713 spin_lock(&portdev->c_ivq_lock);
1714 while ((buf = virtqueue_get_buf(vq, &len))) {
1715 spin_unlock(&portdev->c_ivq_lock);
1716
1717 buf->len = len;
1718 buf->offset = 0;
1719
1720 handle_control_message(vq->vdev, portdev, buf);
1721
1722 spin_lock(&portdev->c_ivq_lock);
1723 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1724 dev_warn(&portdev->vdev->dev,
1725 "Error adding buffer to queue\n");
1726 free_buf(buf, false);
1727 }
1728 }
1729 spin_unlock(&portdev->c_ivq_lock);
1730 }
1731
1732 static void flush_bufs(struct virtqueue *vq, bool can_sleep)
1733 {
1734 struct port_buffer *buf;
1735 unsigned int len;
1736
1737 while ((buf = virtqueue_get_buf(vq, &len)))
1738 free_buf(buf, can_sleep);
1739 }
1740
1741 static void out_intr(struct virtqueue *vq)
1742 {
1743 struct port *port;
1744
1745 port = find_port_by_vq(vq->vdev->priv, vq);
1746 if (!port) {
1747 flush_bufs(vq, false);
1748 return;
1749 }
1750
1751 wake_up_interruptible(&port->waitqueue);
1752 }
1753
1754 static void in_intr(struct virtqueue *vq)
1755 {
1756 struct port *port;
1757 unsigned long flags;
1758
1759 port = find_port_by_vq(vq->vdev->priv, vq);
1760 if (!port) {
1761 flush_bufs(vq, false);
1762 return;
1763 }
1764
1765 spin_lock_irqsave(&port->inbuf_lock, flags);
1766 port->inbuf = get_inbuf(port);
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
1786 discard_port_data(port);
1787
1788
1789 send_sigio_to_port(port);
1790
1791 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1792
1793 wake_up_interruptible(&port->waitqueue);
1794
1795 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1796 hvc_kick();
1797 }
1798
1799 static void control_intr(struct virtqueue *vq)
1800 {
1801 struct ports_device *portdev;
1802
1803 portdev = vq->vdev->priv;
1804 schedule_work(&portdev->control_work);
1805 }
1806
1807 static void config_intr(struct virtio_device *vdev)
1808 {
1809 struct ports_device *portdev;
1810
1811 portdev = vdev->priv;
1812
1813 if (!use_multiport(portdev))
1814 schedule_work(&portdev->config_work);
1815 }
1816
1817 static void config_work_handler(struct work_struct *work)
1818 {
1819 struct ports_device *portdev;
1820
1821 portdev = container_of(work, struct ports_device, config_work);
1822 if (!use_multiport(portdev)) {
1823 struct virtio_device *vdev;
1824 struct port *port;
1825 u16 rows, cols;
1826
1827 vdev = portdev->vdev;
1828 virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1829 virtio_cread(vdev, struct virtio_console_config, rows, &rows);
1830
1831 port = find_port_by_id(portdev, 0);
1832 set_console_size(port, rows, cols);
1833
1834
1835
1836
1837
1838
1839
1840
1841 resize_console(port);
1842 }
1843 }
1844
1845 static int init_vqs(struct ports_device *portdev)
1846 {
1847 vq_callback_t **io_callbacks;
1848 char **io_names;
1849 struct virtqueue **vqs;
1850 u32 i, j, nr_ports, nr_queues;
1851 int err;
1852
1853 nr_ports = portdev->max_nr_ports;
1854 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
1855
1856 vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL);
1857 io_callbacks = kmalloc_array(nr_queues, sizeof(vq_callback_t *),
1858 GFP_KERNEL);
1859 io_names = kmalloc_array(nr_queues, sizeof(char *), GFP_KERNEL);
1860 portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1861 GFP_KERNEL);
1862 portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1863 GFP_KERNEL);
1864 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
1865 !portdev->out_vqs) {
1866 err = -ENOMEM;
1867 goto free;
1868 }
1869
1870
1871
1872
1873
1874
1875 j = 0;
1876 io_callbacks[j] = in_intr;
1877 io_callbacks[j + 1] = out_intr;
1878 io_names[j] = "input";
1879 io_names[j + 1] = "output";
1880 j += 2;
1881
1882 if (use_multiport(portdev)) {
1883 io_callbacks[j] = control_intr;
1884 io_callbacks[j + 1] = NULL;
1885 io_names[j] = "control-i";
1886 io_names[j + 1] = "control-o";
1887
1888 for (i = 1; i < nr_ports; i++) {
1889 j += 2;
1890 io_callbacks[j] = in_intr;
1891 io_callbacks[j + 1] = out_intr;
1892 io_names[j] = "input";
1893 io_names[j + 1] = "output";
1894 }
1895 }
1896
1897 err = virtio_find_vqs(portdev->vdev, nr_queues, vqs,
1898 io_callbacks,
1899 (const char **)io_names, NULL);
1900 if (err)
1901 goto free;
1902
1903 j = 0;
1904 portdev->in_vqs[0] = vqs[0];
1905 portdev->out_vqs[0] = vqs[1];
1906 j += 2;
1907 if (use_multiport(portdev)) {
1908 portdev->c_ivq = vqs[j];
1909 portdev->c_ovq = vqs[j + 1];
1910
1911 for (i = 1; i < nr_ports; i++) {
1912 j += 2;
1913 portdev->in_vqs[i] = vqs[j];
1914 portdev->out_vqs[i] = vqs[j + 1];
1915 }
1916 }
1917 kfree(io_names);
1918 kfree(io_callbacks);
1919 kfree(vqs);
1920
1921 return 0;
1922
1923 free:
1924 kfree(portdev->out_vqs);
1925 kfree(portdev->in_vqs);
1926 kfree(io_names);
1927 kfree(io_callbacks);
1928 kfree(vqs);
1929
1930 return err;
1931 }
1932
1933 static const struct file_operations portdev_fops = {
1934 .owner = THIS_MODULE,
1935 };
1936
1937 static void remove_vqs(struct ports_device *portdev)
1938 {
1939 struct virtqueue *vq;
1940
1941 virtio_device_for_each_vq(portdev->vdev, vq) {
1942 struct port_buffer *buf;
1943
1944 flush_bufs(vq, true);
1945 while ((buf = virtqueue_detach_unused_buf(vq)))
1946 free_buf(buf, true);
1947 }
1948 portdev->vdev->config->del_vqs(portdev->vdev);
1949 kfree(portdev->in_vqs);
1950 kfree(portdev->out_vqs);
1951 }
1952
1953 static void virtcons_remove(struct virtio_device *vdev)
1954 {
1955 struct ports_device *portdev;
1956 struct port *port, *port2;
1957
1958 portdev = vdev->priv;
1959
1960 spin_lock_irq(&pdrvdata_lock);
1961 list_del(&portdev->list);
1962 spin_unlock_irq(&pdrvdata_lock);
1963
1964
1965 vdev->config->reset(vdev);
1966
1967 if (use_multiport(portdev))
1968 cancel_work_sync(&portdev->control_work);
1969 else
1970 cancel_work_sync(&portdev->config_work);
1971
1972 list_for_each_entry_safe(port, port2, &portdev->ports, list)
1973 unplug_port(port);
1974
1975 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985 remove_vqs(portdev);
1986 kfree(portdev);
1987 }
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997 static int virtcons_probe(struct virtio_device *vdev)
1998 {
1999 struct ports_device *portdev;
2000 int err;
2001 bool multiport;
2002 bool early = early_put_chars != NULL;
2003
2004
2005 if (!vdev->config->get &&
2006 (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)
2007 || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {
2008 dev_err(&vdev->dev, "%s failure: config access disabled\n",
2009 __func__);
2010 return -EINVAL;
2011 }
2012
2013
2014 barrier();
2015
2016 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
2017 if (!portdev) {
2018 err = -ENOMEM;
2019 goto fail;
2020 }
2021
2022
2023 portdev->vdev = vdev;
2024 vdev->priv = portdev;
2025
2026 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
2027 &portdev_fops);
2028 if (portdev->chr_major < 0) {
2029 dev_err(&vdev->dev,
2030 "Error %d registering chrdev for device %u\n",
2031 portdev->chr_major, vdev->index);
2032 err = portdev->chr_major;
2033 goto free;
2034 }
2035
2036 multiport = false;
2037 portdev->max_nr_ports = 1;
2038
2039
2040 if (!is_rproc_serial(vdev) &&
2041 virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2042 struct virtio_console_config, max_nr_ports,
2043 &portdev->max_nr_ports) == 0) {
2044 multiport = true;
2045 }
2046
2047 err = init_vqs(portdev);
2048 if (err < 0) {
2049 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
2050 goto free_chrdev;
2051 }
2052
2053 spin_lock_init(&portdev->ports_lock);
2054 INIT_LIST_HEAD(&portdev->ports);
2055 INIT_LIST_HEAD(&portdev->list);
2056
2057 virtio_device_ready(portdev->vdev);
2058
2059 INIT_WORK(&portdev->config_work, &config_work_handler);
2060 INIT_WORK(&portdev->control_work, &control_work_handler);
2061
2062 if (multiport) {
2063 spin_lock_init(&portdev->c_ivq_lock);
2064 spin_lock_init(&portdev->c_ovq_lock);
2065
2066 err = fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2067 if (err < 0) {
2068 dev_err(&vdev->dev,
2069 "Error allocating buffers for control queue\n");
2070
2071
2072
2073
2074 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2075 VIRTIO_CONSOLE_DEVICE_READY, 0);
2076
2077 virtcons_remove(vdev);
2078 return err;
2079 }
2080 } else {
2081
2082
2083
2084
2085 add_port(portdev, 0);
2086 }
2087
2088 spin_lock_irq(&pdrvdata_lock);
2089 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2090 spin_unlock_irq(&pdrvdata_lock);
2091
2092 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2093 VIRTIO_CONSOLE_DEVICE_READY, 1);
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104 if (multiport && early)
2105 wait_for_completion(&early_console_added);
2106
2107 return 0;
2108
2109 free_chrdev:
2110 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2111 free:
2112 kfree(portdev);
2113 fail:
2114 return err;
2115 }
2116
2117 static struct virtio_device_id id_table[] = {
2118 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2119 { 0 },
2120 };
2121
2122 static unsigned int features[] = {
2123 VIRTIO_CONSOLE_F_SIZE,
2124 VIRTIO_CONSOLE_F_MULTIPORT,
2125 };
2126
2127 static struct virtio_device_id rproc_serial_id_table[] = {
2128 #if IS_ENABLED(CONFIG_REMOTEPROC)
2129 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2130 #endif
2131 { 0 },
2132 };
2133
2134 static unsigned int rproc_serial_features[] = {
2135 };
2136
2137 #ifdef CONFIG_PM_SLEEP
2138 static int virtcons_freeze(struct virtio_device *vdev)
2139 {
2140 struct ports_device *portdev;
2141 struct port *port;
2142
2143 portdev = vdev->priv;
2144
2145 vdev->config->reset(vdev);
2146
2147 if (use_multiport(portdev))
2148 virtqueue_disable_cb(portdev->c_ivq);
2149 cancel_work_sync(&portdev->control_work);
2150 cancel_work_sync(&portdev->config_work);
2151
2152
2153
2154
2155 if (use_multiport(portdev))
2156 virtqueue_disable_cb(portdev->c_ivq);
2157
2158 list_for_each_entry(port, &portdev->ports, list) {
2159 virtqueue_disable_cb(port->in_vq);
2160 virtqueue_disable_cb(port->out_vq);
2161
2162
2163
2164
2165 port->host_connected = false;
2166 remove_port_data(port);
2167 }
2168 remove_vqs(portdev);
2169
2170 return 0;
2171 }
2172
2173 static int virtcons_restore(struct virtio_device *vdev)
2174 {
2175 struct ports_device *portdev;
2176 struct port *port;
2177 int ret;
2178
2179 portdev = vdev->priv;
2180
2181 ret = init_vqs(portdev);
2182 if (ret)
2183 return ret;
2184
2185 virtio_device_ready(portdev->vdev);
2186
2187 if (use_multiport(portdev))
2188 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2189
2190 list_for_each_entry(port, &portdev->ports, list) {
2191 port->in_vq = portdev->in_vqs[port->id];
2192 port->out_vq = portdev->out_vqs[port->id];
2193
2194 fill_queue(port->in_vq, &port->inbuf_lock);
2195
2196
2197 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
2198
2199
2200
2201
2202
2203 if (port->guest_connected)
2204 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
2205 }
2206 return 0;
2207 }
2208 #endif
2209
2210 static struct virtio_driver virtio_console = {
2211 .feature_table = features,
2212 .feature_table_size = ARRAY_SIZE(features),
2213 .driver.name = KBUILD_MODNAME,
2214 .driver.owner = THIS_MODULE,
2215 .id_table = id_table,
2216 .probe = virtcons_probe,
2217 .remove = virtcons_remove,
2218 .config_changed = config_intr,
2219 #ifdef CONFIG_PM_SLEEP
2220 .freeze = virtcons_freeze,
2221 .restore = virtcons_restore,
2222 #endif
2223 };
2224
2225 static struct virtio_driver virtio_rproc_serial = {
2226 .feature_table = rproc_serial_features,
2227 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2228 .driver.name = "virtio_rproc_serial",
2229 .driver.owner = THIS_MODULE,
2230 .id_table = rproc_serial_id_table,
2231 .probe = virtcons_probe,
2232 .remove = virtcons_remove,
2233 };
2234
2235 static int __init init(void)
2236 {
2237 int err;
2238
2239 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2240 if (IS_ERR(pdrvdata.class)) {
2241 err = PTR_ERR(pdrvdata.class);
2242 pr_err("Error %d creating virtio-ports class\n", err);
2243 return err;
2244 }
2245
2246 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2247 if (!pdrvdata.debugfs_dir)
2248 pr_warn("Error creating debugfs dir for virtio-ports\n");
2249 INIT_LIST_HEAD(&pdrvdata.consoles);
2250 INIT_LIST_HEAD(&pdrvdata.portdevs);
2251
2252 err = register_virtio_driver(&virtio_console);
2253 if (err < 0) {
2254 pr_err("Error %d registering virtio driver\n", err);
2255 goto free;
2256 }
2257 err = register_virtio_driver(&virtio_rproc_serial);
2258 if (err < 0) {
2259 pr_err("Error %d registering virtio rproc serial driver\n",
2260 err);
2261 goto unregister;
2262 }
2263 return 0;
2264 unregister:
2265 unregister_virtio_driver(&virtio_console);
2266 free:
2267 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2268 class_destroy(pdrvdata.class);
2269 return err;
2270 }
2271
2272 static void __exit fini(void)
2273 {
2274 reclaim_dma_bufs();
2275
2276 unregister_virtio_driver(&virtio_console);
2277 unregister_virtio_driver(&virtio_rproc_serial);
2278
2279 class_destroy(pdrvdata.class);
2280 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2281 }
2282 module_init(init);
2283 module_exit(fini);
2284
2285 MODULE_DEVICE_TABLE(virtio, id_table);
2286 MODULE_DESCRIPTION("Virtio console driver");
2287 MODULE_LICENSE("GPL");