1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/kernel.h>
18#include <linux/sched.h>
19#include <linux/device.h>
20#include <linux/delay.h>
21#include <linux/tty.h>
22#include <linux/tty_flip.h>
23#include <linux/slab.h>
24#include <linux/export.h>
25#include <linux/module.h>
26#include <linux/console.h>
27#include <linux/kthread.h>
28#include <linux/workqueue.h>
29#include <linux/kfifo.h>
30
31#include "u_serial.h"
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80#define QUEUE_SIZE 16
81#define WRITE_BUF_SIZE 8192
82#define GS_CONSOLE_BUF_SIZE 8192
83
84
85struct gs_console {
86 struct console console;
87 struct work_struct work;
88 spinlock_t lock;
89 struct usb_request *req;
90 struct kfifo buf;
91 size_t missed;
92};
93
94
95
96
97
98struct gs_port {
99 struct tty_port port;
100 spinlock_t port_lock;
101
102 struct gserial *port_usb;
103#ifdef CONFIG_U_SERIAL_CONSOLE
104 struct gs_console *console;
105#endif
106
107 u8 port_num;
108
109 struct list_head read_pool;
110 int read_started;
111 int read_allocated;
112 struct list_head read_queue;
113 unsigned n_read;
114 struct delayed_work push;
115
116 struct list_head write_pool;
117 int write_started;
118 int write_allocated;
119 struct kfifo port_write_buf;
120 wait_queue_head_t drain_wait;
121 bool write_busy;
122 wait_queue_head_t close_wait;
123 bool suspended;
124 bool start_delayed;
125
126
127 struct usb_cdc_line_coding port_line_coding;
128};
129
130static struct portmaster {
131 struct mutex lock;
132 struct gs_port *port;
133} ports[MAX_U_SERIAL_PORTS];
134
135#define GS_CLOSE_TIMEOUT 15
136
137
138
139#ifdef VERBOSE_DEBUG
140#ifndef pr_vdebug
141#define pr_vdebug(fmt, arg...) \
142 pr_debug(fmt, ##arg)
143#endif
144#else
145#ifndef pr_vdebug
146#define pr_vdebug(fmt, arg...) \
147 ({ if (0) pr_debug(fmt, ##arg); })
148#endif
149#endif
150
151
152
153
154
155
156
157
158
159
160
161struct usb_request *
162gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
163{
164 struct usb_request *req;
165
166 req = usb_ep_alloc_request(ep, kmalloc_flags);
167
168 if (req != NULL) {
169 req->length = len;
170 req->buf = kmalloc(len, kmalloc_flags);
171 if (req->buf == NULL) {
172 usb_ep_free_request(ep, req);
173 return NULL;
174 }
175 }
176
177 return req;
178}
179EXPORT_SYMBOL_GPL(gs_alloc_req);
180
181
182
183
184
185
186void gs_free_req(struct usb_ep *ep, struct usb_request *req)
187{
188 kfree(req->buf);
189 usb_ep_free_request(ep, req);
190}
191EXPORT_SYMBOL_GPL(gs_free_req);
192
193
194
195
196
197
198
199
200
201
202static unsigned
203gs_send_packet(struct gs_port *port, char *packet, unsigned size)
204{
205 unsigned len;
206
207 len = kfifo_len(&port->port_write_buf);
208 if (len < size)
209 size = len;
210 if (size != 0)
211 size = kfifo_out(&port->port_write_buf, packet, size);
212 return size;
213}
214
215
216
217
218
219
220
221
222
223
224
225
226static int gs_start_tx(struct gs_port *port)
227
228
229
230
231{
232 struct list_head *pool = &port->write_pool;
233 struct usb_ep *in;
234 int status = 0;
235 bool do_tty_wake = false;
236
237 if (!port->port_usb)
238 return status;
239
240 in = port->port_usb->in;
241
242 while (!port->write_busy && !list_empty(pool)) {
243 struct usb_request *req;
244 int len;
245
246 if (port->write_started >= QUEUE_SIZE)
247 break;
248
249 req = list_entry(pool->next, struct usb_request, list);
250 len = gs_send_packet(port, req->buf, in->maxpacket);
251 if (len == 0) {
252 wake_up_interruptible(&port->drain_wait);
253 break;
254 }
255 do_tty_wake = true;
256
257 req->length = len;
258 list_del(&req->list);
259 req->zero = kfifo_is_empty(&port->port_write_buf);
260
261 pr_vdebug("ttyGS%d: tx len=%d, %3ph ...\n", port->port_num, len, req->buf);
262
263
264
265
266
267
268
269
270 port->write_busy = true;
271 spin_unlock(&port->port_lock);
272 status = usb_ep_queue(in, req, GFP_ATOMIC);
273 spin_lock(&port->port_lock);
274 port->write_busy = false;
275
276 if (status) {
277 pr_debug("%s: %s %s err %d\n",
278 __func__, "queue", in->name, status);
279 list_add(&req->list, pool);
280 break;
281 }
282
283 port->write_started++;
284
285
286 if (!port->port_usb)
287 break;
288 }
289
290 if (do_tty_wake && port->port.tty)
291 tty_wakeup(port->port.tty);
292 return status;
293}
294
295
296
297
298static unsigned gs_start_rx(struct gs_port *port)
299
300
301
302
303{
304 struct list_head *pool = &port->read_pool;
305 struct usb_ep *out = port->port_usb->out;
306
307 while (!list_empty(pool)) {
308 struct usb_request *req;
309 int status;
310 struct tty_struct *tty;
311
312
313 tty = port->port.tty;
314 if (!tty)
315 break;
316
317 if (port->read_started >= QUEUE_SIZE)
318 break;
319
320 req = list_entry(pool->next, struct usb_request, list);
321 list_del(&req->list);
322 req->length = out->maxpacket;
323
324
325
326
327 spin_unlock(&port->port_lock);
328 status = usb_ep_queue(out, req, GFP_ATOMIC);
329 spin_lock(&port->port_lock);
330
331 if (status) {
332 pr_debug("%s: %s %s err %d\n",
333 __func__, "queue", out->name, status);
334 list_add(&req->list, pool);
335 break;
336 }
337 port->read_started++;
338
339
340 if (!port->port_usb)
341 break;
342 }
343 return port->read_started;
344}
345
346
347
348
349
350
351
352
353
354
355
356static void gs_rx_push(struct work_struct *work)
357{
358 struct delayed_work *w = to_delayed_work(work);
359 struct gs_port *port = container_of(w, struct gs_port, push);
360 struct tty_struct *tty;
361 struct list_head *queue = &port->read_queue;
362 bool disconnect = false;
363 bool do_push = false;
364
365
366 spin_lock_irq(&port->port_lock);
367 tty = port->port.tty;
368 while (!list_empty(queue)) {
369 struct usb_request *req;
370
371 req = list_first_entry(queue, struct usb_request, list);
372
373
374 if (tty && tty_throttled(tty))
375 break;
376
377 switch (req->status) {
378 case -ESHUTDOWN:
379 disconnect = true;
380 pr_vdebug("ttyGS%d: shutdown\n", port->port_num);
381 break;
382
383 default:
384
385 pr_warn("ttyGS%d: unexpected RX status %d\n",
386 port->port_num, req->status);
387 fallthrough;
388 case 0:
389
390 break;
391 }
392
393
394 if (req->actual && tty) {
395 char *packet = req->buf;
396 unsigned size = req->actual;
397 unsigned n;
398 int count;
399
400
401 n = port->n_read;
402 if (n) {
403 packet += n;
404 size -= n;
405 }
406
407 count = tty_insert_flip_string(&port->port, packet,
408 size);
409 if (count)
410 do_push = true;
411 if (count != size) {
412
413 port->n_read += count;
414 pr_vdebug("ttyGS%d: rx block %d/%d\n",
415 port->port_num, count, req->actual);
416 break;
417 }
418 port->n_read = 0;
419 }
420
421 list_move(&req->list, &port->read_pool);
422 port->read_started--;
423 }
424
425
426
427
428 if (do_push)
429 tty_flip_buffer_push(&port->port);
430
431
432
433
434
435
436
437
438
439 if (!list_empty(queue) && !tty_throttled(tty))
440 schedule_delayed_work(&port->push, 1);
441
442
443 if (!disconnect && port->port_usb)
444 gs_start_rx(port);
445
446 spin_unlock_irq(&port->port_lock);
447}
448
449static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
450{
451 struct gs_port *port = ep->driver_data;
452
453
454 spin_lock(&port->port_lock);
455 list_add_tail(&req->list, &port->read_queue);
456 schedule_delayed_work(&port->push, 0);
457 spin_unlock(&port->port_lock);
458}
459
460static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
461{
462 struct gs_port *port = ep->driver_data;
463
464 spin_lock(&port->port_lock);
465 list_add(&req->list, &port->write_pool);
466 port->write_started--;
467
468 switch (req->status) {
469 default:
470
471 pr_warn("%s: unexpected %s status %d\n",
472 __func__, ep->name, req->status);
473 fallthrough;
474 case 0:
475
476 gs_start_tx(port);
477 break;
478
479 case -ESHUTDOWN:
480
481 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
482 break;
483 }
484
485 spin_unlock(&port->port_lock);
486}
487
488static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
489 int *allocated)
490{
491 struct usb_request *req;
492
493 while (!list_empty(head)) {
494 req = list_entry(head->next, struct usb_request, list);
495 list_del(&req->list);
496 gs_free_req(ep, req);
497 if (allocated)
498 (*allocated)--;
499 }
500}
501
502static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
503 void (*fn)(struct usb_ep *, struct usb_request *),
504 int *allocated)
505{
506 int i;
507 struct usb_request *req;
508 int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
509
510
511
512
513
514 for (i = 0; i < n; i++) {
515 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
516 if (!req)
517 return list_empty(head) ? -ENOMEM : 0;
518 req->complete = fn;
519 list_add_tail(&req->list, head);
520 if (allocated)
521 (*allocated)++;
522 }
523 return 0;
524}
525
526
527
528
529
530
531
532
533
534
535static int gs_start_io(struct gs_port *port)
536{
537 struct list_head *head = &port->read_pool;
538 struct usb_ep *ep = port->port_usb->out;
539 int status;
540 unsigned started;
541
542
543
544
545
546
547
548 status = gs_alloc_requests(ep, head, gs_read_complete,
549 &port->read_allocated);
550 if (status)
551 return status;
552
553 status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
554 gs_write_complete, &port->write_allocated);
555 if (status) {
556 gs_free_requests(ep, head, &port->read_allocated);
557 return status;
558 }
559
560
561 port->n_read = 0;
562 started = gs_start_rx(port);
563
564 if (started) {
565 gs_start_tx(port);
566
567
568 tty_wakeup(port->port.tty);
569 } else {
570 gs_free_requests(ep, head, &port->read_allocated);
571 gs_free_requests(port->port_usb->in, &port->write_pool,
572 &port->write_allocated);
573 status = -EIO;
574 }
575
576 return status;
577}
578
579
580
581
582
583
584
585
586
587
588static int gs_open(struct tty_struct *tty, struct file *file)
589{
590 int port_num = tty->index;
591 struct gs_port *port;
592 int status = 0;
593
594 mutex_lock(&ports[port_num].lock);
595 port = ports[port_num].port;
596 if (!port) {
597 status = -ENODEV;
598 goto out;
599 }
600
601 spin_lock_irq(&port->port_lock);
602
603
604 if (!kfifo_initialized(&port->port_write_buf)) {
605
606 spin_unlock_irq(&port->port_lock);
607
608
609
610
611
612
613 status = kfifo_alloc(&port->port_write_buf,
614 WRITE_BUF_SIZE, GFP_KERNEL);
615 if (status) {
616 pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
617 port_num, tty, file);
618 goto out;
619 }
620
621 spin_lock_irq(&port->port_lock);
622 }
623
624
625 if (port->port.count++)
626 goto exit_unlock_port;
627
628 tty->driver_data = port;
629 port->port.tty = tty;
630
631
632 if (port->port_usb) {
633
634 if (!port->suspended) {
635 struct gserial *gser = port->port_usb;
636
637 pr_debug("gs_open: start ttyGS%d\n", port->port_num);
638 gs_start_io(port);
639
640 if (gser->connect)
641 gser->connect(gser);
642 } else {
643 pr_debug("delay start of ttyGS%d\n", port->port_num);
644 port->start_delayed = true;
645 }
646 }
647
648 pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
649
650exit_unlock_port:
651 spin_unlock_irq(&port->port_lock);
652out:
653 mutex_unlock(&ports[port_num].lock);
654 return status;
655}
656
657static int gs_close_flush_done(struct gs_port *p)
658{
659 int cond;
660
661
662 spin_lock_irq(&p->port_lock);
663 cond = p->port_usb == NULL || !kfifo_len(&p->port_write_buf) ||
664 p->port.count > 1;
665 spin_unlock_irq(&p->port_lock);
666
667 return cond;
668}
669
670static void gs_close(struct tty_struct *tty, struct file *file)
671{
672 struct gs_port *port = tty->driver_data;
673 struct gserial *gser;
674
675 spin_lock_irq(&port->port_lock);
676
677 if (port->port.count != 1) {
678raced_with_open:
679 if (port->port.count == 0)
680 WARN_ON(1);
681 else
682 --port->port.count;
683 goto exit;
684 }
685
686 pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
687
688 gser = port->port_usb;
689 if (gser && !port->suspended && gser->disconnect)
690 gser->disconnect(gser);
691
692
693
694
695 if (kfifo_len(&port->port_write_buf) > 0 && gser) {
696 spin_unlock_irq(&port->port_lock);
697 wait_event_interruptible_timeout(port->drain_wait,
698 gs_close_flush_done(port),
699 GS_CLOSE_TIMEOUT * HZ);
700 spin_lock_irq(&port->port_lock);
701
702 if (port->port.count != 1)
703 goto raced_with_open;
704
705 gser = port->port_usb;
706 }
707
708
709
710
711
712 if (gser == NULL)
713 kfifo_free(&port->port_write_buf);
714 else
715 kfifo_reset(&port->port_write_buf);
716
717 port->start_delayed = false;
718 port->port.count = 0;
719 port->port.tty = NULL;
720
721 pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
722 port->port_num, tty, file);
723
724 wake_up(&port->close_wait);
725exit:
726 spin_unlock_irq(&port->port_lock);
727}
728
729static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
730{
731 struct gs_port *port = tty->driver_data;
732 unsigned long flags;
733
734 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
735 port->port_num, tty, count);
736
737 spin_lock_irqsave(&port->port_lock, flags);
738 if (count)
739 count = kfifo_in(&port->port_write_buf, buf, count);
740
741 if (port->port_usb)
742 gs_start_tx(port);
743 spin_unlock_irqrestore(&port->port_lock, flags);
744
745 return count;
746}
747
748static int gs_put_char(struct tty_struct *tty, unsigned char ch)
749{
750 struct gs_port *port = tty->driver_data;
751 unsigned long flags;
752 int status;
753
754 pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n",
755 port->port_num, tty, ch, __builtin_return_address(0));
756
757 spin_lock_irqsave(&port->port_lock, flags);
758 status = kfifo_put(&port->port_write_buf, ch);
759 spin_unlock_irqrestore(&port->port_lock, flags);
760
761 return status;
762}
763
764static void gs_flush_chars(struct tty_struct *tty)
765{
766 struct gs_port *port = tty->driver_data;
767 unsigned long flags;
768
769 pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
770
771 spin_lock_irqsave(&port->port_lock, flags);
772 if (port->port_usb)
773 gs_start_tx(port);
774 spin_unlock_irqrestore(&port->port_lock, flags);
775}
776
777static unsigned int gs_write_room(struct tty_struct *tty)
778{
779 struct gs_port *port = tty->driver_data;
780 unsigned long flags;
781 unsigned int room = 0;
782
783 spin_lock_irqsave(&port->port_lock, flags);
784 if (port->port_usb)
785 room = kfifo_avail(&port->port_write_buf);
786 spin_unlock_irqrestore(&port->port_lock, flags);
787
788 pr_vdebug("gs_write_room: (%d,%p) room=%u\n",
789 port->port_num, tty, room);
790
791 return room;
792}
793
794static unsigned int gs_chars_in_buffer(struct tty_struct *tty)
795{
796 struct gs_port *port = tty->driver_data;
797 unsigned long flags;
798 unsigned int chars;
799
800 spin_lock_irqsave(&port->port_lock, flags);
801 chars = kfifo_len(&port->port_write_buf);
802 spin_unlock_irqrestore(&port->port_lock, flags);
803
804 pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%u\n",
805 port->port_num, tty, chars);
806
807 return chars;
808}
809
810
811static void gs_unthrottle(struct tty_struct *tty)
812{
813 struct gs_port *port = tty->driver_data;
814 unsigned long flags;
815
816 spin_lock_irqsave(&port->port_lock, flags);
817 if (port->port_usb) {
818
819
820
821
822 pr_vdebug("ttyGS%d: unthrottle\n", port->port_num);
823 schedule_delayed_work(&port->push, 0);
824 }
825 spin_unlock_irqrestore(&port->port_lock, flags);
826}
827
828static int gs_break_ctl(struct tty_struct *tty, int duration)
829{
830 struct gs_port *port = tty->driver_data;
831 int status = 0;
832 struct gserial *gser;
833
834 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
835 port->port_num, duration);
836
837 spin_lock_irq(&port->port_lock);
838 gser = port->port_usb;
839 if (gser && gser->send_break)
840 status = gser->send_break(gser, duration);
841 spin_unlock_irq(&port->port_lock);
842
843 return status;
844}
845
846static const struct tty_operations gs_tty_ops = {
847 .open = gs_open,
848 .close = gs_close,
849 .write = gs_write,
850 .put_char = gs_put_char,
851 .flush_chars = gs_flush_chars,
852 .write_room = gs_write_room,
853 .chars_in_buffer = gs_chars_in_buffer,
854 .unthrottle = gs_unthrottle,
855 .break_ctl = gs_break_ctl,
856};
857
858
859
860static struct tty_driver *gs_tty_driver;
861
862#ifdef CONFIG_U_SERIAL_CONSOLE
863
864static void gs_console_complete_out(struct usb_ep *ep, struct usb_request *req)
865{
866 struct gs_console *cons = req->context;
867
868 switch (req->status) {
869 default:
870 pr_warn("%s: unexpected %s status %d\n",
871 __func__, ep->name, req->status);
872 fallthrough;
873 case 0:
874
875 spin_lock(&cons->lock);
876 req->length = 0;
877 schedule_work(&cons->work);
878 spin_unlock(&cons->lock);
879 break;
880 case -ECONNRESET:
881 case -ESHUTDOWN:
882
883 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
884 break;
885 }
886}
887
888static void __gs_console_push(struct gs_console *cons)
889{
890 struct usb_request *req = cons->req;
891 struct usb_ep *ep;
892 size_t size;
893
894 if (!req)
895 return;
896
897 if (req->length)
898 return;
899
900 ep = cons->console.data;
901 size = kfifo_out(&cons->buf, req->buf, ep->maxpacket);
902 if (!size)
903 return;
904
905 if (cons->missed && ep->maxpacket >= 64) {
906 char buf[64];
907 size_t len;
908
909 len = sprintf(buf, "\n[missed %zu bytes]\n", cons->missed);
910 kfifo_in(&cons->buf, buf, len);
911 cons->missed = 0;
912 }
913
914 req->length = size;
915 if (usb_ep_queue(ep, req, GFP_ATOMIC))
916 req->length = 0;
917}
918
919static void gs_console_work(struct work_struct *work)
920{
921 struct gs_console *cons = container_of(work, struct gs_console, work);
922
923 spin_lock_irq(&cons->lock);
924
925 __gs_console_push(cons);
926
927 spin_unlock_irq(&cons->lock);
928}
929
930static void gs_console_write(struct console *co,
931 const char *buf, unsigned count)
932{
933 struct gs_console *cons = container_of(co, struct gs_console, console);
934 unsigned long flags;
935 size_t n;
936
937 spin_lock_irqsave(&cons->lock, flags);
938
939 n = kfifo_in(&cons->buf, buf, count);
940 if (n < count)
941 cons->missed += count - n;
942
943 if (cons->req && !cons->req->length)
944 schedule_work(&cons->work);
945
946 spin_unlock_irqrestore(&cons->lock, flags);
947}
948
949static struct tty_driver *gs_console_device(struct console *co, int *index)
950{
951 *index = co->index;
952 return gs_tty_driver;
953}
954
955static int gs_console_connect(struct gs_port *port)
956{
957 struct gs_console *cons = port->console;
958 struct usb_request *req;
959 struct usb_ep *ep;
960
961 if (!cons)
962 return 0;
963
964 ep = port->port_usb->in;
965 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
966 if (!req)
967 return -ENOMEM;
968 req->complete = gs_console_complete_out;
969 req->context = cons;
970 req->length = 0;
971
972 spin_lock(&cons->lock);
973 cons->req = req;
974 cons->console.data = ep;
975 spin_unlock(&cons->lock);
976
977 pr_debug("ttyGS%d: console connected!\n", port->port_num);
978
979 schedule_work(&cons->work);
980
981 return 0;
982}
983
984static void gs_console_disconnect(struct gs_port *port)
985{
986 struct gs_console *cons = port->console;
987 struct usb_request *req;
988 struct usb_ep *ep;
989
990 if (!cons)
991 return;
992
993 spin_lock(&cons->lock);
994
995 req = cons->req;
996 ep = cons->console.data;
997 cons->req = NULL;
998
999 spin_unlock(&cons->lock);
1000
1001 if (!req)
1002 return;
1003
1004 usb_ep_dequeue(ep, req);
1005 gs_free_req(ep, req);
1006}
1007
1008static int gs_console_init(struct gs_port *port)
1009{
1010 struct gs_console *cons;
1011 int err;
1012
1013 if (port->console)
1014 return 0;
1015
1016 cons = kzalloc(sizeof(*port->console), GFP_KERNEL);
1017 if (!cons)
1018 return -ENOMEM;
1019
1020 strcpy(cons->console.name, "ttyGS");
1021 cons->console.write = gs_console_write;
1022 cons->console.device = gs_console_device;
1023 cons->console.flags = CON_PRINTBUFFER;
1024 cons->console.index = port->port_num;
1025
1026 INIT_WORK(&cons->work, gs_console_work);
1027 spin_lock_init(&cons->lock);
1028
1029 err = kfifo_alloc(&cons->buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
1030 if (err) {
1031 pr_err("ttyGS%d: allocate console buffer failed\n", port->port_num);
1032 kfree(cons);
1033 return err;
1034 }
1035
1036 port->console = cons;
1037 register_console(&cons->console);
1038
1039 spin_lock_irq(&port->port_lock);
1040 if (port->port_usb)
1041 gs_console_connect(port);
1042 spin_unlock_irq(&port->port_lock);
1043
1044 return 0;
1045}
1046
1047static void gs_console_exit(struct gs_port *port)
1048{
1049 struct gs_console *cons = port->console;
1050
1051 if (!cons)
1052 return;
1053
1054 unregister_console(&cons->console);
1055
1056 spin_lock_irq(&port->port_lock);
1057 if (cons->req)
1058 gs_console_disconnect(port);
1059 spin_unlock_irq(&port->port_lock);
1060
1061 cancel_work_sync(&cons->work);
1062 kfifo_free(&cons->buf);
1063 kfree(cons);
1064 port->console = NULL;
1065}
1066
1067ssize_t gserial_set_console(unsigned char port_num, const char *page, size_t count)
1068{
1069 struct gs_port *port;
1070 bool enable;
1071 int ret;
1072
1073 ret = strtobool(page, &enable);
1074 if (ret)
1075 return ret;
1076
1077 mutex_lock(&ports[port_num].lock);
1078 port = ports[port_num].port;
1079
1080 if (WARN_ON(port == NULL)) {
1081 ret = -ENXIO;
1082 goto out;
1083 }
1084
1085 if (enable)
1086 ret = gs_console_init(port);
1087 else
1088 gs_console_exit(port);
1089out:
1090 mutex_unlock(&ports[port_num].lock);
1091
1092 return ret < 0 ? ret : count;
1093}
1094EXPORT_SYMBOL_GPL(gserial_set_console);
1095
1096ssize_t gserial_get_console(unsigned char port_num, char *page)
1097{
1098 struct gs_port *port;
1099 ssize_t ret;
1100
1101 mutex_lock(&ports[port_num].lock);
1102 port = ports[port_num].port;
1103
1104 if (WARN_ON(port == NULL))
1105 ret = -ENXIO;
1106 else
1107 ret = sprintf(page, "%u\n", !!port->console);
1108
1109 mutex_unlock(&ports[port_num].lock);
1110
1111 return ret;
1112}
1113EXPORT_SYMBOL_GPL(gserial_get_console);
1114
1115#else
1116
1117static int gs_console_connect(struct gs_port *port)
1118{
1119 return 0;
1120}
1121
1122static void gs_console_disconnect(struct gs_port *port)
1123{
1124}
1125
1126static int gs_console_init(struct gs_port *port)
1127{
1128 return -ENOSYS;
1129}
1130
1131static void gs_console_exit(struct gs_port *port)
1132{
1133}
1134
1135#endif
1136
1137static int
1138gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
1139{
1140 struct gs_port *port;
1141 int ret = 0;
1142
1143 mutex_lock(&ports[port_num].lock);
1144 if (ports[port_num].port) {
1145 ret = -EBUSY;
1146 goto out;
1147 }
1148
1149 port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
1150 if (port == NULL) {
1151 ret = -ENOMEM;
1152 goto out;
1153 }
1154
1155 tty_port_init(&port->port);
1156 spin_lock_init(&port->port_lock);
1157 init_waitqueue_head(&port->drain_wait);
1158 init_waitqueue_head(&port->close_wait);
1159
1160 INIT_DELAYED_WORK(&port->push, gs_rx_push);
1161
1162 INIT_LIST_HEAD(&port->read_pool);
1163 INIT_LIST_HEAD(&port->read_queue);
1164 INIT_LIST_HEAD(&port->write_pool);
1165
1166 port->port_num = port_num;
1167 port->port_line_coding = *coding;
1168
1169 ports[port_num].port = port;
1170out:
1171 mutex_unlock(&ports[port_num].lock);
1172 return ret;
1173}
1174
1175static int gs_closed(struct gs_port *port)
1176{
1177 int cond;
1178
1179 spin_lock_irq(&port->port_lock);
1180 cond = port->port.count == 0;
1181 spin_unlock_irq(&port->port_lock);
1182
1183 return cond;
1184}
1185
1186static void gserial_free_port(struct gs_port *port)
1187{
1188 cancel_delayed_work_sync(&port->push);
1189
1190 wait_event(port->close_wait, gs_closed(port));
1191 WARN_ON(port->port_usb != NULL);
1192 tty_port_destroy(&port->port);
1193 kfree(port);
1194}
1195
1196void gserial_free_line(unsigned char port_num)
1197{
1198 struct gs_port *port;
1199
1200 mutex_lock(&ports[port_num].lock);
1201 if (!ports[port_num].port) {
1202 mutex_unlock(&ports[port_num].lock);
1203 return;
1204 }
1205 port = ports[port_num].port;
1206 gs_console_exit(port);
1207 ports[port_num].port = NULL;
1208 mutex_unlock(&ports[port_num].lock);
1209
1210 gserial_free_port(port);
1211 tty_unregister_device(gs_tty_driver, port_num);
1212}
1213EXPORT_SYMBOL_GPL(gserial_free_line);
1214
1215int gserial_alloc_line_no_console(unsigned char *line_num)
1216{
1217 struct usb_cdc_line_coding coding;
1218 struct gs_port *port;
1219 struct device *tty_dev;
1220 int ret;
1221 int port_num;
1222
1223 coding.dwDTERate = cpu_to_le32(9600);
1224 coding.bCharFormat = 8;
1225 coding.bParityType = USB_CDC_NO_PARITY;
1226 coding.bDataBits = USB_CDC_1_STOP_BITS;
1227
1228 for (port_num = 0; port_num < MAX_U_SERIAL_PORTS; port_num++) {
1229 ret = gs_port_alloc(port_num, &coding);
1230 if (ret == -EBUSY)
1231 continue;
1232 if (ret)
1233 return ret;
1234 break;
1235 }
1236 if (ret)
1237 return ret;
1238
1239
1240
1241 port = ports[port_num].port;
1242 tty_dev = tty_port_register_device(&port->port,
1243 gs_tty_driver, port_num, NULL);
1244 if (IS_ERR(tty_dev)) {
1245 pr_err("%s: failed to register tty for port %d, err %ld\n",
1246 __func__, port_num, PTR_ERR(tty_dev));
1247
1248 ret = PTR_ERR(tty_dev);
1249 mutex_lock(&ports[port_num].lock);
1250 ports[port_num].port = NULL;
1251 mutex_unlock(&ports[port_num].lock);
1252 gserial_free_port(port);
1253 goto err;
1254 }
1255 *line_num = port_num;
1256err:
1257 return ret;
1258}
1259EXPORT_SYMBOL_GPL(gserial_alloc_line_no_console);
1260
1261int gserial_alloc_line(unsigned char *line_num)
1262{
1263 int ret = gserial_alloc_line_no_console(line_num);
1264
1265 if (!ret && !*line_num)
1266 gs_console_init(ports[*line_num].port);
1267
1268 return ret;
1269}
1270EXPORT_SYMBOL_GPL(gserial_alloc_line);
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293int gserial_connect(struct gserial *gser, u8 port_num)
1294{
1295 struct gs_port *port;
1296 unsigned long flags;
1297 int status;
1298
1299 if (port_num >= MAX_U_SERIAL_PORTS)
1300 return -ENXIO;
1301
1302 port = ports[port_num].port;
1303 if (!port) {
1304 pr_err("serial line %d not allocated.\n", port_num);
1305 return -EINVAL;
1306 }
1307 if (port->port_usb) {
1308 pr_err("serial line %d is in use.\n", port_num);
1309 return -EBUSY;
1310 }
1311
1312
1313 status = usb_ep_enable(gser->in);
1314 if (status < 0)
1315 return status;
1316 gser->in->driver_data = port;
1317
1318 status = usb_ep_enable(gser->out);
1319 if (status < 0)
1320 goto fail_out;
1321 gser->out->driver_data = port;
1322
1323
1324 spin_lock_irqsave(&port->port_lock, flags);
1325 gser->ioport = port;
1326 port->port_usb = gser;
1327
1328
1329
1330
1331 gser->port_line_coding = port->port_line_coding;
1332
1333
1334
1335
1336
1337
1338 if (port->port.count) {
1339 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1340 gs_start_io(port);
1341 if (gser->connect)
1342 gser->connect(gser);
1343 } else {
1344 if (gser->disconnect)
1345 gser->disconnect(gser);
1346 }
1347
1348 status = gs_console_connect(port);
1349 spin_unlock_irqrestore(&port->port_lock, flags);
1350
1351 return status;
1352
1353fail_out:
1354 usb_ep_disable(gser->in);
1355 return status;
1356}
1357EXPORT_SYMBOL_GPL(gserial_connect);
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369void gserial_disconnect(struct gserial *gser)
1370{
1371 struct gs_port *port = gser->ioport;
1372 unsigned long flags;
1373
1374 if (!port)
1375 return;
1376
1377
1378 spin_lock_irqsave(&port->port_lock, flags);
1379
1380 gs_console_disconnect(port);
1381
1382
1383 port->port_line_coding = gser->port_line_coding;
1384
1385 port->port_usb = NULL;
1386 gser->ioport = NULL;
1387 if (port->port.count > 0) {
1388 wake_up_interruptible(&port->drain_wait);
1389 if (port->port.tty)
1390 tty_hangup(port->port.tty);
1391 }
1392 port->suspended = false;
1393 spin_unlock_irqrestore(&port->port_lock, flags);
1394
1395
1396 usb_ep_disable(gser->out);
1397 usb_ep_disable(gser->in);
1398
1399
1400 spin_lock_irqsave(&port->port_lock, flags);
1401 if (port->port.count == 0)
1402 kfifo_free(&port->port_write_buf);
1403 gs_free_requests(gser->out, &port->read_pool, NULL);
1404 gs_free_requests(gser->out, &port->read_queue, NULL);
1405 gs_free_requests(gser->in, &port->write_pool, NULL);
1406
1407 port->read_allocated = port->read_started =
1408 port->write_allocated = port->write_started = 0;
1409
1410 spin_unlock_irqrestore(&port->port_lock, flags);
1411}
1412EXPORT_SYMBOL_GPL(gserial_disconnect);
1413
1414void gserial_suspend(struct gserial *gser)
1415{
1416 struct gs_port *port = gser->ioport;
1417 unsigned long flags;
1418
1419 spin_lock_irqsave(&port->port_lock, flags);
1420 port->suspended = true;
1421 spin_unlock_irqrestore(&port->port_lock, flags);
1422}
1423EXPORT_SYMBOL_GPL(gserial_suspend);
1424
1425void gserial_resume(struct gserial *gser)
1426{
1427 struct gs_port *port = gser->ioport;
1428 unsigned long flags;
1429
1430 spin_lock_irqsave(&port->port_lock, flags);
1431 port->suspended = false;
1432 if (!port->start_delayed) {
1433 spin_unlock_irqrestore(&port->port_lock, flags);
1434 return;
1435 }
1436
1437 pr_debug("delayed start ttyGS%d\n", port->port_num);
1438 gs_start_io(port);
1439 if (gser->connect)
1440 gser->connect(gser);
1441 port->start_delayed = false;
1442 spin_unlock_irqrestore(&port->port_lock, flags);
1443}
1444EXPORT_SYMBOL_GPL(gserial_resume);
1445
1446static int userial_init(void)
1447{
1448 struct tty_driver *driver;
1449 unsigned i;
1450 int status;
1451
1452 driver = tty_alloc_driver(MAX_U_SERIAL_PORTS, TTY_DRIVER_REAL_RAW |
1453 TTY_DRIVER_DYNAMIC_DEV);
1454 if (IS_ERR(driver))
1455 return PTR_ERR(driver);
1456
1457 driver->driver_name = "g_serial";
1458 driver->name = "ttyGS";
1459
1460
1461 driver->type = TTY_DRIVER_TYPE_SERIAL;
1462 driver->subtype = SERIAL_TYPE_NORMAL;
1463 driver->init_termios = tty_std_termios;
1464
1465
1466
1467
1468
1469 driver->init_termios.c_cflag =
1470 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1471 driver->init_termios.c_ispeed = 9600;
1472 driver->init_termios.c_ospeed = 9600;
1473
1474 tty_set_operations(driver, &gs_tty_ops);
1475 for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
1476 mutex_init(&ports[i].lock);
1477
1478
1479 status = tty_register_driver(driver);
1480 if (status) {
1481 pr_err("%s: cannot register, err %d\n",
1482 __func__, status);
1483 goto fail;
1484 }
1485
1486 gs_tty_driver = driver;
1487
1488 pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1489 MAX_U_SERIAL_PORTS,
1490 (MAX_U_SERIAL_PORTS == 1) ? "" : "s");
1491
1492 return status;
1493fail:
1494 tty_driver_kref_put(driver);
1495 return status;
1496}
1497module_init(userial_init);
1498
1499static void userial_cleanup(void)
1500{
1501 tty_unregister_driver(gs_tty_driver);
1502 tty_driver_kref_put(gs_tty_driver);
1503 gs_tty_driver = NULL;
1504}
1505module_exit(userial_cleanup);
1506
1507MODULE_LICENSE("GPL");
1508