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