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