1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/types.h>
26#include <linux/major.h>
27#include <linux/errno.h>
28#include <linux/signal.h>
29#include <linux/fcntl.h>
30#include <linux/sched/signal.h>
31#include <linux/interrupt.h>
32#include <linux/tty.h>
33#include <linux/ctype.h>
34#include <linux/mm.h>
35#include <linux/string.h>
36#include <linux/slab.h>
37#include <linux/poll.h>
38#include <linux/bitops.h>
39#include <linux/file.h>
40#include <linux/uaccess.h>
41#include <linux/module.h>
42#include <linux/timer.h>
43#include <linux/tty_flip.h>
44#include <linux/tty_driver.h>
45#include <linux/serial.h>
46#include <linux/kfifo.h>
47#include <linux/skbuff.h>
48#include <net/arp.h>
49#include <linux/ip.h>
50#include <linux/netdevice.h>
51#include <linux/etherdevice.h>
52#include <linux/gsmmux.h>
53
54static int debug;
55module_param(debug, int, 0600);
56
57
58
59#define T1 10
60#define T2 34
61#define N2 3
62
63
64#ifdef DEBUG_TIMING
65#define T1 100
66#define T2 200
67#endif
68
69
70
71
72
73#define MAX_MRU 1500
74#define MAX_MTU 1500
75#define GSM_NET_TX_TIMEOUT (HZ*10)
76
77
78
79
80
81
82
83struct gsm_mux_net {
84 struct kref ref;
85 struct gsm_dlci *dlci;
86};
87
88
89
90
91
92
93
94struct gsm_msg {
95 struct list_head list;
96 u8 addr;
97 u8 ctrl;
98 unsigned int len;
99 unsigned char *data;
100 unsigned char buffer[0];
101};
102
103
104
105
106
107
108
109
110
111
112
113struct gsm_dlci {
114 struct gsm_mux *gsm;
115 int addr;
116 int state;
117#define DLCI_CLOSED 0
118#define DLCI_OPENING 1
119#define DLCI_OPEN 2
120#define DLCI_CLOSING 3
121 struct mutex mutex;
122
123
124 spinlock_t lock;
125 struct timer_list t1;
126 int retries;
127
128 struct tty_port port;
129 struct kfifo *fifo;
130 struct kfifo _fifo;
131 int adaption;
132 int prev_adaption;
133 u32 modem_rx;
134 u32 modem_tx;
135 int dead;
136
137 int throttled;
138 int constipated;
139
140 struct sk_buff *skb;
141 struct sk_buff_head skb_list;
142
143 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
144 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
145 struct net_device *net;
146};
147
148
149
150#define NUM_DLCI 64
151
152
153
154
155
156
157
158
159
160struct gsm_control {
161 u8 cmd;
162 u8 *data;
163 int len;
164 int done;
165 int error;
166};
167
168
169
170
171
172
173
174
175
176
177
178struct gsm_mux {
179 struct tty_struct *tty;
180 spinlock_t lock;
181 struct mutex mutex;
182 unsigned int num;
183 struct kref ref;
184
185
186 wait_queue_head_t event;
187
188
189
190
191 unsigned char *buf;
192 int state;
193#define GSM_SEARCH 0
194#define GSM_START 1
195#define GSM_ADDRESS 2
196#define GSM_CONTROL 3
197#define GSM_LEN 4
198#define GSM_DATA 5
199#define GSM_FCS 6
200#define GSM_OVERRUN 7
201#define GSM_LEN0 8
202#define GSM_LEN1 9
203#define GSM_SSOF 10
204 unsigned int len;
205 unsigned int address;
206 unsigned int count;
207 int escape;
208 int encoding;
209 u8 control;
210 u8 fcs;
211 u8 received_fcs;
212 u8 *txframe;
213
214
215 void (*receive)(struct gsm_mux *gsm, u8 ch);
216 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
217
218 int (*output)(struct gsm_mux *mux, u8 *data, int len);
219
220
221 unsigned int mru;
222 unsigned int mtu;
223 int initiator;
224 int dead;
225 struct gsm_dlci *dlci[NUM_DLCI];
226 int constipated;
227
228 spinlock_t tx_lock;
229 unsigned int tx_bytes;
230#define TX_THRESH_HI 8192
231#define TX_THRESH_LO 2048
232 struct list_head tx_list;
233
234
235 struct timer_list t2_timer;
236 int cretries;
237 struct gsm_control *pending_cmd;
238 spinlock_t control_lock;
239
240
241 int adaption;
242 u8 ftype;
243 int t1, t2;
244 int n2;
245
246
247 unsigned long bad_fcs;
248 unsigned long malformed;
249 unsigned long io_error;
250 unsigned long bad_size;
251 unsigned long unsupported;
252};
253
254
255
256
257
258
259
260#define MAX_MUX 4
261static struct gsm_mux *gsm_mux[MAX_MUX];
262static spinlock_t gsm_mux_lock;
263
264static struct tty_driver *gsm_tty_driver;
265
266
267
268
269
270
271
272#define CR 0x02
273#define EA 0x01
274#define PF 0x10
275
276
277#define RR 0x01
278#define UI 0x03
279#define RNR 0x05
280#define REJ 0x09
281#define DM 0x0F
282#define SABM 0x2F
283#define DISC 0x43
284#define UA 0x63
285#define UIH 0xEF
286
287
288#define CMD_NSC 0x09
289#define CMD_TEST 0x11
290#define CMD_PSC 0x21
291#define CMD_RLS 0x29
292#define CMD_FCOFF 0x31
293#define CMD_PN 0x41
294#define CMD_RPN 0x49
295#define CMD_FCON 0x51
296#define CMD_CLD 0x61
297#define CMD_SNC 0x69
298#define CMD_MSC 0x71
299
300
301#define MDM_FC 0x01
302#define MDM_RTC 0x02
303#define MDM_RTR 0x04
304#define MDM_IC 0x20
305#define MDM_DV 0x40
306
307#define GSM0_SOF 0xF9
308#define GSM1_SOF 0x7E
309#define GSM1_ESCAPE 0x7D
310#define GSM1_ESCAPE_BITS 0x20
311#define XON 0x11
312#define XOFF 0x13
313
314static const struct tty_port_operations gsm_port_ops;
315
316
317
318
319
320static const u8 gsm_fcs8[256] = {
321 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
322 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
323 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
324 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
325 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
326 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
327 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
328 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
329 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
330 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
331 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
332 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
333 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
334 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
335 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
336 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
337 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
338 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
339 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
340 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
341 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
342 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
343 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
344 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
345 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
346 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
347 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
348 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
349 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
350 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
351 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
352 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
353};
354
355#define INIT_FCS 0xFF
356#define GOOD_FCS 0xCF
357
358
359
360
361
362
363
364
365
366
367static inline u8 gsm_fcs_add(u8 fcs, u8 c)
368{
369 return gsm_fcs8[fcs ^ c];
370}
371
372
373
374
375
376
377
378
379
380
381
382static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
383{
384 while (len--)
385 fcs = gsm_fcs8[fcs ^ *c++];
386 return fcs;
387}
388
389
390
391
392
393
394
395
396
397
398static int gsm_read_ea(unsigned int *val, u8 c)
399{
400
401 *val <<= 7;
402 *val |= c >> 1;
403
404 return c & EA;
405}
406
407
408
409
410
411
412
413
414
415static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
416{
417 u8 modembits = 0;
418
419 if (dlci->throttled)
420 modembits |= MDM_FC;
421 if (dlci->modem_tx & TIOCM_DTR)
422 modembits |= MDM_RTC;
423 if (dlci->modem_tx & TIOCM_RTS)
424 modembits |= MDM_RTR;
425 if (dlci->modem_tx & TIOCM_RI)
426 modembits |= MDM_IC;
427 if (dlci->modem_tx & TIOCM_CD)
428 modembits |= MDM_DV;
429 return modembits;
430}
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445static void gsm_print_packet(const char *hdr, int addr, int cr,
446 u8 control, const u8 *data, int dlen)
447{
448 if (!(debug & 1))
449 return;
450
451 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
452
453 switch (control & ~PF) {
454 case SABM:
455 pr_cont("SABM");
456 break;
457 case UA:
458 pr_cont("UA");
459 break;
460 case DISC:
461 pr_cont("DISC");
462 break;
463 case DM:
464 pr_cont("DM");
465 break;
466 case UI:
467 pr_cont("UI");
468 break;
469 case UIH:
470 pr_cont("UIH");
471 break;
472 default:
473 if (!(control & 0x01)) {
474 pr_cont("I N(S)%d N(R)%d",
475 (control & 0x0E) >> 1, (control & 0xE0) >> 5);
476 } else switch (control & 0x0F) {
477 case RR:
478 pr_cont("RR(%d)", (control & 0xE0) >> 5);
479 break;
480 case RNR:
481 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
482 break;
483 case REJ:
484 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
485 break;
486 default:
487 pr_cont("[%02X]", control);
488 }
489 }
490
491 if (control & PF)
492 pr_cont("(P)");
493 else
494 pr_cont("(F)");
495
496 if (dlen) {
497 int ct = 0;
498 while (dlen--) {
499 if (ct % 8 == 0) {
500 pr_cont("\n");
501 pr_debug(" ");
502 }
503 pr_cont("%02X ", *data++);
504 ct++;
505 }
506 }
507 pr_cont("\n");
508}
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
527{
528 int olen = 0;
529 while (len--) {
530 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
531 || *input == XON || *input == XOFF) {
532 *output++ = GSM1_ESCAPE;
533 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
534 olen++;
535 } else
536 *output++ = *input++;
537 olen++;
538 }
539 return olen;
540}
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
557{
558 int len;
559 u8 cbuf[10];
560 u8 ibuf[3];
561
562 switch (gsm->encoding) {
563 case 0:
564 cbuf[0] = GSM0_SOF;
565 cbuf[1] = (addr << 2) | (cr << 1) | EA;
566 cbuf[2] = control;
567 cbuf[3] = EA;
568 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
569 cbuf[5] = GSM0_SOF;
570 len = 6;
571 break;
572 case 1:
573 case 2:
574
575 ibuf[0] = (addr << 2) | (cr << 1) | EA;
576 ibuf[1] = control;
577 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
578
579 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
580
581 cbuf[0] = GSM1_SOF;
582 cbuf[len + 1] = GSM1_SOF;
583
584 len += 2;
585 break;
586 default:
587 WARN_ON(1);
588 return;
589 }
590 gsm->output(gsm, cbuf, len);
591 gsm_print_packet("-->", addr, cr, control, NULL, 0);
592}
593
594
595
596
597
598
599
600
601
602
603static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
604{
605 gsm_send(gsm, addr, 0, control);
606}
607
608
609
610
611
612
613
614
615
616
617static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
618{
619 gsm_send(gsm, addr, 1, control);
620}
621
622
623
624#define HDR_LEN 6
625
626
627
628
629
630
631
632
633
634
635
636
637
638static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
639 u8 ctrl)
640{
641 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
642 GFP_ATOMIC);
643 if (m == NULL)
644 return NULL;
645 m->data = m->buffer + HDR_LEN - 1;
646 m->len = len;
647 m->addr = addr;
648 m->ctrl = ctrl;
649 INIT_LIST_HEAD(&m->list);
650 return m;
651}
652
653
654
655
656
657
658
659
660
661
662
663
664
665static void gsm_data_kick(struct gsm_mux *gsm)
666{
667 struct gsm_msg *msg, *nmsg;
668 int len;
669 int skip_sof = 0;
670
671 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
672 if (gsm->constipated && msg->addr)
673 continue;
674 if (gsm->encoding != 0) {
675 gsm->txframe[0] = GSM1_SOF;
676 len = gsm_stuff_frame(msg->data,
677 gsm->txframe + 1, msg->len);
678 gsm->txframe[len + 1] = GSM1_SOF;
679 len += 2;
680 } else {
681 gsm->txframe[0] = GSM0_SOF;
682 memcpy(gsm->txframe + 1 , msg->data, msg->len);
683 gsm->txframe[msg->len + 1] = GSM0_SOF;
684 len = msg->len + 2;
685 }
686
687 if (debug & 4)
688 print_hex_dump_bytes("gsm_data_kick: ",
689 DUMP_PREFIX_OFFSET,
690 gsm->txframe, len);
691
692 if (gsm->output(gsm, gsm->txframe + skip_sof,
693 len - skip_sof) < 0)
694 break;
695
696 gsm->tx_bytes -= msg->len;
697
698
699 skip_sof = 1;
700
701 list_del(&msg->list);
702 kfree(msg);
703 }
704}
705
706
707
708
709
710
711
712
713
714
715
716static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
717{
718 struct gsm_mux *gsm = dlci->gsm;
719 u8 *dp = msg->data;
720 u8 *fcs = dp + msg->len;
721
722
723 if (gsm->encoding == 0) {
724 if (msg->len < 128)
725 *--dp = (msg->len << 1) | EA;
726 else {
727 *--dp = (msg->len >> 7);
728 *--dp = (msg->len & 127) << 1;
729 }
730 }
731
732 *--dp = msg->ctrl;
733 if (gsm->initiator)
734 *--dp = (msg->addr << 2) | 2 | EA;
735 else
736 *--dp = (msg->addr << 2) | EA;
737 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
738
739 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
740 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
741 *fcs = 0xFF - *fcs;
742
743 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
744 msg->data, msg->len);
745
746
747
748 msg->len += (msg->data - dp) + 1;
749 msg->data = dp;
750
751
752 list_add_tail(&msg->list, &gsm->tx_list);
753 gsm->tx_bytes += msg->len;
754 gsm_data_kick(gsm);
755}
756
757
758
759
760
761
762
763
764
765
766
767static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
768{
769 unsigned long flags;
770 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
771 __gsm_data_queue(dlci, msg);
772 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
773}
774
775
776
777
778
779
780
781
782
783
784
785
786
787static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
788{
789 struct gsm_msg *msg;
790 u8 *dp;
791 int len, total_size, size;
792 int h = dlci->adaption - 1;
793
794 total_size = 0;
795 while (1) {
796 len = kfifo_len(dlci->fifo);
797 if (len == 0)
798 return total_size;
799
800
801 if (len > gsm->mtu)
802 len = gsm->mtu;
803
804 size = len + h;
805
806 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
807
808
809 if (msg == NULL)
810 return -ENOMEM;
811 dp = msg->data;
812 switch (dlci->adaption) {
813 case 1:
814 break;
815 case 2:
816
817 *dp++ = gsm_encode_modem(dlci);
818 break;
819 }
820 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
821 __gsm_data_queue(dlci, msg);
822 total_size += size;
823 }
824
825 return total_size;
826}
827
828
829
830
831
832
833
834
835
836
837
838
839
840static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
841 struct gsm_dlci *dlci)
842{
843 struct gsm_msg *msg;
844 u8 *dp;
845 int len, size;
846 int last = 0, first = 0;
847 int overhead = 0;
848
849
850 if (dlci->adaption == 4)
851 overhead = 1;
852
853
854 if (dlci->skb == NULL) {
855 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
856 if (dlci->skb == NULL)
857 return 0;
858 first = 1;
859 }
860 len = dlci->skb->len + overhead;
861
862
863 if (len > gsm->mtu) {
864 if (dlci->adaption == 3) {
865
866 dev_kfree_skb_any(dlci->skb);
867 dlci->skb = NULL;
868 return 0;
869 }
870 len = gsm->mtu;
871 } else
872 last = 1;
873
874 size = len + overhead;
875 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
876
877
878
879 if (msg == NULL) {
880 skb_queue_tail(&dlci->skb_list, dlci->skb);
881 dlci->skb = NULL;
882 return -ENOMEM;
883 }
884 dp = msg->data;
885
886 if (dlci->adaption == 4) {
887
888 *dp++ = last << 7 | first << 6 | 1;
889 len--;
890 }
891 memcpy(dp, dlci->skb->data, len);
892 skb_pull(dlci->skb, len);
893 __gsm_data_queue(dlci, msg);
894 if (last) {
895 dev_kfree_skb_any(dlci->skb);
896 dlci->skb = NULL;
897 }
898 return size;
899}
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
915{
916 int len;
917
918 int i = 1;
919
920 while (i < NUM_DLCI) {
921 struct gsm_dlci *dlci;
922
923 if (gsm->tx_bytes > TX_THRESH_HI)
924 break;
925 dlci = gsm->dlci[i];
926 if (dlci == NULL || dlci->constipated) {
927 i++;
928 continue;
929 }
930 if (dlci->adaption < 3 && !dlci->net)
931 len = gsm_dlci_data_output(gsm, dlci);
932 else
933 len = gsm_dlci_data_output_framed(gsm, dlci);
934 if (len < 0)
935 break;
936
937 if (len == 0)
938 i++;
939 }
940}
941
942
943
944
945
946
947
948
949
950
951static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
952{
953 unsigned long flags;
954 int sweep;
955
956 if (dlci->constipated)
957 return;
958
959 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
960
961 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
962 if (dlci->gsm->tx_bytes == 0) {
963 if (dlci->net)
964 gsm_dlci_data_output_framed(dlci->gsm, dlci);
965 else
966 gsm_dlci_data_output(dlci->gsm, dlci);
967 }
968 if (sweep)
969 gsm_dlci_data_sweep(dlci->gsm);
970 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
971}
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
989 int dlen)
990{
991 struct gsm_msg *msg;
992 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
993 if (msg == NULL)
994 return;
995 msg->data[0] = (cmd & 0xFE) << 1 | EA;
996 msg->data[1] = (dlen << 1) | EA;
997 memcpy(msg->data + 2, data, dlen);
998 gsm_data_queue(gsm->dlci[0], msg);
999}
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1012 u32 modem, int clen)
1013{
1014 int mlines = 0;
1015 u8 brk = 0;
1016 int fc;
1017
1018
1019
1020
1021
1022
1023 if (clen == 2)
1024 modem = modem & 0x7f;
1025 else {
1026 brk = modem & 0x7f;
1027 modem = (modem >> 7) & 0x7f;
1028 }
1029
1030
1031 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1032 if (fc && !dlci->constipated) {
1033
1034 dlci->constipated = 1;
1035 } else if (!fc && dlci->constipated) {
1036 dlci->constipated = 0;
1037 gsm_dlci_data_kick(dlci);
1038 }
1039
1040
1041 if (modem & MDM_RTC)
1042 mlines |= TIOCM_DSR | TIOCM_DTR;
1043 if (modem & MDM_RTR)
1044 mlines |= TIOCM_RTS | TIOCM_CTS;
1045 if (modem & MDM_IC)
1046 mlines |= TIOCM_RI;
1047 if (modem & MDM_DV)
1048 mlines |= TIOCM_CD;
1049
1050
1051 if (tty) {
1052 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1053 if (!C_CLOCAL(tty))
1054 tty_hangup(tty);
1055 }
1056 if (brk & 0x01)
1057 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
1058 dlci->modem_rx = mlines;
1059}
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1074{
1075 unsigned int addr = 0;
1076 unsigned int modem = 0;
1077 unsigned int brk = 0;
1078 struct gsm_dlci *dlci;
1079 int len = clen;
1080 u8 *dp = data;
1081 struct tty_struct *tty;
1082
1083 while (gsm_read_ea(&addr, *dp++) == 0) {
1084 len--;
1085 if (len == 0)
1086 return;
1087 }
1088
1089 len--;
1090 if (len <= 0)
1091 return;
1092
1093 addr >>= 1;
1094
1095 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1096 return;
1097 dlci = gsm->dlci[addr];
1098
1099 while (gsm_read_ea(&modem, *dp++) == 0) {
1100 len--;
1101 if (len == 0)
1102 return;
1103 }
1104 len--;
1105 if (len > 0) {
1106 while (gsm_read_ea(&brk, *dp++) == 0) {
1107 len--;
1108 if (len == 0)
1109 return;
1110 }
1111 modem <<= 7;
1112 modem |= (brk & 0x7f);
1113 }
1114 tty = tty_port_tty_get(&dlci->port);
1115 gsm_process_modem(tty, dlci, modem, clen);
1116 if (tty) {
1117 tty_wakeup(tty);
1118 tty_kref_put(tty);
1119 }
1120 gsm_control_reply(gsm, CMD_MSC, data, clen);
1121}
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1135{
1136 struct tty_port *port;
1137 unsigned int addr = 0;
1138 u8 bits;
1139 int len = clen;
1140 u8 *dp = data;
1141
1142 while (gsm_read_ea(&addr, *dp++) == 0) {
1143 len--;
1144 if (len == 0)
1145 return;
1146 }
1147
1148 len--;
1149 if (len <= 0)
1150 return;
1151 addr >>= 1;
1152
1153 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1154 return;
1155
1156 bits = *dp;
1157 if ((bits & 1) == 0)
1158 return;
1159
1160 port = &gsm->dlci[addr]->port;
1161
1162 if (bits & 2)
1163 tty_insert_flip_char(port, 0, TTY_OVERRUN);
1164 if (bits & 4)
1165 tty_insert_flip_char(port, 0, TTY_PARITY);
1166 if (bits & 8)
1167 tty_insert_flip_char(port, 0, TTY_FRAME);
1168
1169 tty_flip_buffer_push(port);
1170
1171 gsm_control_reply(gsm, CMD_RLS, data, clen);
1172}
1173
1174static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1189 u8 *data, int clen)
1190{
1191 u8 buf[1];
1192 unsigned long flags;
1193
1194 switch (command) {
1195 case CMD_CLD: {
1196 struct gsm_dlci *dlci = gsm->dlci[0];
1197
1198 if (dlci) {
1199 dlci->dead = 1;
1200 gsm->dead = 1;
1201 gsm_dlci_begin_close(dlci);
1202 }
1203 }
1204 break;
1205 case CMD_TEST:
1206
1207 gsm_control_reply(gsm, CMD_TEST, data, clen);
1208 break;
1209 case CMD_FCON:
1210
1211 gsm->constipated = 0;
1212 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1213
1214 spin_lock_irqsave(&gsm->tx_lock, flags);
1215 gsm_data_kick(gsm);
1216 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1217 break;
1218 case CMD_FCOFF:
1219
1220 gsm->constipated = 1;
1221 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1222 break;
1223 case CMD_MSC:
1224
1225 gsm_control_modem(gsm, data, clen);
1226 break;
1227 case CMD_RLS:
1228
1229 gsm_control_rls(gsm, data, clen);
1230 break;
1231 case CMD_PSC:
1232
1233 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1234 break;
1235
1236 case CMD_PN:
1237 case CMD_RPN:
1238 case CMD_SNC:
1239 default:
1240
1241 buf[0] = command;
1242 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1243 break;
1244 }
1245}
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1261 u8 *data, int clen)
1262{
1263 struct gsm_control *ctrl;
1264 unsigned long flags;
1265
1266 spin_lock_irqsave(&gsm->control_lock, flags);
1267
1268 ctrl = gsm->pending_cmd;
1269
1270 command |= 1;
1271 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1272
1273 del_timer(&gsm->t2_timer);
1274 gsm->pending_cmd = NULL;
1275
1276 if (command == CMD_NSC)
1277 ctrl->error = -EOPNOTSUPP;
1278 ctrl->done = 1;
1279 wake_up(&gsm->event);
1280 }
1281 spin_unlock_irqrestore(&gsm->control_lock, flags);
1282}
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1293{
1294 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1295 if (msg == NULL)
1296 return;
1297 msg->data[0] = (ctrl->cmd << 1) | 2 | EA;
1298 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1299 gsm_data_queue(gsm->dlci[0], msg);
1300}
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313static void gsm_control_retransmit(struct timer_list *t)
1314{
1315 struct gsm_mux *gsm = from_timer(gsm, t, t2_timer);
1316 struct gsm_control *ctrl;
1317 unsigned long flags;
1318 spin_lock_irqsave(&gsm->control_lock, flags);
1319 ctrl = gsm->pending_cmd;
1320 if (ctrl) {
1321 gsm->cretries--;
1322 if (gsm->cretries == 0) {
1323 gsm->pending_cmd = NULL;
1324 ctrl->error = -ETIMEDOUT;
1325 ctrl->done = 1;
1326 spin_unlock_irqrestore(&gsm->control_lock, flags);
1327 wake_up(&gsm->event);
1328 return;
1329 }
1330 gsm_control_transmit(gsm, ctrl);
1331 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1332 }
1333 spin_unlock_irqrestore(&gsm->control_lock, flags);
1334}
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1349 unsigned int command, u8 *data, int clen)
1350{
1351 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1352 GFP_KERNEL);
1353 unsigned long flags;
1354 if (ctrl == NULL)
1355 return NULL;
1356retry:
1357 wait_event(gsm->event, gsm->pending_cmd == NULL);
1358 spin_lock_irqsave(&gsm->control_lock, flags);
1359 if (gsm->pending_cmd != NULL) {
1360 spin_unlock_irqrestore(&gsm->control_lock, flags);
1361 goto retry;
1362 }
1363 ctrl->cmd = command;
1364 ctrl->data = data;
1365 ctrl->len = clen;
1366 gsm->pending_cmd = ctrl;
1367 gsm->cretries = gsm->n2;
1368 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1369 gsm_control_transmit(gsm, ctrl);
1370 spin_unlock_irqrestore(&gsm->control_lock, flags);
1371 return ctrl;
1372}
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1385{
1386 int err;
1387 wait_event(gsm->event, control->done == 1);
1388 err = control->error;
1389 kfree(control);
1390 return err;
1391}
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410static void gsm_dlci_close(struct gsm_dlci *dlci)
1411{
1412 del_timer(&dlci->t1);
1413 if (debug & 8)
1414 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1415 dlci->state = DLCI_CLOSED;
1416 if (dlci->addr != 0) {
1417 tty_port_tty_hangup(&dlci->port, false);
1418 kfifo_reset(dlci->fifo);
1419 } else
1420 dlci->gsm->dead = 1;
1421 wake_up(&dlci->gsm->event);
1422
1423
1424}
1425
1426
1427
1428
1429
1430
1431
1432
1433static void gsm_dlci_open(struct gsm_dlci *dlci)
1434{
1435
1436
1437 del_timer(&dlci->t1);
1438
1439 dlci->state = DLCI_OPEN;
1440 if (debug & 8)
1441 pr_debug("DLCI %d goes open.\n", dlci->addr);
1442 wake_up(&dlci->gsm->event);
1443}
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460static void gsm_dlci_t1(struct timer_list *t)
1461{
1462 struct gsm_dlci *dlci = from_timer(dlci, t, t1);
1463 struct gsm_mux *gsm = dlci->gsm;
1464
1465 switch (dlci->state) {
1466 case DLCI_OPENING:
1467 dlci->retries--;
1468 if (dlci->retries) {
1469 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1470 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1471 } else if (!dlci->addr && gsm->control == (DM | PF)) {
1472 if (debug & 8)
1473 pr_info("DLCI %d opening in ADM mode.\n",
1474 dlci->addr);
1475 gsm_dlci_open(dlci);
1476 } else {
1477 gsm_dlci_close(dlci);
1478 }
1479
1480 break;
1481 case DLCI_CLOSING:
1482 dlci->retries--;
1483 if (dlci->retries) {
1484 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1485 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1486 } else
1487 gsm_dlci_close(dlci);
1488 break;
1489 }
1490}
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1503{
1504 struct gsm_mux *gsm = dlci->gsm;
1505 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1506 return;
1507 dlci->retries = gsm->n2;
1508 dlci->state = DLCI_OPENING;
1509 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1510 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1511}
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1525{
1526 struct gsm_mux *gsm = dlci->gsm;
1527 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1528 return;
1529 dlci->retries = gsm->n2;
1530 dlci->state = DLCI_CLOSING;
1531 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1532 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1533}
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1547{
1548
1549 struct tty_port *port = &dlci->port;
1550 struct tty_struct *tty;
1551 unsigned int modem = 0;
1552 int len = clen;
1553
1554 if (debug & 16)
1555 pr_debug("%d bytes for tty\n", len);
1556 switch (dlci->adaption) {
1557
1558
1559 case 4:
1560 break;
1561
1562 case 3:
1563 break;
1564
1565 case 2:
1566 while (gsm_read_ea(&modem, *data++) == 0) {
1567 len--;
1568 if (len == 0)
1569 return;
1570 }
1571 tty = tty_port_tty_get(port);
1572 if (tty) {
1573 gsm_process_modem(tty, dlci, modem, clen);
1574 tty_kref_put(tty);
1575 }
1576
1577 case 1:
1578 default:
1579 tty_insert_flip_string(port, data, len);
1580 tty_flip_buffer_push(port);
1581 }
1582}
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1597{
1598
1599 unsigned int command = 0;
1600 while (len-- > 0) {
1601 if (gsm_read_ea(&command, *data++) == 1) {
1602 int clen = *data++;
1603 len--;
1604
1605 clen >>= 1;
1606
1607 if (clen > len)
1608 return;
1609 if (command & 1)
1610 gsm_control_message(dlci->gsm, command,
1611 data, clen);
1612 else
1613 gsm_control_response(dlci->gsm, command,
1614 data, clen);
1615 return;
1616 }
1617 }
1618}
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1635{
1636 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1637 if (dlci == NULL)
1638 return NULL;
1639 spin_lock_init(&dlci->lock);
1640 mutex_init(&dlci->mutex);
1641 dlci->fifo = &dlci->_fifo;
1642 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1643 kfree(dlci);
1644 return NULL;
1645 }
1646
1647 skb_queue_head_init(&dlci->skb_list);
1648 timer_setup(&dlci->t1, gsm_dlci_t1, 0);
1649 tty_port_init(&dlci->port);
1650 dlci->port.ops = &gsm_port_ops;
1651 dlci->gsm = gsm;
1652 dlci->addr = addr;
1653 dlci->adaption = gsm->adaption;
1654 dlci->state = DLCI_CLOSED;
1655 if (addr)
1656 dlci->data = gsm_dlci_data;
1657 else
1658 dlci->data = gsm_dlci_command;
1659 gsm->dlci[addr] = dlci;
1660 return dlci;
1661}
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671static void gsm_dlci_free(struct tty_port *port)
1672{
1673 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
1674
1675 del_timer_sync(&dlci->t1);
1676 dlci->gsm->dlci[dlci->addr] = NULL;
1677 kfifo_free(dlci->fifo);
1678 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1679 dev_kfree_skb(dlci->skb);
1680 kfree(dlci);
1681}
1682
1683static inline void dlci_get(struct gsm_dlci *dlci)
1684{
1685 tty_port_get(&dlci->port);
1686}
1687
1688static inline void dlci_put(struct gsm_dlci *dlci)
1689{
1690 tty_port_put(&dlci->port);
1691}
1692
1693static void gsm_destroy_network(struct gsm_dlci *dlci);
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704static void gsm_dlci_release(struct gsm_dlci *dlci)
1705{
1706 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1707 if (tty) {
1708 mutex_lock(&dlci->mutex);
1709 gsm_destroy_network(dlci);
1710 mutex_unlock(&dlci->mutex);
1711
1712 tty_vhangup(tty);
1713
1714 tty_port_tty_set(&dlci->port, NULL);
1715 tty_kref_put(tty);
1716 }
1717 dlci->state = DLCI_CLOSED;
1718 dlci_put(dlci);
1719}
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735static void gsm_queue(struct gsm_mux *gsm)
1736{
1737 struct gsm_dlci *dlci;
1738 u8 cr;
1739 int address;
1740
1741
1742
1743 if ((gsm->control & ~PF) == UI)
1744 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1745 if (gsm->encoding == 0) {
1746
1747
1748
1749
1750 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1751 }
1752 if (gsm->fcs != GOOD_FCS) {
1753 gsm->bad_fcs++;
1754 if (debug & 4)
1755 pr_debug("BAD FCS %02x\n", gsm->fcs);
1756 return;
1757 }
1758 address = gsm->address >> 1;
1759 if (address >= NUM_DLCI)
1760 goto invalid;
1761
1762 cr = gsm->address & 1;
1763
1764 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1765
1766 cr ^= 1 - gsm->initiator;
1767 dlci = gsm->dlci[address];
1768
1769 switch (gsm->control) {
1770 case SABM|PF:
1771 if (cr == 0)
1772 goto invalid;
1773 if (dlci == NULL)
1774 dlci = gsm_dlci_alloc(gsm, address);
1775 if (dlci == NULL)
1776 return;
1777 if (dlci->dead)
1778 gsm_response(gsm, address, DM);
1779 else {
1780 gsm_response(gsm, address, UA);
1781 gsm_dlci_open(dlci);
1782 }
1783 break;
1784 case DISC|PF:
1785 if (cr == 0)
1786 goto invalid;
1787 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1788 gsm_response(gsm, address, DM);
1789 return;
1790 }
1791
1792 gsm_response(gsm, address, UA);
1793 gsm_dlci_close(dlci);
1794 break;
1795 case UA:
1796 case UA|PF:
1797 if (cr == 0 || dlci == NULL)
1798 break;
1799 switch (dlci->state) {
1800 case DLCI_CLOSING:
1801 gsm_dlci_close(dlci);
1802 break;
1803 case DLCI_OPENING:
1804 gsm_dlci_open(dlci);
1805 break;
1806 }
1807 break;
1808 case DM:
1809 case DM|PF:
1810 if (cr)
1811 goto invalid;
1812 if (dlci == NULL)
1813 return;
1814 gsm_dlci_close(dlci);
1815 break;
1816 case UI:
1817 case UI|PF:
1818 case UIH:
1819 case UIH|PF:
1820#if 0
1821 if (cr)
1822 goto invalid;
1823#endif
1824 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1825 gsm_command(gsm, address, DM|PF);
1826 return;
1827 }
1828 dlci->data(dlci, gsm->buf, gsm->len);
1829 break;
1830 default:
1831 goto invalid;
1832 }
1833 return;
1834invalid:
1835 gsm->malformed++;
1836 return;
1837}
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1849{
1850 unsigned int len;
1851
1852 switch (gsm->state) {
1853 case GSM_SEARCH:
1854 if (c == GSM0_SOF) {
1855 gsm->state = GSM_ADDRESS;
1856 gsm->address = 0;
1857 gsm->len = 0;
1858 gsm->fcs = INIT_FCS;
1859 }
1860 break;
1861 case GSM_ADDRESS:
1862 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1863 if (gsm_read_ea(&gsm->address, c))
1864 gsm->state = GSM_CONTROL;
1865 break;
1866 case GSM_CONTROL:
1867 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1868 gsm->control = c;
1869 gsm->state = GSM_LEN0;
1870 break;
1871 case GSM_LEN0:
1872 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1873 if (gsm_read_ea(&gsm->len, c)) {
1874 if (gsm->len > gsm->mru) {
1875 gsm->bad_size++;
1876 gsm->state = GSM_SEARCH;
1877 break;
1878 }
1879 gsm->count = 0;
1880 if (!gsm->len)
1881 gsm->state = GSM_FCS;
1882 else
1883 gsm->state = GSM_DATA;
1884 break;
1885 }
1886 gsm->state = GSM_LEN1;
1887 break;
1888 case GSM_LEN1:
1889 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1890 len = c;
1891 gsm->len |= len << 7;
1892 if (gsm->len > gsm->mru) {
1893 gsm->bad_size++;
1894 gsm->state = GSM_SEARCH;
1895 break;
1896 }
1897 gsm->count = 0;
1898 if (!gsm->len)
1899 gsm->state = GSM_FCS;
1900 else
1901 gsm->state = GSM_DATA;
1902 break;
1903 case GSM_DATA:
1904 gsm->buf[gsm->count++] = c;
1905 if (gsm->count == gsm->len)
1906 gsm->state = GSM_FCS;
1907 break;
1908 case GSM_FCS:
1909 gsm->received_fcs = c;
1910 gsm_queue(gsm);
1911 gsm->state = GSM_SSOF;
1912 break;
1913 case GSM_SSOF:
1914 if (c == GSM0_SOF) {
1915 gsm->state = GSM_SEARCH;
1916 break;
1917 }
1918 break;
1919 }
1920}
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1931{
1932 if (c == GSM1_SOF) {
1933
1934
1935 if (gsm->state == GSM_DATA && gsm->count) {
1936
1937 gsm->count--;
1938 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1939 gsm->len = gsm->count;
1940 gsm_queue(gsm);
1941 gsm->state = GSM_START;
1942 return;
1943 }
1944
1945 if (gsm->state != GSM_START) {
1946 gsm->malformed++;
1947 gsm->state = GSM_START;
1948 }
1949
1950
1951 return;
1952 }
1953
1954 if (c == GSM1_ESCAPE) {
1955 gsm->escape = 1;
1956 return;
1957 }
1958
1959
1960 if (gsm->state == GSM_SEARCH)
1961 return;
1962
1963 if (gsm->escape) {
1964 c ^= GSM1_ESCAPE_BITS;
1965 gsm->escape = 0;
1966 }
1967 switch (gsm->state) {
1968 case GSM_START:
1969 gsm->address = 0;
1970 gsm->state = GSM_ADDRESS;
1971 gsm->fcs = INIT_FCS;
1972
1973 case GSM_ADDRESS:
1974 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1975 if (gsm_read_ea(&gsm->address, c))
1976 gsm->state = GSM_CONTROL;
1977 break;
1978 case GSM_CONTROL:
1979 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1980 gsm->control = c;
1981 gsm->count = 0;
1982 gsm->state = GSM_DATA;
1983 break;
1984 case GSM_DATA:
1985 if (gsm->count > gsm->mru) {
1986 gsm->state = GSM_OVERRUN;
1987 gsm->bad_size++;
1988 } else
1989 gsm->buf[gsm->count++] = c;
1990 break;
1991 case GSM_OVERRUN:
1992 break;
1993 }
1994}
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008static void gsm_error(struct gsm_mux *gsm,
2009 unsigned char data, unsigned char flag)
2010{
2011 gsm->state = GSM_SEARCH;
2012 gsm->io_error++;
2013}
2014
2015static int gsm_disconnect(struct gsm_mux *gsm)
2016{
2017 struct gsm_dlci *dlci = gsm->dlci[0];
2018 struct gsm_control *gc;
2019
2020 if (!dlci)
2021 return 0;
2022
2023
2024
2025 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2026 if (gc)
2027 gsm_control_wait(gsm, gc);
2028
2029 del_timer_sync(&gsm->t2_timer);
2030
2031
2032 gsm_dlci_begin_close(dlci);
2033 wait_event_interruptible(gsm->event,
2034 dlci->state == DLCI_CLOSED);
2035
2036 if (signal_pending(current))
2037 return -EINTR;
2038
2039 return 0;
2040}
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051static void gsm_cleanup_mux(struct gsm_mux *gsm)
2052{
2053 int i;
2054 struct gsm_dlci *dlci = gsm->dlci[0];
2055 struct gsm_msg *txq, *ntxq;
2056
2057 gsm->dead = 1;
2058
2059 spin_lock(&gsm_mux_lock);
2060 for (i = 0; i < MAX_MUX; i++) {
2061 if (gsm_mux[i] == gsm) {
2062 gsm_mux[i] = NULL;
2063 break;
2064 }
2065 }
2066 spin_unlock(&gsm_mux_lock);
2067
2068 if (i == MAX_MUX)
2069 return;
2070
2071 del_timer_sync(&gsm->t2_timer);
2072
2073 if (dlci)
2074 dlci->dead = 1;
2075
2076
2077 mutex_lock(&gsm->mutex);
2078 for (i = 0; i < NUM_DLCI; i++)
2079 if (gsm->dlci[i])
2080 gsm_dlci_release(gsm->dlci[i]);
2081 mutex_unlock(&gsm->mutex);
2082
2083 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2084 kfree(txq);
2085 INIT_LIST_HEAD(&gsm->tx_list);
2086}
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097static int gsm_activate_mux(struct gsm_mux *gsm)
2098{
2099 struct gsm_dlci *dlci;
2100 int i = 0;
2101
2102 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0);
2103 init_waitqueue_head(&gsm->event);
2104 spin_lock_init(&gsm->control_lock);
2105 spin_lock_init(&gsm->tx_lock);
2106
2107 if (gsm->encoding == 0)
2108 gsm->receive = gsm0_receive;
2109 else
2110 gsm->receive = gsm1_receive;
2111 gsm->error = gsm_error;
2112
2113 spin_lock(&gsm_mux_lock);
2114 for (i = 0; i < MAX_MUX; i++) {
2115 if (gsm_mux[i] == NULL) {
2116 gsm->num = i;
2117 gsm_mux[i] = gsm;
2118 break;
2119 }
2120 }
2121 spin_unlock(&gsm_mux_lock);
2122 if (i == MAX_MUX)
2123 return -EBUSY;
2124
2125 dlci = gsm_dlci_alloc(gsm, 0);
2126 if (dlci == NULL)
2127 return -ENOMEM;
2128 gsm->dead = 0;
2129 return 0;
2130}
2131
2132
2133
2134
2135
2136
2137
2138static void gsm_free_mux(struct gsm_mux *gsm)
2139{
2140 kfree(gsm->txframe);
2141 kfree(gsm->buf);
2142 kfree(gsm);
2143}
2144
2145
2146
2147
2148
2149
2150
2151static void gsm_free_muxr(struct kref *ref)
2152{
2153 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2154 gsm_free_mux(gsm);
2155}
2156
2157static inline void mux_get(struct gsm_mux *gsm)
2158{
2159 kref_get(&gsm->ref);
2160}
2161
2162static inline void mux_put(struct gsm_mux *gsm)
2163{
2164 kref_put(&gsm->ref, gsm_free_muxr);
2165}
2166
2167
2168
2169
2170
2171
2172
2173static struct gsm_mux *gsm_alloc_mux(void)
2174{
2175 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2176 if (gsm == NULL)
2177 return NULL;
2178 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2179 if (gsm->buf == NULL) {
2180 kfree(gsm);
2181 return NULL;
2182 }
2183 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2184 if (gsm->txframe == NULL) {
2185 kfree(gsm->buf);
2186 kfree(gsm);
2187 return NULL;
2188 }
2189 spin_lock_init(&gsm->lock);
2190 mutex_init(&gsm->mutex);
2191 kref_init(&gsm->ref);
2192 INIT_LIST_HEAD(&gsm->tx_list);
2193
2194 gsm->t1 = T1;
2195 gsm->t2 = T2;
2196 gsm->n2 = N2;
2197 gsm->ftype = UIH;
2198 gsm->adaption = 1;
2199 gsm->encoding = 1;
2200 gsm->mru = 64;
2201 gsm->mtu = 64;
2202 gsm->dead = 1;
2203
2204 return gsm;
2205}
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2218{
2219 if (tty_write_room(gsm->tty) < len) {
2220 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2221 return -ENOSPC;
2222 }
2223 if (debug & 4)
2224 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2225 data, len);
2226 gsm->tty->ops->write(gsm->tty, data, len);
2227 return len;
2228}
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2241{
2242 int ret, i, base;
2243
2244 gsm->tty = tty_kref_get(tty);
2245 gsm->output = gsmld_output;
2246 ret = gsm_activate_mux(gsm);
2247 if (ret != 0)
2248 tty_kref_put(gsm->tty);
2249 else {
2250
2251
2252 base = gsm->num << 6;
2253 for (i = 1; i < NUM_DLCI; i++)
2254 tty_register_device(gsm_tty_driver, base + i, NULL);
2255 }
2256 return ret;
2257}
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2269{
2270 int i;
2271 int base = gsm->num << 6;
2272
2273 WARN_ON(tty != gsm->tty);
2274 for (i = 1; i < NUM_DLCI; i++)
2275 tty_unregister_device(gsm_tty_driver, base + i);
2276 gsm_cleanup_mux(gsm);
2277 tty_kref_put(gsm->tty);
2278 gsm->tty = NULL;
2279}
2280
2281static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2282 char *fp, int count)
2283{
2284 struct gsm_mux *gsm = tty->disc_data;
2285 const unsigned char *dp;
2286 char *f;
2287 int i;
2288 char flags = TTY_NORMAL;
2289
2290 if (debug & 4)
2291 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2292 cp, count);
2293
2294 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2295 if (f)
2296 flags = *f++;
2297 switch (flags) {
2298 case TTY_NORMAL:
2299 gsm->receive(gsm, *dp);
2300 break;
2301 case TTY_OVERRUN:
2302 case TTY_BREAK:
2303 case TTY_PARITY:
2304 case TTY_FRAME:
2305 gsm->error(gsm, *dp, flags);
2306 break;
2307 default:
2308 WARN_ONCE(1, "%s: unknown flag %d\n",
2309 tty_name(tty), flags);
2310 break;
2311 }
2312 }
2313
2314
2315}
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326static void gsmld_flush_buffer(struct tty_struct *tty)
2327{
2328}
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340static void gsmld_close(struct tty_struct *tty)
2341{
2342 struct gsm_mux *gsm = tty->disc_data;
2343
2344 gsmld_detach_gsm(tty, gsm);
2345
2346 gsmld_flush_buffer(tty);
2347
2348 mux_put(gsm);
2349}
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361static int gsmld_open(struct tty_struct *tty)
2362{
2363 struct gsm_mux *gsm;
2364 int ret;
2365
2366 if (tty->ops->write == NULL)
2367 return -EINVAL;
2368
2369
2370 gsm = gsm_alloc_mux();
2371 if (gsm == NULL)
2372 return -ENOMEM;
2373
2374 tty->disc_data = gsm;
2375 tty->receive_room = 65536;
2376
2377
2378 gsm->encoding = 1;
2379
2380 ret = gsmld_attach_gsm(tty, gsm);
2381 if (ret != 0) {
2382 gsm_cleanup_mux(gsm);
2383 mux_put(gsm);
2384 }
2385 return ret;
2386}
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397static void gsmld_write_wakeup(struct tty_struct *tty)
2398{
2399 struct gsm_mux *gsm = tty->disc_data;
2400 unsigned long flags;
2401
2402
2403 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2404 spin_lock_irqsave(&gsm->tx_lock, flags);
2405 gsm_data_kick(gsm);
2406 if (gsm->tx_bytes < TX_THRESH_LO) {
2407 gsm_dlci_data_sweep(gsm);
2408 }
2409 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2410}
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2428 unsigned char __user *buf, size_t nr)
2429{
2430 return -EOPNOTSUPP;
2431}
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2448 const unsigned char *buf, size_t nr)
2449{
2450 int space = tty_write_room(tty);
2451 if (space >= nr)
2452 return tty->ops->write(tty, buf, nr);
2453 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2454 return -ENOBUFS;
2455}
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file,
2472 poll_table *wait)
2473{
2474 __poll_t mask = 0;
2475 struct gsm_mux *gsm = tty->disc_data;
2476
2477 poll_wait(file, &tty->read_wait, wait);
2478 poll_wait(file, &tty->write_wait, wait);
2479 if (tty_hung_up_p(file))
2480 mask |= EPOLLHUP;
2481 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2482 mask |= EPOLLOUT | EPOLLWRNORM;
2483 if (gsm->dead)
2484 mask |= EPOLLHUP;
2485 return mask;
2486}
2487
2488static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2489 struct gsm_config *c)
2490{
2491 int need_close = 0;
2492 int need_restart = 0;
2493
2494
2495 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2496 return -EOPNOTSUPP;
2497
2498 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2499 return -EINVAL;
2500 if (c->n2 < 3)
2501 return -EINVAL;
2502 if (c->encapsulation > 1)
2503 return -EINVAL;
2504 if (c->initiator > 1)
2505 return -EINVAL;
2506 if (c->i == 0 || c->i > 2)
2507 return -EINVAL;
2508
2509
2510
2511
2512
2513 if (c->t1 != 0 && c->t1 != gsm->t1)
2514 need_restart = 1;
2515 if (c->t2 != 0 && c->t2 != gsm->t2)
2516 need_restart = 1;
2517 if (c->encapsulation != gsm->encoding)
2518 need_restart = 1;
2519 if (c->adaption != gsm->adaption)
2520 need_restart = 1;
2521
2522 if (c->initiator != gsm->initiator)
2523 need_close = 1;
2524 if (c->mru != gsm->mru)
2525 need_restart = 1;
2526 if (c->mtu != gsm->mtu)
2527 need_restart = 1;
2528
2529
2530
2531
2532
2533
2534 if (need_close || need_restart) {
2535 int ret;
2536
2537 ret = gsm_disconnect(gsm);
2538
2539 if (ret)
2540 return ret;
2541 }
2542 if (need_restart)
2543 gsm_cleanup_mux(gsm);
2544
2545 gsm->initiator = c->initiator;
2546 gsm->mru = c->mru;
2547 gsm->mtu = c->mtu;
2548 gsm->encoding = c->encapsulation;
2549 gsm->adaption = c->adaption;
2550 gsm->n2 = c->n2;
2551
2552 if (c->i == 1)
2553 gsm->ftype = UIH;
2554 else if (c->i == 2)
2555 gsm->ftype = UI;
2556
2557 if (c->t1)
2558 gsm->t1 = c->t1;
2559 if (c->t2)
2560 gsm->t2 = c->t2;
2561
2562
2563
2564 if (need_restart)
2565 gsm_activate_mux(gsm);
2566 if (gsm->initiator && need_close)
2567 gsm_dlci_begin_open(gsm->dlci[0]);
2568 return 0;
2569}
2570
2571static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2572 unsigned int cmd, unsigned long arg)
2573{
2574 struct gsm_config c;
2575 struct gsm_mux *gsm = tty->disc_data;
2576
2577 switch (cmd) {
2578 case GSMIOC_GETCONF:
2579 memset(&c, 0, sizeof(c));
2580 c.adaption = gsm->adaption;
2581 c.encapsulation = gsm->encoding;
2582 c.initiator = gsm->initiator;
2583 c.t1 = gsm->t1;
2584 c.t2 = gsm->t2;
2585 c.t3 = 0;
2586 c.n2 = gsm->n2;
2587 if (gsm->ftype == UIH)
2588 c.i = 1;
2589 else
2590 c.i = 2;
2591 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2592 c.mru = gsm->mru;
2593 c.mtu = gsm->mtu;
2594 c.k = 0;
2595 if (copy_to_user((void *)arg, &c, sizeof(c)))
2596 return -EFAULT;
2597 return 0;
2598 case GSMIOC_SETCONF:
2599 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2600 return -EFAULT;
2601 return gsmld_config(tty, gsm, &c);
2602 default:
2603 return n_tty_ioctl_helper(tty, file, cmd, arg);
2604 }
2605}
2606
2607#ifdef CONFIG_COMPAT
2608static long gsmld_compat_ioctl(struct tty_struct *tty, struct file *file,
2609 unsigned int cmd, unsigned long arg)
2610{
2611 return gsmld_ioctl(tty, file, cmd, arg);
2612}
2613#endif
2614
2615
2616
2617
2618
2619
2620static int gsm_mux_net_open(struct net_device *net)
2621{
2622 pr_debug("%s called\n", __func__);
2623 netif_start_queue(net);
2624 return 0;
2625}
2626
2627static int gsm_mux_net_close(struct net_device *net)
2628{
2629 netif_stop_queue(net);
2630 return 0;
2631}
2632
2633static void dlci_net_free(struct gsm_dlci *dlci)
2634{
2635 if (!dlci->net) {
2636 WARN_ON(1);
2637 return;
2638 }
2639 dlci->adaption = dlci->prev_adaption;
2640 dlci->data = dlci->prev_data;
2641 free_netdev(dlci->net);
2642 dlci->net = NULL;
2643}
2644static void net_free(struct kref *ref)
2645{
2646 struct gsm_mux_net *mux_net;
2647 struct gsm_dlci *dlci;
2648
2649 mux_net = container_of(ref, struct gsm_mux_net, ref);
2650 dlci = mux_net->dlci;
2651
2652 if (dlci->net) {
2653 unregister_netdev(dlci->net);
2654 dlci_net_free(dlci);
2655 }
2656}
2657
2658static inline void muxnet_get(struct gsm_mux_net *mux_net)
2659{
2660 kref_get(&mux_net->ref);
2661}
2662
2663static inline void muxnet_put(struct gsm_mux_net *mux_net)
2664{
2665 kref_put(&mux_net->ref, net_free);
2666}
2667
2668static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2669 struct net_device *net)
2670{
2671 struct gsm_mux_net *mux_net = netdev_priv(net);
2672 struct gsm_dlci *dlci = mux_net->dlci;
2673 muxnet_get(mux_net);
2674
2675 skb_queue_head(&dlci->skb_list, skb);
2676 net->stats.tx_packets++;
2677 net->stats.tx_bytes += skb->len;
2678 gsm_dlci_data_kick(dlci);
2679
2680 netif_trans_update(net);
2681 muxnet_put(mux_net);
2682 return NETDEV_TX_OK;
2683}
2684
2685
2686static void gsm_mux_net_tx_timeout(struct net_device *net)
2687{
2688
2689 dev_dbg(&net->dev, "Tx timed out.\n");
2690
2691
2692 net->stats.tx_errors++;
2693}
2694
2695static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2696 unsigned char *in_buf, int size)
2697{
2698 struct net_device *net = dlci->net;
2699 struct sk_buff *skb;
2700 struct gsm_mux_net *mux_net = netdev_priv(net);
2701 muxnet_get(mux_net);
2702
2703
2704 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2705 if (!skb) {
2706
2707 net->stats.rx_dropped++;
2708 muxnet_put(mux_net);
2709 return;
2710 }
2711 skb_reserve(skb, NET_IP_ALIGN);
2712 skb_put_data(skb, in_buf, size);
2713
2714 skb->dev = net;
2715 skb->protocol = htons(ETH_P_IP);
2716
2717
2718 netif_rx(skb);
2719
2720
2721 net->stats.rx_packets++;
2722 net->stats.rx_bytes += size;
2723 muxnet_put(mux_net);
2724 return;
2725}
2726
2727static void gsm_mux_net_init(struct net_device *net)
2728{
2729 static const struct net_device_ops gsm_netdev_ops = {
2730 .ndo_open = gsm_mux_net_open,
2731 .ndo_stop = gsm_mux_net_close,
2732 .ndo_start_xmit = gsm_mux_net_start_xmit,
2733 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2734 };
2735
2736 net->netdev_ops = &gsm_netdev_ops;
2737
2738
2739 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2740 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2741 net->type = ARPHRD_NONE;
2742 net->tx_queue_len = 10;
2743}
2744
2745
2746
2747static void gsm_destroy_network(struct gsm_dlci *dlci)
2748{
2749 struct gsm_mux_net *mux_net;
2750
2751 pr_debug("destroy network interface");
2752 if (!dlci->net)
2753 return;
2754 mux_net = netdev_priv(dlci->net);
2755 muxnet_put(mux_net);
2756}
2757
2758
2759
2760static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2761{
2762 char *netname;
2763 int retval = 0;
2764 struct net_device *net;
2765 struct gsm_mux_net *mux_net;
2766
2767 if (!capable(CAP_NET_ADMIN))
2768 return -EPERM;
2769
2770
2771 if (dlci->adaption > 2)
2772 return -EBUSY;
2773
2774 if (nc->protocol != htons(ETH_P_IP))
2775 return -EPROTONOSUPPORT;
2776
2777 if (nc->adaption != 3 && nc->adaption != 4)
2778 return -EPROTONOSUPPORT;
2779
2780 pr_debug("create network interface");
2781
2782 netname = "gsm%d";
2783 if (nc->if_name[0] != '\0')
2784 netname = nc->if_name;
2785 net = alloc_netdev(sizeof(struct gsm_mux_net), netname,
2786 NET_NAME_UNKNOWN, gsm_mux_net_init);
2787 if (!net) {
2788 pr_err("alloc_netdev failed");
2789 return -ENOMEM;
2790 }
2791 net->mtu = dlci->gsm->mtu;
2792 net->min_mtu = 8;
2793 net->max_mtu = dlci->gsm->mtu;
2794 mux_net = netdev_priv(net);
2795 mux_net->dlci = dlci;
2796 kref_init(&mux_net->ref);
2797 strncpy(nc->if_name, net->name, IFNAMSIZ);
2798
2799
2800 dlci->prev_adaption = dlci->adaption;
2801 dlci->prev_data = dlci->data;
2802 dlci->adaption = nc->adaption;
2803 dlci->data = gsm_mux_rx_netchar;
2804 dlci->net = net;
2805
2806 pr_debug("register netdev");
2807 retval = register_netdev(net);
2808 if (retval) {
2809 pr_err("network register fail %d\n", retval);
2810 dlci_net_free(dlci);
2811 return retval;
2812 }
2813 return net->ifindex;
2814}
2815
2816
2817static struct tty_ldisc_ops tty_ldisc_packet = {
2818 .owner = THIS_MODULE,
2819 .magic = TTY_LDISC_MAGIC,
2820 .name = "n_gsm",
2821 .open = gsmld_open,
2822 .close = gsmld_close,
2823 .flush_buffer = gsmld_flush_buffer,
2824 .read = gsmld_read,
2825 .write = gsmld_write,
2826#ifdef CONFIG_COMPAT
2827 .compat_ioctl = gsmld_compat_ioctl,
2828#endif
2829 .ioctl = gsmld_ioctl,
2830 .poll = gsmld_poll,
2831 .receive_buf = gsmld_receive_buf,
2832 .write_wakeup = gsmld_write_wakeup
2833};
2834
2835
2836
2837
2838
2839#define TX_SIZE 512
2840
2841static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2842{
2843 u8 modembits[5];
2844 struct gsm_control *ctrl;
2845 int len = 2;
2846
2847 if (brk)
2848 len++;
2849
2850 modembits[0] = len << 1 | EA;
2851 modembits[1] = dlci->addr << 2 | 3;
2852 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2853 if (brk)
2854 modembits[3] = brk << 4 | 2 | EA;
2855 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2856 if (ctrl == NULL)
2857 return -ENOMEM;
2858 return gsm_control_wait(dlci->gsm, ctrl);
2859}
2860
2861static int gsm_carrier_raised(struct tty_port *port)
2862{
2863 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2864
2865 if (dlci->state != DLCI_OPEN)
2866 return 0;
2867 if (debug & 2)
2868 return 1;
2869 return dlci->modem_rx & TIOCM_CD;
2870}
2871
2872static void gsm_dtr_rts(struct tty_port *port, int onoff)
2873{
2874 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2875 unsigned int modem_tx = dlci->modem_tx;
2876 if (onoff)
2877 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2878 else
2879 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2880 if (modem_tx != dlci->modem_tx) {
2881 dlci->modem_tx = modem_tx;
2882 gsmtty_modem_update(dlci, 0);
2883 }
2884}
2885
2886static const struct tty_port_operations gsm_port_ops = {
2887 .carrier_raised = gsm_carrier_raised,
2888 .dtr_rts = gsm_dtr_rts,
2889 .destruct = gsm_dlci_free,
2890};
2891
2892static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty)
2893{
2894 struct gsm_mux *gsm;
2895 struct gsm_dlci *dlci;
2896 unsigned int line = tty->index;
2897 unsigned int mux = line >> 6;
2898 bool alloc = false;
2899 int ret;
2900
2901 line = line & 0x3F;
2902
2903 if (mux >= MAX_MUX)
2904 return -ENXIO;
2905
2906 if (gsm_mux[mux] == NULL)
2907 return -EUNATCH;
2908 if (line == 0 || line > 61)
2909 return -ECHRNG;
2910 gsm = gsm_mux[mux];
2911 if (gsm->dead)
2912 return -EL2HLT;
2913
2914
2915
2916
2917 mutex_lock(&gsm->mutex);
2918 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) {
2919 mutex_unlock(&gsm->mutex);
2920 return -EL2NSYNC;
2921 }
2922 dlci = gsm->dlci[line];
2923 if (dlci == NULL) {
2924 alloc = true;
2925 dlci = gsm_dlci_alloc(gsm, line);
2926 }
2927 if (dlci == NULL) {
2928 mutex_unlock(&gsm->mutex);
2929 return -ENOMEM;
2930 }
2931 ret = tty_port_install(&dlci->port, driver, tty);
2932 if (ret) {
2933 if (alloc)
2934 dlci_put(dlci);
2935 mutex_unlock(&gsm->mutex);
2936 return ret;
2937 }
2938
2939 dlci_get(dlci);
2940 dlci_get(gsm->dlci[0]);
2941 mux_get(gsm);
2942 tty->driver_data = dlci;
2943 mutex_unlock(&gsm->mutex);
2944
2945 return 0;
2946}
2947
2948static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2949{
2950 struct gsm_dlci *dlci = tty->driver_data;
2951 struct tty_port *port = &dlci->port;
2952
2953 port->count++;
2954 tty_port_tty_set(port, tty);
2955
2956 dlci->modem_rx = 0;
2957
2958
2959 tty_port_set_initialized(port, 1);
2960
2961 gsm_dlci_begin_open(dlci);
2962
2963 return tty_port_block_til_ready(port, tty, filp);
2964}
2965
2966static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2967{
2968 struct gsm_dlci *dlci = tty->driver_data;
2969
2970 if (dlci == NULL)
2971 return;
2972 if (dlci->state == DLCI_CLOSED)
2973 return;
2974 mutex_lock(&dlci->mutex);
2975 gsm_destroy_network(dlci);
2976 mutex_unlock(&dlci->mutex);
2977 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2978 return;
2979 gsm_dlci_begin_close(dlci);
2980 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty))
2981 tty_port_lower_dtr_rts(&dlci->port);
2982 tty_port_close_end(&dlci->port, tty);
2983 tty_port_tty_set(&dlci->port, NULL);
2984 return;
2985}
2986
2987static void gsmtty_hangup(struct tty_struct *tty)
2988{
2989 struct gsm_dlci *dlci = tty->driver_data;
2990 if (dlci->state == DLCI_CLOSED)
2991 return;
2992 tty_port_hangup(&dlci->port);
2993 gsm_dlci_begin_close(dlci);
2994}
2995
2996static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2997 int len)
2998{
2999 int sent;
3000 struct gsm_dlci *dlci = tty->driver_data;
3001 if (dlci->state == DLCI_CLOSED)
3002 return -EINVAL;
3003
3004 sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
3005
3006 gsm_dlci_data_kick(dlci);
3007 return sent;
3008}
3009
3010static int gsmtty_write_room(struct tty_struct *tty)
3011{
3012 struct gsm_dlci *dlci = tty->driver_data;
3013 if (dlci->state == DLCI_CLOSED)
3014 return -EINVAL;
3015 return TX_SIZE - kfifo_len(dlci->fifo);
3016}
3017
3018static int gsmtty_chars_in_buffer(struct tty_struct *tty)
3019{
3020 struct gsm_dlci *dlci = tty->driver_data;
3021 if (dlci->state == DLCI_CLOSED)
3022 return -EINVAL;
3023 return kfifo_len(dlci->fifo);
3024}
3025
3026static void gsmtty_flush_buffer(struct tty_struct *tty)
3027{
3028 struct gsm_dlci *dlci = tty->driver_data;
3029 if (dlci->state == DLCI_CLOSED)
3030 return;
3031
3032
3033
3034
3035 kfifo_reset(dlci->fifo);
3036
3037}
3038
3039static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3040{
3041
3042
3043
3044}
3045
3046static int gsmtty_tiocmget(struct tty_struct *tty)
3047{
3048 struct gsm_dlci *dlci = tty->driver_data;
3049 if (dlci->state == DLCI_CLOSED)
3050 return -EINVAL;
3051 return dlci->modem_rx;
3052}
3053
3054static int gsmtty_tiocmset(struct tty_struct *tty,
3055 unsigned int set, unsigned int clear)
3056{
3057 struct gsm_dlci *dlci = tty->driver_data;
3058 unsigned int modem_tx = dlci->modem_tx;
3059
3060 if (dlci->state == DLCI_CLOSED)
3061 return -EINVAL;
3062 modem_tx &= ~clear;
3063 modem_tx |= set;
3064
3065 if (modem_tx != dlci->modem_tx) {
3066 dlci->modem_tx = modem_tx;
3067 return gsmtty_modem_update(dlci, 0);
3068 }
3069 return 0;
3070}
3071
3072
3073static int gsmtty_ioctl(struct tty_struct *tty,
3074 unsigned int cmd, unsigned long arg)
3075{
3076 struct gsm_dlci *dlci = tty->driver_data;
3077 struct gsm_netconfig nc;
3078 int index;
3079
3080 if (dlci->state == DLCI_CLOSED)
3081 return -EINVAL;
3082 switch (cmd) {
3083 case GSMIOC_ENABLE_NET:
3084 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3085 return -EFAULT;
3086 nc.if_name[IFNAMSIZ-1] = '\0';
3087
3088 mutex_lock(&dlci->mutex);
3089 index = gsm_create_network(dlci, &nc);
3090 mutex_unlock(&dlci->mutex);
3091 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3092 return -EFAULT;
3093 return index;
3094 case GSMIOC_DISABLE_NET:
3095 if (!capable(CAP_NET_ADMIN))
3096 return -EPERM;
3097 mutex_lock(&dlci->mutex);
3098 gsm_destroy_network(dlci);
3099 mutex_unlock(&dlci->mutex);
3100 return 0;
3101 default:
3102 return -ENOIOCTLCMD;
3103 }
3104}
3105
3106static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3107{
3108 struct gsm_dlci *dlci = tty->driver_data;
3109 if (dlci->state == DLCI_CLOSED)
3110 return;
3111
3112
3113
3114
3115
3116 tty_termios_copy_hw(&tty->termios, old);
3117}
3118
3119static void gsmtty_throttle(struct tty_struct *tty)
3120{
3121 struct gsm_dlci *dlci = tty->driver_data;
3122 if (dlci->state == DLCI_CLOSED)
3123 return;
3124 if (C_CRTSCTS(tty))
3125 dlci->modem_tx &= ~TIOCM_DTR;
3126 dlci->throttled = 1;
3127
3128 gsmtty_modem_update(dlci, 0);
3129}
3130
3131static void gsmtty_unthrottle(struct tty_struct *tty)
3132{
3133 struct gsm_dlci *dlci = tty->driver_data;
3134 if (dlci->state == DLCI_CLOSED)
3135 return;
3136 if (C_CRTSCTS(tty))
3137 dlci->modem_tx |= TIOCM_DTR;
3138 dlci->throttled = 0;
3139
3140 gsmtty_modem_update(dlci, 0);
3141}
3142
3143static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3144{
3145 struct gsm_dlci *dlci = tty->driver_data;
3146 int encode = 0;
3147 if (dlci->state == DLCI_CLOSED)
3148 return -EINVAL;
3149
3150 if (state == -1)
3151
3152 encode = 0x0F;
3153 else if (state > 0) {
3154 encode = state / 200;
3155 if (encode > 0x0F)
3156 encode = 0x0F;
3157 }
3158 return gsmtty_modem_update(dlci, encode);
3159}
3160
3161static void gsmtty_cleanup(struct tty_struct *tty)
3162{
3163 struct gsm_dlci *dlci = tty->driver_data;
3164 struct gsm_mux *gsm = dlci->gsm;
3165
3166 dlci_put(dlci);
3167 dlci_put(gsm->dlci[0]);
3168 mux_put(gsm);
3169}
3170
3171
3172static const struct tty_operations gsmtty_ops = {
3173 .install = gsmtty_install,
3174 .open = gsmtty_open,
3175 .close = gsmtty_close,
3176 .write = gsmtty_write,
3177 .write_room = gsmtty_write_room,
3178 .chars_in_buffer = gsmtty_chars_in_buffer,
3179 .flush_buffer = gsmtty_flush_buffer,
3180 .ioctl = gsmtty_ioctl,
3181 .throttle = gsmtty_throttle,
3182 .unthrottle = gsmtty_unthrottle,
3183 .set_termios = gsmtty_set_termios,
3184 .hangup = gsmtty_hangup,
3185 .wait_until_sent = gsmtty_wait_until_sent,
3186 .tiocmget = gsmtty_tiocmget,
3187 .tiocmset = gsmtty_tiocmset,
3188 .break_ctl = gsmtty_break_ctl,
3189 .cleanup = gsmtty_cleanup,
3190};
3191
3192
3193
3194static int __init gsm_init(void)
3195{
3196
3197 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3198 if (status != 0) {
3199 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3200 status);
3201 return status;
3202 }
3203
3204 gsm_tty_driver = alloc_tty_driver(256);
3205 if (!gsm_tty_driver) {
3206 tty_unregister_ldisc(N_GSM0710);
3207 pr_err("gsm_init: tty allocation failed.\n");
3208 return -EINVAL;
3209 }
3210 gsm_tty_driver->driver_name = "gsmtty";
3211 gsm_tty_driver->name = "gsmtty";
3212 gsm_tty_driver->major = 0;
3213 gsm_tty_driver->minor_start = 0;
3214 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3215 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3216 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3217 | TTY_DRIVER_HARDWARE_BREAK;
3218 gsm_tty_driver->init_termios = tty_std_termios;
3219
3220 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3221 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3222
3223 spin_lock_init(&gsm_mux_lock);
3224
3225 if (tty_register_driver(gsm_tty_driver)) {
3226 put_tty_driver(gsm_tty_driver);
3227 tty_unregister_ldisc(N_GSM0710);
3228 pr_err("gsm_init: tty registration failed.\n");
3229 return -EBUSY;
3230 }
3231 pr_debug("gsm_init: loaded as %d,%d.\n",
3232 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3233 return 0;
3234}
3235
3236static void __exit gsm_exit(void)
3237{
3238 int status = tty_unregister_ldisc(N_GSM0710);
3239 if (status != 0)
3240 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3241 status);
3242 tty_unregister_driver(gsm_tty_driver);
3243 put_tty_driver(gsm_tty_driver);
3244}
3245
3246module_init(gsm_init);
3247module_exit(gsm_exit);
3248
3249
3250MODULE_LICENSE("GPL");
3251MODULE_ALIAS_LDISC(N_GSM0710);
3252