1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * n_gsm.c GSM 0710 tty multiplexor 4 * Copyright (c) 2009/10 Intel Corporation 5 * 6 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE * 7 * 8 * TO DO: 9 * Mostly done: ioctls for setting modes/timing 10 * Partly done: hooks so you can pull off frames to non tty devs 11 * Restart DLCI 0 when it closes ? 12 * Improve the tx engine 13 * Resolve tx side locking by adding a queue_head and routing 14 * all control traffic via it 15 * General tidy/document 16 * Review the locking/move to refcounts more (mux now moved to an 17 * alloc/free model ready) 18 * Use newest tty open/close port helpers and install hooks 19 * What to do about power functions ? 20 * Termios setting and negotiation 21 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets 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 #include "tty.h" 54 55 static int debug; 56 module_param(debug, int, 0600); 57 58 /* Defaults: these are from the specification */ 59 60 #define T1 10 /* 100mS */ 61 #define T2 34 /* 333mS */ 62 #define N2 3 /* Retry 3 times */ 63 64 /* Use long timers for testing at low speed with debug on */ 65 #ifdef DEBUG_TIMING 66 #define T1 100 67 #define T2 200 68 #endif 69 70 /* 71 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte 72 * limits so this is plenty 73 */ 74 #define MAX_MRU 1500 75 #define MAX_MTU 1500 76 #define GSM_NET_TX_TIMEOUT (HZ*10) 77 78 /* 79 * struct gsm_mux_net - network interface 80 * 81 * Created when net interface is initialized. 82 */ 83 struct gsm_mux_net { 84 struct kref ref; 85 struct gsm_dlci *dlci; 86 }; 87 88 /* 89 * Each block of data we have queued to go out is in the form of 90 * a gsm_msg which holds everything we need in a link layer independent 91 * format 92 */ 93 94 struct gsm_msg { 95 struct list_head list; 96 u8 addr; /* DLCI address + flags */ 97 u8 ctrl; /* Control byte + flags */ 98 unsigned int len; /* Length of data block (can be zero) */ 99 unsigned char *data; /* Points into buffer but not at the start */ 100 unsigned char buffer[]; 101 }; 102 103 enum gsm_dlci_state { 104 DLCI_CLOSED, 105 DLCI_OPENING, /* Sending SABM not seen UA */ 106 DLCI_OPEN, /* SABM/UA complete */ 107 DLCI_CLOSING, /* Sending DISC not seen UA/DM */ 108 }; 109 110 enum gsm_dlci_mode { 111 DLCI_MODE_ABM, /* Normal Asynchronous Balanced Mode */ 112 DLCI_MODE_ADM, /* Asynchronous Disconnected Mode */ 113 }; 114 115 /* 116 * Each active data link has a gsm_dlci structure associated which ties 117 * the link layer to an optional tty (if the tty side is open). To avoid 118 * complexity right now these are only ever freed up when the mux is 119 * shut down. 120 * 121 * At the moment we don't free DLCI objects until the mux is torn down 122 * this avoid object life time issues but might be worth review later. 123 */ 124 125 struct gsm_dlci { 126 struct gsm_mux *gsm; 127 int addr; 128 enum gsm_dlci_state state; 129 struct mutex mutex; 130 131 /* Link layer */ 132 enum gsm_dlci_mode mode; 133 spinlock_t lock; /* Protects the internal state */ 134 struct timer_list t1; /* Retransmit timer for SABM and UA */ 135 int retries; 136 /* Uplink tty if active */ 137 struct tty_port port; /* The tty bound to this DLCI if there is one */ 138 struct kfifo fifo; /* Queue fifo for the DLCI */ 139 int adaption; /* Adaption layer in use */ 140 int prev_adaption; 141 u32 modem_rx; /* Our incoming virtual modem lines */ 142 u32 modem_tx; /* Our outgoing modem lines */ 143 bool dead; /* Refuse re-open */ 144 /* Flow control */ 145 bool throttled; /* Private copy of throttle state */ 146 bool constipated; /* Throttle status for outgoing */ 147 /* Packetised I/O */ 148 struct sk_buff *skb; /* Frame being sent */ 149 struct sk_buff_head skb_list; /* Queued frames */ 150 /* Data handling callback */ 151 void (*data)(struct gsm_dlci *dlci, const u8 *data, int len); 152 void (*prev_data)(struct gsm_dlci *dlci, const u8 *data, int len); 153 struct net_device *net; /* network interface, if created */ 154 }; 155 156 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */ 157 158 #define NUM_DLCI 64 159 160 /* 161 * DLCI 0 is used to pass control blocks out of band of the data 162 * flow (and with a higher link priority). One command can be outstanding 163 * at a time and we use this structure to manage them. They are created 164 * and destroyed by the user context, and updated by the receive paths 165 * and timers 166 */ 167 168 struct gsm_control { 169 u8 cmd; /* Command we are issuing */ 170 u8 *data; /* Data for the command in case we retransmit */ 171 int len; /* Length of block for retransmission */ 172 int done; /* Done flag */ 173 int error; /* Error if any */ 174 }; 175 176 enum gsm_mux_state { 177 GSM_SEARCH, 178 GSM_START, 179 GSM_ADDRESS, 180 GSM_CONTROL, 181 GSM_LEN, 182 GSM_DATA, 183 GSM_FCS, 184 GSM_OVERRUN, 185 GSM_LEN0, 186 GSM_LEN1, 187 GSM_SSOF, 188 }; 189 190 /* 191 * Each GSM mux we have is represented by this structure. If we are 192 * operating as an ldisc then we use this structure as our ldisc 193 * state. We need to sort out lifetimes and locking with respect 194 * to the gsm mux array. For now we don't free DLCI objects that 195 * have been instantiated until the mux itself is terminated. 196 * 197 * To consider further: tty open versus mux shutdown. 198 */ 199 200 struct gsm_mux { 201 struct tty_struct *tty; /* The tty our ldisc is bound to */ 202 spinlock_t lock; 203 struct mutex mutex; 204 unsigned int num; 205 struct kref ref; 206 207 /* Events on the GSM channel */ 208 wait_queue_head_t event; 209 210 /* Bits for GSM mode decoding */ 211 212 /* Framing Layer */ 213 unsigned char *buf; 214 enum gsm_mux_state state; 215 unsigned int len; 216 unsigned int address; 217 unsigned int count; 218 bool escape; 219 int encoding; 220 u8 control; 221 u8 fcs; 222 u8 received_fcs; 223 u8 *txframe; /* TX framing buffer */ 224 225 /* Method for the receiver side */ 226 void (*receive)(struct gsm_mux *gsm, u8 ch); 227 228 /* Link Layer */ 229 unsigned int mru; 230 unsigned int mtu; 231 int initiator; /* Did we initiate connection */ 232 bool dead; /* Has the mux been shut down */ 233 struct gsm_dlci *dlci[NUM_DLCI]; 234 bool constipated; /* Asked by remote to shut up */ 235 236 spinlock_t tx_lock; 237 unsigned int tx_bytes; /* TX data outstanding */ 238 #define TX_THRESH_HI 8192 239 #define TX_THRESH_LO 2048 240 struct list_head tx_list; /* Pending data packets */ 241 242 /* Control messages */ 243 struct timer_list t2_timer; /* Retransmit timer for commands */ 244 int cretries; /* Command retry counter */ 245 struct gsm_control *pending_cmd;/* Our current pending command */ 246 spinlock_t control_lock; /* Protects the pending command */ 247 248 /* Configuration */ 249 int adaption; /* 1 or 2 supported */ 250 u8 ftype; /* UI or UIH */ 251 int t1, t2; /* Timers in 1/100th of a sec */ 252 int n2; /* Retry count */ 253 254 /* Statistics (not currently exposed) */ 255 unsigned long bad_fcs; 256 unsigned long malformed; 257 unsigned long io_error; 258 unsigned long bad_size; 259 unsigned long unsupported; 260 }; 261 262 263 /* 264 * Mux objects - needed so that we can translate a tty index into the 265 * relevant mux and DLCI. 266 */ 267 268 #define MAX_MUX 4 /* 256 minors */ 269 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */ 270 static DEFINE_SPINLOCK(gsm_mux_lock); 271 272 static struct tty_driver *gsm_tty_driver; 273 274 /* 275 * This section of the driver logic implements the GSM encodings 276 * both the basic and the 'advanced'. Reliable transport is not 277 * supported. 278 */ 279 280 #define CR 0x02 281 #define EA 0x01 282 #define PF 0x10 283 284 /* I is special: the rest are ..*/ 285 #define RR 0x01 286 #define UI 0x03 287 #define RNR 0x05 288 #define REJ 0x09 289 #define DM 0x0F 290 #define SABM 0x2F 291 #define DISC 0x43 292 #define UA 0x63 293 #define UIH 0xEF 294 295 /* Channel commands */ 296 #define CMD_NSC 0x09 297 #define CMD_TEST 0x11 298 #define CMD_PSC 0x21 299 #define CMD_RLS 0x29 300 #define CMD_FCOFF 0x31 301 #define CMD_PN 0x41 302 #define CMD_RPN 0x49 303 #define CMD_FCON 0x51 304 #define CMD_CLD 0x61 305 #define CMD_SNC 0x69 306 #define CMD_MSC 0x71 307 308 /* Virtual modem bits */ 309 #define MDM_FC 0x01 310 #define MDM_RTC 0x02 311 #define MDM_RTR 0x04 312 #define MDM_IC 0x20 313 #define MDM_DV 0x40 314 315 #define GSM0_SOF 0xF9 316 #define GSM1_SOF 0x7E 317 #define GSM1_ESCAPE 0x7D 318 #define GSM1_ESCAPE_BITS 0x20 319 #define XON 0x11 320 #define XOFF 0x13 321 322 static const struct tty_port_operations gsm_port_ops; 323 324 /* 325 * CRC table for GSM 0710 326 */ 327 328 static const u8 gsm_fcs8[256] = { 329 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75, 330 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B, 331 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69, 332 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67, 333 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D, 334 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43, 335 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51, 336 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F, 337 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05, 338 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B, 339 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19, 340 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17, 341 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D, 342 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33, 343 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21, 344 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F, 345 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95, 346 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B, 347 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89, 348 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87, 349 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD, 350 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3, 351 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1, 352 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF, 353 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5, 354 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB, 355 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9, 356 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7, 357 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD, 358 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3, 359 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1, 360 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF 361 }; 362 363 #define INIT_FCS 0xFF 364 #define GOOD_FCS 0xCF 365 366 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len); 367 368 /** 369 * gsm_fcs_add - update FCS 370 * @fcs: Current FCS 371 * @c: Next data 372 * 373 * Update the FCS to include c. Uses the algorithm in the specification 374 * notes. 375 */ 376 377 static inline u8 gsm_fcs_add(u8 fcs, u8 c) 378 { 379 return gsm_fcs8[fcs ^ c]; 380 } 381 382 /** 383 * gsm_fcs_add_block - update FCS for a block 384 * @fcs: Current FCS 385 * @c: buffer of data 386 * @len: length of buffer 387 * 388 * Update the FCS to include c. Uses the algorithm in the specification 389 * notes. 390 */ 391 392 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len) 393 { 394 while (len--) 395 fcs = gsm_fcs8[fcs ^ *c++]; 396 return fcs; 397 } 398 399 /** 400 * gsm_read_ea - read a byte into an EA 401 * @val: variable holding value 402 * @c: byte going into the EA 403 * 404 * Processes one byte of an EA. Updates the passed variable 405 * and returns 1 if the EA is now completely read 406 */ 407 408 static int gsm_read_ea(unsigned int *val, u8 c) 409 { 410 /* Add the next 7 bits into the value */ 411 *val <<= 7; 412 *val |= c >> 1; 413 /* Was this the last byte of the EA 1 = yes*/ 414 return c & EA; 415 } 416 417 /** 418 * gsm_encode_modem - encode modem data bits 419 * @dlci: DLCI to encode from 420 * 421 * Returns the correct GSM encoded modem status bits (6 bit field) for 422 * the current status of the DLCI and attached tty object 423 */ 424 425 static u8 gsm_encode_modem(const struct gsm_dlci *dlci) 426 { 427 u8 modembits = 0; 428 /* FC is true flow control not modem bits */ 429 if (dlci->throttled) 430 modembits |= MDM_FC; 431 if (dlci->modem_tx & TIOCM_DTR) 432 modembits |= MDM_RTC; 433 if (dlci->modem_tx & TIOCM_RTS) 434 modembits |= MDM_RTR; 435 if (dlci->modem_tx & TIOCM_RI) 436 modembits |= MDM_IC; 437 if (dlci->modem_tx & TIOCM_CD) 438 modembits |= MDM_DV; 439 return modembits; 440 } 441 442 /** 443 * gsm_print_packet - display a frame for debug 444 * @hdr: header to print before decode 445 * @addr: address EA from the frame 446 * @cr: C/R bit from the frame 447 * @control: control including PF bit 448 * @data: following data bytes 449 * @dlen: length of data 450 * 451 * Displays a packet in human readable format for debugging purposes. The 452 * style is based on amateur radio LAP-B dump display. 453 */ 454 455 static void gsm_print_packet(const char *hdr, int addr, int cr, 456 u8 control, const u8 *data, int dlen) 457 { 458 if (!(debug & 1)) 459 return; 460 461 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]); 462 463 switch (control & ~PF) { 464 case SABM: 465 pr_cont("SABM"); 466 break; 467 case UA: 468 pr_cont("UA"); 469 break; 470 case DISC: 471 pr_cont("DISC"); 472 break; 473 case DM: 474 pr_cont("DM"); 475 break; 476 case UI: 477 pr_cont("UI"); 478 break; 479 case UIH: 480 pr_cont("UIH"); 481 break; 482 default: 483 if (!(control & 0x01)) { 484 pr_cont("I N(S)%d N(R)%d", 485 (control & 0x0E) >> 1, (control & 0xE0) >> 5); 486 } else switch (control & 0x0F) { 487 case RR: 488 pr_cont("RR(%d)", (control & 0xE0) >> 5); 489 break; 490 case RNR: 491 pr_cont("RNR(%d)", (control & 0xE0) >> 5); 492 break; 493 case REJ: 494 pr_cont("REJ(%d)", (control & 0xE0) >> 5); 495 break; 496 default: 497 pr_cont("[%02X]", control); 498 } 499 } 500 501 if (control & PF) 502 pr_cont("(P)"); 503 else 504 pr_cont("(F)"); 505 506 print_hex_dump_bytes("", DUMP_PREFIX_NONE, data, dlen); 507 } 508 509 510 /* 511 * Link level transmission side 512 */ 513 514 /** 515 * gsm_stuff_packet - bytestuff a packet 516 * @input: input buffer 517 * @output: output buffer 518 * @len: length of input 519 * 520 * Expand a buffer by bytestuffing it. The worst case size change 521 * is doubling and the caller is responsible for handing out 522 * suitable sized buffers. 523 */ 524 525 static int gsm_stuff_frame(const u8 *input, u8 *output, int len) 526 { 527 int olen = 0; 528 while (len--) { 529 if (*input == GSM1_SOF || *input == GSM1_ESCAPE 530 || *input == XON || *input == XOFF) { 531 *output++ = GSM1_ESCAPE; 532 *output++ = *input++ ^ GSM1_ESCAPE_BITS; 533 olen++; 534 } else 535 *output++ = *input++; 536 olen++; 537 } 538 return olen; 539 } 540 541 /** 542 * gsm_send - send a control frame 543 * @gsm: our GSM mux 544 * @addr: address for control frame 545 * @cr: command/response bit 546 * @control: control byte including PF bit 547 * 548 * Format up and transmit a control frame. These do not go via the 549 * queueing logic as they should be transmitted ahead of data when 550 * they are needed. 551 * 552 * FIXME: Lock versus data TX path 553 */ 554 555 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control) 556 { 557 int len; 558 u8 cbuf[10]; 559 u8 ibuf[3]; 560 561 switch (gsm->encoding) { 562 case 0: 563 cbuf[0] = GSM0_SOF; 564 cbuf[1] = (addr << 2) | (cr << 1) | EA; 565 cbuf[2] = control; 566 cbuf[3] = EA; /* Length of data = 0 */ 567 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3); 568 cbuf[5] = GSM0_SOF; 569 len = 6; 570 break; 571 case 1: 572 case 2: 573 /* Control frame + packing (but not frame stuffing) in mode 1 */ 574 ibuf[0] = (addr << 2) | (cr << 1) | EA; 575 ibuf[1] = control; 576 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2); 577 /* Stuffing may double the size worst case */ 578 len = gsm_stuff_frame(ibuf, cbuf + 1, 3); 579 /* Now add the SOF markers */ 580 cbuf[0] = GSM1_SOF; 581 cbuf[len + 1] = GSM1_SOF; 582 /* FIXME: we can omit the lead one in many cases */ 583 len += 2; 584 break; 585 default: 586 WARN_ON(1); 587 return; 588 } 589 gsmld_output(gsm, cbuf, len); 590 gsm_print_packet("-->", addr, cr, control, NULL, 0); 591 } 592 593 /** 594 * gsm_response - send a control response 595 * @gsm: our GSM mux 596 * @addr: address for control frame 597 * @control: control byte including PF bit 598 * 599 * Format up and transmit a link level response frame. 600 */ 601 602 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control) 603 { 604 gsm_send(gsm, addr, 0, control); 605 } 606 607 /** 608 * gsm_command - send a control command 609 * @gsm: our GSM mux 610 * @addr: address for control frame 611 * @control: control byte including PF bit 612 * 613 * Format up and transmit a link level command frame. 614 */ 615 616 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control) 617 { 618 gsm_send(gsm, addr, 1, control); 619 } 620 621 /* Data transmission */ 622 623 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */ 624 625 /** 626 * gsm_data_alloc - allocate data frame 627 * @gsm: GSM mux 628 * @addr: DLCI address 629 * @len: length excluding header and FCS 630 * @ctrl: control byte 631 * 632 * Allocate a new data buffer for sending frames with data. Space is left 633 * at the front for header bytes but that is treated as an implementation 634 * detail and not for the high level code to use 635 */ 636 637 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len, 638 u8 ctrl) 639 { 640 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN, 641 GFP_ATOMIC); 642 if (m == NULL) 643 return NULL; 644 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */ 645 m->len = len; 646 m->addr = addr; 647 m->ctrl = ctrl; 648 INIT_LIST_HEAD(&m->list); 649 return m; 650 } 651 652 /** 653 * gsm_data_kick - poke the queue 654 * @gsm: GSM Mux 655 * @dlci: DLCI sending the data 656 * 657 * The tty device has called us to indicate that room has appeared in 658 * the transmit queue. Ram more data into the pipe if we have any 659 * If we have been flow-stopped by a CMD_FCOFF, then we can only 660 * send messages on DLCI0 until CMD_FCON 661 * 662 * FIXME: lock against link layer control transmissions 663 */ 664 665 static void gsm_data_kick(struct gsm_mux *gsm, struct gsm_dlci *dlci) 666 { 667 struct gsm_msg *msg, *nmsg; 668 int len; 669 670 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) { 671 if (gsm->constipated && msg->addr) 672 continue; 673 if (gsm->encoding != 0) { 674 gsm->txframe[0] = GSM1_SOF; 675 len = gsm_stuff_frame(msg->data, 676 gsm->txframe + 1, msg->len); 677 gsm->txframe[len + 1] = GSM1_SOF; 678 len += 2; 679 } else { 680 gsm->txframe[0] = GSM0_SOF; 681 memcpy(gsm->txframe + 1 , msg->data, msg->len); 682 gsm->txframe[msg->len + 1] = GSM0_SOF; 683 len = msg->len + 2; 684 } 685 686 if (debug & 4) 687 print_hex_dump_bytes("gsm_data_kick: ", 688 DUMP_PREFIX_OFFSET, 689 gsm->txframe, len); 690 if (gsmld_output(gsm, gsm->txframe, len) < 0) 691 break; 692 /* FIXME: Can eliminate one SOF in many more cases */ 693 gsm->tx_bytes -= msg->len; 694 695 list_del(&msg->list); 696 kfree(msg); 697 698 if (dlci) { 699 tty_port_tty_wakeup(&dlci->port); 700 } else { 701 int i = 0; 702 703 for (i = 0; i < NUM_DLCI; i++) 704 if (gsm->dlci[i]) 705 tty_port_tty_wakeup(&gsm->dlci[i]->port); 706 } 707 } 708 } 709 710 /** 711 * __gsm_data_queue - queue a UI or UIH frame 712 * @dlci: DLCI sending the data 713 * @msg: message queued 714 * 715 * Add data to the transmit queue and try and get stuff moving 716 * out of the mux tty if not already doing so. The Caller must hold 717 * the gsm tx lock. 718 */ 719 720 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg) 721 { 722 struct gsm_mux *gsm = dlci->gsm; 723 u8 *dp = msg->data; 724 u8 *fcs = dp + msg->len; 725 726 /* Fill in the header */ 727 if (gsm->encoding == 0) { 728 if (msg->len < 128) 729 *--dp = (msg->len << 1) | EA; 730 else { 731 *--dp = (msg->len >> 7); /* bits 7 - 15 */ 732 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */ 733 } 734 } 735 736 *--dp = msg->ctrl; 737 if (gsm->initiator) 738 *--dp = (msg->addr << 2) | 2 | EA; 739 else 740 *--dp = (msg->addr << 2) | EA; 741 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp); 742 /* Ugly protocol layering violation */ 743 if (msg->ctrl == UI || msg->ctrl == (UI|PF)) 744 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len); 745 *fcs = 0xFF - *fcs; 746 747 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl, 748 msg->data, msg->len); 749 750 /* Move the header back and adjust the length, also allow for the FCS 751 now tacked on the end */ 752 msg->len += (msg->data - dp) + 1; 753 msg->data = dp; 754 755 /* Add to the actual output queue */ 756 list_add_tail(&msg->list, &gsm->tx_list); 757 gsm->tx_bytes += msg->len; 758 gsm_data_kick(gsm, dlci); 759 } 760 761 /** 762 * gsm_data_queue - queue a UI or UIH frame 763 * @dlci: DLCI sending the data 764 * @msg: message queued 765 * 766 * Add data to the transmit queue and try and get stuff moving 767 * out of the mux tty if not already doing so. Take the 768 * the gsm tx lock and dlci lock. 769 */ 770 771 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg) 772 { 773 unsigned long flags; 774 spin_lock_irqsave(&dlci->gsm->tx_lock, flags); 775 __gsm_data_queue(dlci, msg); 776 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags); 777 } 778 779 /** 780 * gsm_dlci_data_output - try and push data out of a DLCI 781 * @gsm: mux 782 * @dlci: the DLCI to pull data from 783 * 784 * Pull data from a DLCI and send it into the transmit queue if there 785 * is data. Keep to the MRU of the mux. This path handles the usual tty 786 * interface which is a byte stream with optional modem data. 787 * 788 * Caller must hold the tx_lock of the mux. 789 */ 790 791 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci) 792 { 793 struct gsm_msg *msg; 794 u8 *dp; 795 int len, total_size, size; 796 int h = dlci->adaption - 1; 797 798 total_size = 0; 799 while (1) { 800 len = kfifo_len(&dlci->fifo); 801 if (len == 0) 802 return total_size; 803 804 /* MTU/MRU count only the data bits */ 805 if (len > gsm->mtu) 806 len = gsm->mtu; 807 808 size = len + h; 809 810 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype); 811 /* FIXME: need a timer or something to kick this so it can't 812 get stuck with no work outstanding and no buffer free */ 813 if (msg == NULL) 814 return -ENOMEM; 815 dp = msg->data; 816 switch (dlci->adaption) { 817 case 1: /* Unstructured */ 818 break; 819 case 2: /* Unstructed with modem bits. 820 Always one byte as we never send inline break data */ 821 *dp++ = gsm_encode_modem(dlci); 822 break; 823 } 824 WARN_ON(kfifo_out_locked(&dlci->fifo, dp , len, &dlci->lock) != len); 825 __gsm_data_queue(dlci, msg); 826 total_size += size; 827 } 828 /* Bytes of data we used up */ 829 return total_size; 830 } 831 832 /** 833 * gsm_dlci_data_output_framed - try and push data out of a DLCI 834 * @gsm: mux 835 * @dlci: the DLCI to pull data from 836 * 837 * Pull data from a DLCI and send it into the transmit queue if there 838 * is data. Keep to the MRU of the mux. This path handles framed data 839 * queued as skbuffs to the DLCI. 840 * 841 * Caller must hold the tx_lock of the mux. 842 */ 843 844 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm, 845 struct gsm_dlci *dlci) 846 { 847 struct gsm_msg *msg; 848 u8 *dp; 849 int len, size; 850 int last = 0, first = 0; 851 int overhead = 0; 852 853 /* One byte per frame is used for B/F flags */ 854 if (dlci->adaption == 4) 855 overhead = 1; 856 857 /* dlci->skb is locked by tx_lock */ 858 if (dlci->skb == NULL) { 859 dlci->skb = skb_dequeue_tail(&dlci->skb_list); 860 if (dlci->skb == NULL) 861 return 0; 862 first = 1; 863 } 864 len = dlci->skb->len + overhead; 865 866 /* MTU/MRU count only the data bits */ 867 if (len > gsm->mtu) { 868 if (dlci->adaption == 3) { 869 /* Over long frame, bin it */ 870 dev_kfree_skb_any(dlci->skb); 871 dlci->skb = NULL; 872 return 0; 873 } 874 len = gsm->mtu; 875 } else 876 last = 1; 877 878 size = len + overhead; 879 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype); 880 881 /* FIXME: need a timer or something to kick this so it can't 882 get stuck with no work outstanding and no buffer free */ 883 if (msg == NULL) { 884 skb_queue_tail(&dlci->skb_list, dlci->skb); 885 dlci->skb = NULL; 886 return -ENOMEM; 887 } 888 dp = msg->data; 889 890 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */ 891 /* Flag byte to carry the start/end info */ 892 *dp++ = last << 7 | first << 6 | 1; /* EA */ 893 len--; 894 } 895 memcpy(dp, dlci->skb->data, len); 896 skb_pull(dlci->skb, len); 897 __gsm_data_queue(dlci, msg); 898 if (last) { 899 dev_kfree_skb_any(dlci->skb); 900 dlci->skb = NULL; 901 } 902 return size; 903 } 904 905 /** 906 * gsm_dlci_data_sweep - look for data to send 907 * @gsm: the GSM mux 908 * 909 * Sweep the GSM mux channels in priority order looking for ones with 910 * data to send. We could do with optimising this scan a bit. We aim 911 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit 912 * TX_THRESH_LO we get called again 913 * 914 * FIXME: We should round robin between groups and in theory you can 915 * renegotiate DLCI priorities with optional stuff. Needs optimising. 916 */ 917 918 static void gsm_dlci_data_sweep(struct gsm_mux *gsm) 919 { 920 int len; 921 /* Priority ordering: We should do priority with RR of the groups */ 922 int i = 1; 923 924 while (i < NUM_DLCI) { 925 struct gsm_dlci *dlci; 926 927 if (gsm->tx_bytes > TX_THRESH_HI) 928 break; 929 dlci = gsm->dlci[i]; 930 if (dlci == NULL || dlci->constipated) { 931 i++; 932 continue; 933 } 934 if (dlci->adaption < 3 && !dlci->net) 935 len = gsm_dlci_data_output(gsm, dlci); 936 else 937 len = gsm_dlci_data_output_framed(gsm, dlci); 938 if (len < 0) 939 break; 940 /* DLCI empty - try the next */ 941 if (len == 0) 942 i++; 943 } 944 } 945 946 /** 947 * gsm_dlci_data_kick - transmit if possible 948 * @dlci: DLCI to kick 949 * 950 * Transmit data from this DLCI if the queue is empty. We can't rely on 951 * a tty wakeup except when we filled the pipe so we need to fire off 952 * new data ourselves in other cases. 953 */ 954 955 static void gsm_dlci_data_kick(struct gsm_dlci *dlci) 956 { 957 unsigned long flags; 958 int sweep; 959 960 if (dlci->constipated) 961 return; 962 963 spin_lock_irqsave(&dlci->gsm->tx_lock, flags); 964 /* If we have nothing running then we need to fire up */ 965 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO); 966 if (dlci->gsm->tx_bytes == 0) { 967 if (dlci->net) 968 gsm_dlci_data_output_framed(dlci->gsm, dlci); 969 else 970 gsm_dlci_data_output(dlci->gsm, dlci); 971 } 972 if (sweep) 973 gsm_dlci_data_sweep(dlci->gsm); 974 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags); 975 } 976 977 /* 978 * Control message processing 979 */ 980 981 982 /** 983 * gsm_control_reply - send a response frame to a control 984 * @gsm: gsm channel 985 * @cmd: the command to use 986 * @data: data to follow encoded info 987 * @dlen: length of data 988 * 989 * Encode up and queue a UI/UIH frame containing our response. 990 */ 991 992 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, const u8 *data, 993 int dlen) 994 { 995 struct gsm_msg *msg; 996 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype); 997 if (msg == NULL) 998 return; 999 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */ 1000 msg->data[1] = (dlen << 1) | EA; 1001 memcpy(msg->data + 2, data, dlen); 1002 gsm_data_queue(gsm->dlci[0], msg); 1003 } 1004 1005 /** 1006 * gsm_process_modem - process received modem status 1007 * @tty: virtual tty bound to the DLCI 1008 * @dlci: DLCI to affect 1009 * @modem: modem bits (full EA) 1010 * @clen: command length 1011 * 1012 * Used when a modem control message or line state inline in adaption 1013 * layer 2 is processed. Sort out the local modem state and throttles 1014 */ 1015 1016 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci, 1017 u32 modem, int clen) 1018 { 1019 int mlines = 0; 1020 u8 brk = 0; 1021 int fc; 1022 1023 /* The modem status command can either contain one octet (v.24 signals) 1024 or two octets (v.24 signals + break signals). The length field will 1025 either be 2 or 3 respectively. This is specified in section 1026 5.4.6.3.7 of the 27.010 mux spec. */ 1027 1028 if (clen == 2) 1029 modem = modem & 0x7f; 1030 else { 1031 brk = modem & 0x7f; 1032 modem = (modem >> 7) & 0x7f; 1033 } 1034 1035 /* Flow control/ready to communicate */ 1036 fc = (modem & MDM_FC) || !(modem & MDM_RTR); 1037 if (fc && !dlci->constipated) { 1038 /* Need to throttle our output on this device */ 1039 dlci->constipated = true; 1040 } else if (!fc && dlci->constipated) { 1041 dlci->constipated = false; 1042 gsm_dlci_data_kick(dlci); 1043 } 1044 1045 /* Map modem bits */ 1046 if (modem & MDM_RTC) 1047 mlines |= TIOCM_DSR | TIOCM_DTR; 1048 if (modem & MDM_RTR) 1049 mlines |= TIOCM_RTS | TIOCM_CTS; 1050 if (modem & MDM_IC) 1051 mlines |= TIOCM_RI; 1052 if (modem & MDM_DV) 1053 mlines |= TIOCM_CD; 1054 1055 /* Carrier drop -> hangup */ 1056 if (tty) { 1057 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD)) 1058 if (!C_CLOCAL(tty)) 1059 tty_hangup(tty); 1060 } 1061 if (brk & 0x01) 1062 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK); 1063 dlci->modem_rx = mlines; 1064 } 1065 1066 /** 1067 * gsm_control_modem - modem status received 1068 * @gsm: GSM channel 1069 * @data: data following command 1070 * @clen: command length 1071 * 1072 * We have received a modem status control message. This is used by 1073 * the GSM mux protocol to pass virtual modem line status and optionally 1074 * to indicate break signals. Unpack it, convert to Linux representation 1075 * and if need be stuff a break message down the tty. 1076 */ 1077 1078 static void gsm_control_modem(struct gsm_mux *gsm, const u8 *data, int clen) 1079 { 1080 unsigned int addr = 0; 1081 unsigned int modem = 0; 1082 unsigned int brk = 0; 1083 struct gsm_dlci *dlci; 1084 int len = clen; 1085 const u8 *dp = data; 1086 struct tty_struct *tty; 1087 1088 while (gsm_read_ea(&addr, *dp++) == 0) { 1089 len--; 1090 if (len == 0) 1091 return; 1092 } 1093 /* Must be at least one byte following the EA */ 1094 len--; 1095 if (len <= 0) 1096 return; 1097 1098 addr >>= 1; 1099 /* Closed port, or invalid ? */ 1100 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL) 1101 return; 1102 dlci = gsm->dlci[addr]; 1103 1104 while (gsm_read_ea(&modem, *dp++) == 0) { 1105 len--; 1106 if (len == 0) 1107 return; 1108 } 1109 len--; 1110 if (len > 0) { 1111 while (gsm_read_ea(&brk, *dp++) == 0) { 1112 len--; 1113 if (len == 0) 1114 return; 1115 } 1116 modem <<= 7; 1117 modem |= (brk & 0x7f); 1118 } 1119 tty = tty_port_tty_get(&dlci->port); 1120 gsm_process_modem(tty, dlci, modem, clen); 1121 if (tty) { 1122 tty_wakeup(tty); 1123 tty_kref_put(tty); 1124 } 1125 gsm_control_reply(gsm, CMD_MSC, data, clen); 1126 } 1127 1128 /** 1129 * gsm_control_rls - remote line status 1130 * @gsm: GSM channel 1131 * @data: data bytes 1132 * @clen: data length 1133 * 1134 * The modem sends us a two byte message on the control channel whenever 1135 * it wishes to send us an error state from the virtual link. Stuff 1136 * this into the uplink tty if present 1137 */ 1138 1139 static void gsm_control_rls(struct gsm_mux *gsm, const u8 *data, int clen) 1140 { 1141 struct tty_port *port; 1142 unsigned int addr = 0; 1143 u8 bits; 1144 int len = clen; 1145 const u8 *dp = data; 1146 1147 while (gsm_read_ea(&addr, *dp++) == 0) { 1148 len--; 1149 if (len == 0) 1150 return; 1151 } 1152 /* Must be at least one byte following ea */ 1153 len--; 1154 if (len <= 0) 1155 return; 1156 addr >>= 1; 1157 /* Closed port, or invalid ? */ 1158 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL) 1159 return; 1160 /* No error ? */ 1161 bits = *dp; 1162 if ((bits & 1) == 0) 1163 return; 1164 1165 port = &gsm->dlci[addr]->port; 1166 1167 if (bits & 2) 1168 tty_insert_flip_char(port, 0, TTY_OVERRUN); 1169 if (bits & 4) 1170 tty_insert_flip_char(port, 0, TTY_PARITY); 1171 if (bits & 8) 1172 tty_insert_flip_char(port, 0, TTY_FRAME); 1173 1174 tty_flip_buffer_push(port); 1175 1176 gsm_control_reply(gsm, CMD_RLS, data, clen); 1177 } 1178 1179 static void gsm_dlci_begin_close(struct gsm_dlci *dlci); 1180 1181 /** 1182 * gsm_control_message - DLCI 0 control processing 1183 * @gsm: our GSM mux 1184 * @command: the command EA 1185 * @data: data beyond the command/length EAs 1186 * @clen: length 1187 * 1188 * Input processor for control messages from the other end of the link. 1189 * Processes the incoming request and queues a response frame or an 1190 * NSC response if not supported 1191 */ 1192 1193 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command, 1194 const u8 *data, int clen) 1195 { 1196 u8 buf[1]; 1197 unsigned long flags; 1198 1199 switch (command) { 1200 case CMD_CLD: { 1201 struct gsm_dlci *dlci = gsm->dlci[0]; 1202 /* Modem wishes to close down */ 1203 if (dlci) { 1204 dlci->dead = true; 1205 gsm->dead = true; 1206 gsm_dlci_begin_close(dlci); 1207 } 1208 } 1209 break; 1210 case CMD_TEST: 1211 /* Modem wishes to test, reply with the data */ 1212 gsm_control_reply(gsm, CMD_TEST, data, clen); 1213 break; 1214 case CMD_FCON: 1215 /* Modem can accept data again */ 1216 gsm->constipated = false; 1217 gsm_control_reply(gsm, CMD_FCON, NULL, 0); 1218 /* Kick the link in case it is idling */ 1219 spin_lock_irqsave(&gsm->tx_lock, flags); 1220 gsm_data_kick(gsm, NULL); 1221 spin_unlock_irqrestore(&gsm->tx_lock, flags); 1222 break; 1223 case CMD_FCOFF: 1224 /* Modem wants us to STFU */ 1225 gsm->constipated = true; 1226 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0); 1227 break; 1228 case CMD_MSC: 1229 /* Out of band modem line change indicator for a DLCI */ 1230 gsm_control_modem(gsm, data, clen); 1231 break; 1232 case CMD_RLS: 1233 /* Out of band error reception for a DLCI */ 1234 gsm_control_rls(gsm, data, clen); 1235 break; 1236 case CMD_PSC: 1237 /* Modem wishes to enter power saving state */ 1238 gsm_control_reply(gsm, CMD_PSC, NULL, 0); 1239 break; 1240 /* Optional unsupported commands */ 1241 case CMD_PN: /* Parameter negotiation */ 1242 case CMD_RPN: /* Remote port negotiation */ 1243 case CMD_SNC: /* Service negotiation command */ 1244 default: 1245 /* Reply to bad commands with an NSC */ 1246 buf[0] = command; 1247 gsm_control_reply(gsm, CMD_NSC, buf, 1); 1248 break; 1249 } 1250 } 1251 1252 /** 1253 * gsm_control_response - process a response to our control 1254 * @gsm: our GSM mux 1255 * @command: the command (response) EA 1256 * @data: data beyond the command/length EA 1257 * @clen: length 1258 * 1259 * Process a response to an outstanding command. We only allow a single 1260 * control message in flight so this is fairly easy. All the clean up 1261 * is done by the caller, we just update the fields, flag it as done 1262 * and return 1263 */ 1264 1265 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command, 1266 const u8 *data, int clen) 1267 { 1268 struct gsm_control *ctrl; 1269 unsigned long flags; 1270 1271 spin_lock_irqsave(&gsm->control_lock, flags); 1272 1273 ctrl = gsm->pending_cmd; 1274 /* Does the reply match our command */ 1275 command |= 1; 1276 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) { 1277 /* Our command was replied to, kill the retry timer */ 1278 del_timer(&gsm->t2_timer); 1279 gsm->pending_cmd = NULL; 1280 /* Rejected by the other end */ 1281 if (command == CMD_NSC) 1282 ctrl->error = -EOPNOTSUPP; 1283 ctrl->done = 1; 1284 wake_up(&gsm->event); 1285 } 1286 spin_unlock_irqrestore(&gsm->control_lock, flags); 1287 } 1288 1289 /** 1290 * gsm_control_transmit - send control packet 1291 * @gsm: gsm mux 1292 * @ctrl: frame to send 1293 * 1294 * Send out a pending control command (called under control lock) 1295 */ 1296 1297 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl) 1298 { 1299 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype); 1300 if (msg == NULL) 1301 return; 1302 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */ 1303 memcpy(msg->data + 1, ctrl->data, ctrl->len); 1304 gsm_data_queue(gsm->dlci[0], msg); 1305 } 1306 1307 /** 1308 * gsm_control_retransmit - retransmit a control frame 1309 * @t: timer contained in our gsm object 1310 * 1311 * Called off the T2 timer expiry in order to retransmit control frames 1312 * that have been lost in the system somewhere. The control_lock protects 1313 * us from colliding with another sender or a receive completion event. 1314 * In that situation the timer may still occur in a small window but 1315 * gsm->pending_cmd will be NULL and we just let the timer expire. 1316 */ 1317 1318 static void gsm_control_retransmit(struct timer_list *t) 1319 { 1320 struct gsm_mux *gsm = from_timer(gsm, t, t2_timer); 1321 struct gsm_control *ctrl; 1322 unsigned long flags; 1323 spin_lock_irqsave(&gsm->control_lock, flags); 1324 ctrl = gsm->pending_cmd; 1325 if (ctrl) { 1326 gsm->cretries--; 1327 if (gsm->cretries == 0) { 1328 gsm->pending_cmd = NULL; 1329 ctrl->error = -ETIMEDOUT; 1330 ctrl->done = 1; 1331 spin_unlock_irqrestore(&gsm->control_lock, flags); 1332 wake_up(&gsm->event); 1333 return; 1334 } 1335 gsm_control_transmit(gsm, ctrl); 1336 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100); 1337 } 1338 spin_unlock_irqrestore(&gsm->control_lock, flags); 1339 } 1340 1341 /** 1342 * gsm_control_send - send a control frame on DLCI 0 1343 * @gsm: the GSM channel 1344 * @command: command to send including CR bit 1345 * @data: bytes of data (must be kmalloced) 1346 * @clen: length of the block to send 1347 * 1348 * Queue and dispatch a control command. Only one command can be 1349 * active at a time. In theory more can be outstanding but the matching 1350 * gets really complicated so for now stick to one outstanding. 1351 */ 1352 1353 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm, 1354 unsigned int command, u8 *data, int clen) 1355 { 1356 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control), 1357 GFP_KERNEL); 1358 unsigned long flags; 1359 if (ctrl == NULL) 1360 return NULL; 1361 retry: 1362 wait_event(gsm->event, gsm->pending_cmd == NULL); 1363 spin_lock_irqsave(&gsm->control_lock, flags); 1364 if (gsm->pending_cmd != NULL) { 1365 spin_unlock_irqrestore(&gsm->control_lock, flags); 1366 goto retry; 1367 } 1368 ctrl->cmd = command; 1369 ctrl->data = data; 1370 ctrl->len = clen; 1371 gsm->pending_cmd = ctrl; 1372 1373 /* If DLCI0 is in ADM mode skip retries, it won't respond */ 1374 if (gsm->dlci[0]->mode == DLCI_MODE_ADM) 1375 gsm->cretries = 1; 1376 else 1377 gsm->cretries = gsm->n2; 1378 1379 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100); 1380 gsm_control_transmit(gsm, ctrl); 1381 spin_unlock_irqrestore(&gsm->control_lock, flags); 1382 return ctrl; 1383 } 1384 1385 /** 1386 * gsm_control_wait - wait for a control to finish 1387 * @gsm: GSM mux 1388 * @control: control we are waiting on 1389 * 1390 * Waits for the control to complete or time out. Frees any used 1391 * resources and returns 0 for success, or an error if the remote 1392 * rejected or ignored the request. 1393 */ 1394 1395 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control) 1396 { 1397 int err; 1398 wait_event(gsm->event, control->done == 1); 1399 err = control->error; 1400 kfree(control); 1401 return err; 1402 } 1403 1404 1405 /* 1406 * DLCI level handling: Needs krefs 1407 */ 1408 1409 /* 1410 * State transitions and timers 1411 */ 1412 1413 /** 1414 * gsm_dlci_close - a DLCI has closed 1415 * @dlci: DLCI that closed 1416 * 1417 * Perform processing when moving a DLCI into closed state. If there 1418 * is an attached tty this is hung up 1419 */ 1420 1421 static void gsm_dlci_close(struct gsm_dlci *dlci) 1422 { 1423 del_timer(&dlci->t1); 1424 if (debug & 8) 1425 pr_debug("DLCI %d goes closed.\n", dlci->addr); 1426 dlci->state = DLCI_CLOSED; 1427 if (dlci->addr != 0) { 1428 tty_port_tty_hangup(&dlci->port, false); 1429 kfifo_reset(&dlci->fifo); 1430 } else 1431 dlci->gsm->dead = true; 1432 wake_up(&dlci->gsm->event); 1433 /* A DLCI 0 close is a MUX termination so we need to kick that 1434 back to userspace somehow */ 1435 } 1436 1437 /** 1438 * gsm_dlci_open - a DLCI has opened 1439 * @dlci: DLCI that opened 1440 * 1441 * Perform processing when moving a DLCI into open state. 1442 */ 1443 1444 static void gsm_dlci_open(struct gsm_dlci *dlci) 1445 { 1446 /* Note that SABM UA .. SABM UA first UA lost can mean that we go 1447 open -> open */ 1448 del_timer(&dlci->t1); 1449 /* This will let a tty open continue */ 1450 dlci->state = DLCI_OPEN; 1451 if (debug & 8) 1452 pr_debug("DLCI %d goes open.\n", dlci->addr); 1453 wake_up(&dlci->gsm->event); 1454 } 1455 1456 /** 1457 * gsm_dlci_t1 - T1 timer expiry 1458 * @t: timer contained in the DLCI that opened 1459 * 1460 * The T1 timer handles retransmits of control frames (essentially of 1461 * SABM and DISC). We resend the command until the retry count runs out 1462 * in which case an opening port goes back to closed and a closing port 1463 * is simply put into closed state (any further frames from the other 1464 * end will get a DM response) 1465 * 1466 * Some control dlci can stay in ADM mode with other dlci working just 1467 * fine. In that case we can just keep the control dlci open after the 1468 * DLCI_OPENING retries time out. 1469 */ 1470 1471 static void gsm_dlci_t1(struct timer_list *t) 1472 { 1473 struct gsm_dlci *dlci = from_timer(dlci, t, t1); 1474 struct gsm_mux *gsm = dlci->gsm; 1475 1476 switch (dlci->state) { 1477 case DLCI_OPENING: 1478 dlci->retries--; 1479 if (dlci->retries) { 1480 gsm_command(dlci->gsm, dlci->addr, SABM|PF); 1481 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 1482 } else if (!dlci->addr && gsm->control == (DM | PF)) { 1483 if (debug & 8) 1484 pr_info("DLCI %d opening in ADM mode.\n", 1485 dlci->addr); 1486 dlci->mode = DLCI_MODE_ADM; 1487 gsm_dlci_open(dlci); 1488 } else { 1489 gsm_dlci_close(dlci); 1490 } 1491 1492 break; 1493 case DLCI_CLOSING: 1494 dlci->retries--; 1495 if (dlci->retries) { 1496 gsm_command(dlci->gsm, dlci->addr, DISC|PF); 1497 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 1498 } else 1499 gsm_dlci_close(dlci); 1500 break; 1501 default: 1502 pr_debug("%s: unhandled state: %d\n", __func__, dlci->state); 1503 break; 1504 } 1505 } 1506 1507 /** 1508 * gsm_dlci_begin_open - start channel open procedure 1509 * @dlci: DLCI to open 1510 * 1511 * Commence opening a DLCI from the Linux side. We issue SABM messages 1512 * to the modem which should then reply with a UA or ADM, at which point 1513 * we will move into open state. Opening is done asynchronously with retry 1514 * running off timers and the responses. 1515 */ 1516 1517 static void gsm_dlci_begin_open(struct gsm_dlci *dlci) 1518 { 1519 struct gsm_mux *gsm = dlci->gsm; 1520 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING) 1521 return; 1522 dlci->retries = gsm->n2; 1523 dlci->state = DLCI_OPENING; 1524 gsm_command(dlci->gsm, dlci->addr, SABM|PF); 1525 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 1526 } 1527 1528 /** 1529 * gsm_dlci_begin_close - start channel open procedure 1530 * @dlci: DLCI to open 1531 * 1532 * Commence closing a DLCI from the Linux side. We issue DISC messages 1533 * to the modem which should then reply with a UA, at which point we 1534 * will move into closed state. Closing is done asynchronously with retry 1535 * off timers. We may also receive a DM reply from the other end which 1536 * indicates the channel was already closed. 1537 */ 1538 1539 static void gsm_dlci_begin_close(struct gsm_dlci *dlci) 1540 { 1541 struct gsm_mux *gsm = dlci->gsm; 1542 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING) 1543 return; 1544 dlci->retries = gsm->n2; 1545 dlci->state = DLCI_CLOSING; 1546 gsm_command(dlci->gsm, dlci->addr, DISC|PF); 1547 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 1548 } 1549 1550 /** 1551 * gsm_dlci_data - data arrived 1552 * @dlci: channel 1553 * @data: block of bytes received 1554 * @clen: length of received block 1555 * 1556 * A UI or UIH frame has arrived which contains data for a channel 1557 * other than the control channel. If the relevant virtual tty is 1558 * open we shovel the bits down it, if not we drop them. 1559 */ 1560 1561 static void gsm_dlci_data(struct gsm_dlci *dlci, const u8 *data, int clen) 1562 { 1563 /* krefs .. */ 1564 struct tty_port *port = &dlci->port; 1565 struct tty_struct *tty; 1566 unsigned int modem = 0; 1567 int len = clen; 1568 1569 if (debug & 16) 1570 pr_debug("%d bytes for tty\n", len); 1571 switch (dlci->adaption) { 1572 /* Unsupported types */ 1573 case 4: /* Packetised interruptible data */ 1574 break; 1575 case 3: /* Packetised uininterruptible voice/data */ 1576 break; 1577 case 2: /* Asynchronous serial with line state in each frame */ 1578 while (gsm_read_ea(&modem, *data++) == 0) { 1579 len--; 1580 if (len == 0) 1581 return; 1582 } 1583 tty = tty_port_tty_get(port); 1584 if (tty) { 1585 gsm_process_modem(tty, dlci, modem, clen); 1586 tty_kref_put(tty); 1587 } 1588 fallthrough; 1589 case 1: /* Line state will go via DLCI 0 controls only */ 1590 default: 1591 tty_insert_flip_string(port, data, len); 1592 tty_flip_buffer_push(port); 1593 } 1594 } 1595 1596 /** 1597 * gsm_dlci_control - data arrived on control channel 1598 * @dlci: channel 1599 * @data: block of bytes received 1600 * @len: length of received block 1601 * 1602 * A UI or UIH frame has arrived which contains data for DLCI 0 the 1603 * control channel. This should contain a command EA followed by 1604 * control data bytes. The command EA contains a command/response bit 1605 * and we divide up the work accordingly. 1606 */ 1607 1608 static void gsm_dlci_command(struct gsm_dlci *dlci, const u8 *data, int len) 1609 { 1610 /* See what command is involved */ 1611 unsigned int command = 0; 1612 while (len-- > 0) { 1613 if (gsm_read_ea(&command, *data++) == 1) { 1614 int clen = *data++; 1615 len--; 1616 /* FIXME: this is properly an EA */ 1617 clen >>= 1; 1618 /* Malformed command ? */ 1619 if (clen > len) 1620 return; 1621 if (command & 1) 1622 gsm_control_message(dlci->gsm, command, 1623 data, clen); 1624 else 1625 gsm_control_response(dlci->gsm, command, 1626 data, clen); 1627 return; 1628 } 1629 } 1630 } 1631 1632 /* 1633 * Allocate/Free DLCI channels 1634 */ 1635 1636 /** 1637 * gsm_dlci_alloc - allocate a DLCI 1638 * @gsm: GSM mux 1639 * @addr: address of the DLCI 1640 * 1641 * Allocate and install a new DLCI object into the GSM mux. 1642 * 1643 * FIXME: review locking races 1644 */ 1645 1646 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr) 1647 { 1648 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC); 1649 if (dlci == NULL) 1650 return NULL; 1651 spin_lock_init(&dlci->lock); 1652 mutex_init(&dlci->mutex); 1653 if (kfifo_alloc(&dlci->fifo, 4096, GFP_KERNEL) < 0) { 1654 kfree(dlci); 1655 return NULL; 1656 } 1657 1658 skb_queue_head_init(&dlci->skb_list); 1659 timer_setup(&dlci->t1, gsm_dlci_t1, 0); 1660 tty_port_init(&dlci->port); 1661 dlci->port.ops = &gsm_port_ops; 1662 dlci->gsm = gsm; 1663 dlci->addr = addr; 1664 dlci->adaption = gsm->adaption; 1665 dlci->state = DLCI_CLOSED; 1666 if (addr) 1667 dlci->data = gsm_dlci_data; 1668 else 1669 dlci->data = gsm_dlci_command; 1670 gsm->dlci[addr] = dlci; 1671 return dlci; 1672 } 1673 1674 /** 1675 * gsm_dlci_free - free DLCI 1676 * @port: tty port for DLCI to free 1677 * 1678 * Free up a DLCI. 1679 * 1680 * Can sleep. 1681 */ 1682 static void gsm_dlci_free(struct tty_port *port) 1683 { 1684 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 1685 1686 del_timer_sync(&dlci->t1); 1687 dlci->gsm->dlci[dlci->addr] = NULL; 1688 kfifo_free(&dlci->fifo); 1689 while ((dlci->skb = skb_dequeue(&dlci->skb_list))) 1690 dev_kfree_skb(dlci->skb); 1691 kfree(dlci); 1692 } 1693 1694 static inline void dlci_get(struct gsm_dlci *dlci) 1695 { 1696 tty_port_get(&dlci->port); 1697 } 1698 1699 static inline void dlci_put(struct gsm_dlci *dlci) 1700 { 1701 tty_port_put(&dlci->port); 1702 } 1703 1704 static void gsm_destroy_network(struct gsm_dlci *dlci); 1705 1706 /** 1707 * gsm_dlci_release - release DLCI 1708 * @dlci: DLCI to destroy 1709 * 1710 * Release a DLCI. Actual free is deferred until either 1711 * mux is closed or tty is closed - whichever is last. 1712 * 1713 * Can sleep. 1714 */ 1715 static void gsm_dlci_release(struct gsm_dlci *dlci) 1716 { 1717 struct tty_struct *tty = tty_port_tty_get(&dlci->port); 1718 if (tty) { 1719 mutex_lock(&dlci->mutex); 1720 gsm_destroy_network(dlci); 1721 mutex_unlock(&dlci->mutex); 1722 1723 tty_hangup(tty); 1724 1725 tty_port_tty_set(&dlci->port, NULL); 1726 tty_kref_put(tty); 1727 } 1728 dlci->state = DLCI_CLOSED; 1729 dlci_put(dlci); 1730 } 1731 1732 /* 1733 * LAPBish link layer logic 1734 */ 1735 1736 /** 1737 * gsm_queue - a GSM frame is ready to process 1738 * @gsm: pointer to our gsm mux 1739 * 1740 * At this point in time a frame has arrived and been demangled from 1741 * the line encoding. All the differences between the encodings have 1742 * been handled below us and the frame is unpacked into the structures. 1743 * The fcs holds the header FCS but any data FCS must be added here. 1744 */ 1745 1746 static void gsm_queue(struct gsm_mux *gsm) 1747 { 1748 struct gsm_dlci *dlci; 1749 u8 cr; 1750 int address; 1751 /* We have to sneak a look at the packet body to do the FCS. 1752 A somewhat layering violation in the spec */ 1753 1754 if ((gsm->control & ~PF) == UI) 1755 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len); 1756 if (gsm->encoding == 0) { 1757 /* WARNING: gsm->received_fcs is used for 1758 gsm->encoding = 0 only. 1759 In this case it contain the last piece of data 1760 required to generate final CRC */ 1761 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs); 1762 } 1763 if (gsm->fcs != GOOD_FCS) { 1764 gsm->bad_fcs++; 1765 if (debug & 4) 1766 pr_debug("BAD FCS %02x\n", gsm->fcs); 1767 return; 1768 } 1769 address = gsm->address >> 1; 1770 if (address >= NUM_DLCI) 1771 goto invalid; 1772 1773 cr = gsm->address & 1; /* C/R bit */ 1774 1775 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len); 1776 1777 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */ 1778 dlci = gsm->dlci[address]; 1779 1780 switch (gsm->control) { 1781 case SABM|PF: 1782 if (cr == 0) 1783 goto invalid; 1784 if (dlci == NULL) 1785 dlci = gsm_dlci_alloc(gsm, address); 1786 if (dlci == NULL) 1787 return; 1788 if (dlci->dead) 1789 gsm_response(gsm, address, DM); 1790 else { 1791 gsm_response(gsm, address, UA); 1792 gsm_dlci_open(dlci); 1793 } 1794 break; 1795 case DISC|PF: 1796 if (cr == 0) 1797 goto invalid; 1798 if (dlci == NULL || dlci->state == DLCI_CLOSED) { 1799 gsm_response(gsm, address, DM); 1800 return; 1801 } 1802 /* Real close complete */ 1803 gsm_response(gsm, address, UA); 1804 gsm_dlci_close(dlci); 1805 break; 1806 case UA: 1807 case UA|PF: 1808 if (cr == 0 || dlci == NULL) 1809 break; 1810 switch (dlci->state) { 1811 case DLCI_CLOSING: 1812 gsm_dlci_close(dlci); 1813 break; 1814 case DLCI_OPENING: 1815 gsm_dlci_open(dlci); 1816 break; 1817 default: 1818 pr_debug("%s: unhandled state: %d\n", __func__, 1819 dlci->state); 1820 break; 1821 } 1822 break; 1823 case DM: /* DM can be valid unsolicited */ 1824 case DM|PF: 1825 if (cr) 1826 goto invalid; 1827 if (dlci == NULL) 1828 return; 1829 gsm_dlci_close(dlci); 1830 break; 1831 case UI: 1832 case UI|PF: 1833 case UIH: 1834 case UIH|PF: 1835 #if 0 1836 if (cr) 1837 goto invalid; 1838 #endif 1839 if (dlci == NULL || dlci->state != DLCI_OPEN) { 1840 gsm_command(gsm, address, DM|PF); 1841 return; 1842 } 1843 dlci->data(dlci, gsm->buf, gsm->len); 1844 break; 1845 default: 1846 goto invalid; 1847 } 1848 return; 1849 invalid: 1850 gsm->malformed++; 1851 return; 1852 } 1853 1854 1855 /** 1856 * gsm0_receive - perform processing for non-transparency 1857 * @gsm: gsm data for this ldisc instance 1858 * @c: character 1859 * 1860 * Receive bytes in gsm mode 0 1861 */ 1862 1863 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c) 1864 { 1865 unsigned int len; 1866 1867 switch (gsm->state) { 1868 case GSM_SEARCH: /* SOF marker */ 1869 if (c == GSM0_SOF) { 1870 gsm->state = GSM_ADDRESS; 1871 gsm->address = 0; 1872 gsm->len = 0; 1873 gsm->fcs = INIT_FCS; 1874 } 1875 break; 1876 case GSM_ADDRESS: /* Address EA */ 1877 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1878 if (gsm_read_ea(&gsm->address, c)) 1879 gsm->state = GSM_CONTROL; 1880 break; 1881 case GSM_CONTROL: /* Control Byte */ 1882 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1883 gsm->control = c; 1884 gsm->state = GSM_LEN0; 1885 break; 1886 case GSM_LEN0: /* Length EA */ 1887 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1888 if (gsm_read_ea(&gsm->len, c)) { 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 } 1901 gsm->state = GSM_LEN1; 1902 break; 1903 case GSM_LEN1: 1904 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1905 len = c; 1906 gsm->len |= len << 7; 1907 if (gsm->len > gsm->mru) { 1908 gsm->bad_size++; 1909 gsm->state = GSM_SEARCH; 1910 break; 1911 } 1912 gsm->count = 0; 1913 if (!gsm->len) 1914 gsm->state = GSM_FCS; 1915 else 1916 gsm->state = GSM_DATA; 1917 break; 1918 case GSM_DATA: /* Data */ 1919 gsm->buf[gsm->count++] = c; 1920 if (gsm->count == gsm->len) 1921 gsm->state = GSM_FCS; 1922 break; 1923 case GSM_FCS: /* FCS follows the packet */ 1924 gsm->received_fcs = c; 1925 gsm_queue(gsm); 1926 gsm->state = GSM_SSOF; 1927 break; 1928 case GSM_SSOF: 1929 if (c == GSM0_SOF) { 1930 gsm->state = GSM_SEARCH; 1931 break; 1932 } 1933 break; 1934 default: 1935 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state); 1936 break; 1937 } 1938 } 1939 1940 /** 1941 * gsm1_receive - perform processing for non-transparency 1942 * @gsm: gsm data for this ldisc instance 1943 * @c: character 1944 * 1945 * Receive bytes in mode 1 (Advanced option) 1946 */ 1947 1948 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c) 1949 { 1950 if (c == GSM1_SOF) { 1951 /* EOF is only valid in frame if we have got to the data state 1952 and received at least one byte (the FCS) */ 1953 if (gsm->state == GSM_DATA && gsm->count) { 1954 /* Extract the FCS */ 1955 gsm->count--; 1956 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]); 1957 gsm->len = gsm->count; 1958 gsm_queue(gsm); 1959 gsm->state = GSM_START; 1960 return; 1961 } 1962 /* Any partial frame was a runt so go back to start */ 1963 if (gsm->state != GSM_START) { 1964 gsm->malformed++; 1965 gsm->state = GSM_START; 1966 } 1967 /* A SOF in GSM_START means we are still reading idling or 1968 framing bytes */ 1969 return; 1970 } 1971 1972 if (c == GSM1_ESCAPE) { 1973 gsm->escape = true; 1974 return; 1975 } 1976 1977 /* Only an unescaped SOF gets us out of GSM search */ 1978 if (gsm->state == GSM_SEARCH) 1979 return; 1980 1981 if (gsm->escape) { 1982 c ^= GSM1_ESCAPE_BITS; 1983 gsm->escape = false; 1984 } 1985 switch (gsm->state) { 1986 case GSM_START: /* First byte after SOF */ 1987 gsm->address = 0; 1988 gsm->state = GSM_ADDRESS; 1989 gsm->fcs = INIT_FCS; 1990 fallthrough; 1991 case GSM_ADDRESS: /* Address continuation */ 1992 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1993 if (gsm_read_ea(&gsm->address, c)) 1994 gsm->state = GSM_CONTROL; 1995 break; 1996 case GSM_CONTROL: /* Control Byte */ 1997 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 1998 gsm->control = c; 1999 gsm->count = 0; 2000 gsm->state = GSM_DATA; 2001 break; 2002 case GSM_DATA: /* Data */ 2003 if (gsm->count > gsm->mru) { /* Allow one for the FCS */ 2004 gsm->state = GSM_OVERRUN; 2005 gsm->bad_size++; 2006 } else 2007 gsm->buf[gsm->count++] = c; 2008 break; 2009 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */ 2010 break; 2011 default: 2012 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state); 2013 break; 2014 } 2015 } 2016 2017 /** 2018 * gsm_error - handle tty error 2019 * @gsm: ldisc data 2020 * @data: byte received (may be invalid) 2021 * @flag: error received 2022 * 2023 * Handle an error in the receipt of data for a frame. Currently we just 2024 * go back to hunting for a SOF. 2025 * 2026 * FIXME: better diagnostics ? 2027 */ 2028 2029 static void gsm_error(struct gsm_mux *gsm, 2030 unsigned char data, unsigned char flag) 2031 { 2032 gsm->state = GSM_SEARCH; 2033 gsm->io_error++; 2034 } 2035 2036 static int gsm_disconnect(struct gsm_mux *gsm) 2037 { 2038 struct gsm_dlci *dlci = gsm->dlci[0]; 2039 struct gsm_control *gc; 2040 2041 if (!dlci) 2042 return 0; 2043 2044 /* In theory disconnecting DLCI 0 is sufficient but for some 2045 modems this is apparently not the case. */ 2046 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0); 2047 if (gc) 2048 gsm_control_wait(gsm, gc); 2049 2050 del_timer_sync(&gsm->t2_timer); 2051 /* Now we are sure T2 has stopped */ 2052 2053 gsm_dlci_begin_close(dlci); 2054 wait_event_interruptible(gsm->event, 2055 dlci->state == DLCI_CLOSED); 2056 2057 if (signal_pending(current)) 2058 return -EINTR; 2059 2060 return 0; 2061 } 2062 2063 /** 2064 * gsm_cleanup_mux - generic GSM protocol cleanup 2065 * @gsm: our mux 2066 * 2067 * Clean up the bits of the mux which are the same for all framing 2068 * protocols. Remove the mux from the mux table, stop all the timers 2069 * and then shut down each device hanging up the channels as we go. 2070 */ 2071 2072 static void gsm_cleanup_mux(struct gsm_mux *gsm) 2073 { 2074 int i; 2075 struct gsm_dlci *dlci = gsm->dlci[0]; 2076 struct gsm_msg *txq, *ntxq; 2077 2078 gsm->dead = true; 2079 2080 spin_lock(&gsm_mux_lock); 2081 for (i = 0; i < MAX_MUX; i++) { 2082 if (gsm_mux[i] == gsm) { 2083 gsm_mux[i] = NULL; 2084 break; 2085 } 2086 } 2087 spin_unlock(&gsm_mux_lock); 2088 /* open failed before registering => nothing to do */ 2089 if (i == MAX_MUX) 2090 return; 2091 2092 del_timer_sync(&gsm->t2_timer); 2093 /* Now we are sure T2 has stopped */ 2094 if (dlci) 2095 dlci->dead = true; 2096 2097 /* Free up any link layer users */ 2098 mutex_lock(&gsm->mutex); 2099 for (i = 0; i < NUM_DLCI; i++) 2100 if (gsm->dlci[i]) 2101 gsm_dlci_release(gsm->dlci[i]); 2102 mutex_unlock(&gsm->mutex); 2103 /* Now wipe the queues */ 2104 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list) 2105 kfree(txq); 2106 INIT_LIST_HEAD(&gsm->tx_list); 2107 } 2108 2109 /** 2110 * gsm_activate_mux - generic GSM setup 2111 * @gsm: our mux 2112 * 2113 * Set up the bits of the mux which are the same for all framing 2114 * protocols. Add the mux to the mux table so it can be opened and 2115 * finally kick off connecting to DLCI 0 on the modem. 2116 */ 2117 2118 static int gsm_activate_mux(struct gsm_mux *gsm) 2119 { 2120 struct gsm_dlci *dlci; 2121 int i = 0; 2122 2123 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0); 2124 init_waitqueue_head(&gsm->event); 2125 spin_lock_init(&gsm->control_lock); 2126 spin_lock_init(&gsm->tx_lock); 2127 2128 if (gsm->encoding == 0) 2129 gsm->receive = gsm0_receive; 2130 else 2131 gsm->receive = gsm1_receive; 2132 2133 spin_lock(&gsm_mux_lock); 2134 for (i = 0; i < MAX_MUX; i++) { 2135 if (gsm_mux[i] == NULL) { 2136 gsm->num = i; 2137 gsm_mux[i] = gsm; 2138 break; 2139 } 2140 } 2141 spin_unlock(&gsm_mux_lock); 2142 if (i == MAX_MUX) 2143 return -EBUSY; 2144 2145 dlci = gsm_dlci_alloc(gsm, 0); 2146 if (dlci == NULL) 2147 return -ENOMEM; 2148 gsm->dead = false; /* Tty opens are now permissible */ 2149 return 0; 2150 } 2151 2152 /** 2153 * gsm_free_mux - free up a mux 2154 * @gsm: mux to free 2155 * 2156 * Dispose of allocated resources for a dead mux 2157 */ 2158 static void gsm_free_mux(struct gsm_mux *gsm) 2159 { 2160 kfree(gsm->txframe); 2161 kfree(gsm->buf); 2162 kfree(gsm); 2163 } 2164 2165 /** 2166 * gsm_free_muxr - free up a mux 2167 * @ref: kreference to the mux to free 2168 * 2169 * Dispose of allocated resources for a dead mux 2170 */ 2171 static void gsm_free_muxr(struct kref *ref) 2172 { 2173 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref); 2174 gsm_free_mux(gsm); 2175 } 2176 2177 static inline void mux_get(struct gsm_mux *gsm) 2178 { 2179 kref_get(&gsm->ref); 2180 } 2181 2182 static inline void mux_put(struct gsm_mux *gsm) 2183 { 2184 kref_put(&gsm->ref, gsm_free_muxr); 2185 } 2186 2187 static inline unsigned int mux_num_to_base(struct gsm_mux *gsm) 2188 { 2189 return gsm->num * NUM_DLCI; 2190 } 2191 2192 static inline unsigned int mux_line_to_num(unsigned int line) 2193 { 2194 return line / NUM_DLCI; 2195 } 2196 2197 /** 2198 * gsm_alloc_mux - allocate a mux 2199 * 2200 * Creates a new mux ready for activation. 2201 */ 2202 2203 static struct gsm_mux *gsm_alloc_mux(void) 2204 { 2205 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL); 2206 if (gsm == NULL) 2207 return NULL; 2208 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL); 2209 if (gsm->buf == NULL) { 2210 kfree(gsm); 2211 return NULL; 2212 } 2213 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL); 2214 if (gsm->txframe == NULL) { 2215 kfree(gsm->buf); 2216 kfree(gsm); 2217 return NULL; 2218 } 2219 spin_lock_init(&gsm->lock); 2220 mutex_init(&gsm->mutex); 2221 kref_init(&gsm->ref); 2222 INIT_LIST_HEAD(&gsm->tx_list); 2223 2224 gsm->t1 = T1; 2225 gsm->t2 = T2; 2226 gsm->n2 = N2; 2227 gsm->ftype = UIH; 2228 gsm->adaption = 1; 2229 gsm->encoding = 1; 2230 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */ 2231 gsm->mtu = 64; 2232 gsm->dead = true; /* Avoid early tty opens */ 2233 2234 return gsm; 2235 } 2236 2237 static void gsm_copy_config_values(struct gsm_mux *gsm, 2238 struct gsm_config *c) 2239 { 2240 memset(c, 0, sizeof(*c)); 2241 c->adaption = gsm->adaption; 2242 c->encapsulation = gsm->encoding; 2243 c->initiator = gsm->initiator; 2244 c->t1 = gsm->t1; 2245 c->t2 = gsm->t2; 2246 c->t3 = 0; /* Not supported */ 2247 c->n2 = gsm->n2; 2248 if (gsm->ftype == UIH) 2249 c->i = 1; 2250 else 2251 c->i = 2; 2252 pr_debug("Ftype %d i %d\n", gsm->ftype, c->i); 2253 c->mru = gsm->mru; 2254 c->mtu = gsm->mtu; 2255 c->k = 0; 2256 } 2257 2258 static int gsm_config(struct gsm_mux *gsm, struct gsm_config *c) 2259 { 2260 int need_close = 0; 2261 int need_restart = 0; 2262 2263 /* Stuff we don't support yet - UI or I frame transport, windowing */ 2264 if ((c->adaption != 1 && c->adaption != 2) || c->k) 2265 return -EOPNOTSUPP; 2266 /* Check the MRU/MTU range looks sane */ 2267 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8) 2268 return -EINVAL; 2269 if (c->n2 < 3) 2270 return -EINVAL; 2271 if (c->encapsulation > 1) /* Basic, advanced, no I */ 2272 return -EINVAL; 2273 if (c->initiator > 1) 2274 return -EINVAL; 2275 if (c->i == 0 || c->i > 2) /* UIH and UI only */ 2276 return -EINVAL; 2277 /* 2278 * See what is needed for reconfiguration 2279 */ 2280 2281 /* Timing fields */ 2282 if (c->t1 != 0 && c->t1 != gsm->t1) 2283 need_restart = 1; 2284 if (c->t2 != 0 && c->t2 != gsm->t2) 2285 need_restart = 1; 2286 if (c->encapsulation != gsm->encoding) 2287 need_restart = 1; 2288 if (c->adaption != gsm->adaption) 2289 need_restart = 1; 2290 /* Requires care */ 2291 if (c->initiator != gsm->initiator) 2292 need_close = 1; 2293 if (c->mru != gsm->mru) 2294 need_restart = 1; 2295 if (c->mtu != gsm->mtu) 2296 need_restart = 1; 2297 2298 /* 2299 * Close down what is needed, restart and initiate the new 2300 * configuration 2301 */ 2302 2303 if (need_close || need_restart) { 2304 int ret; 2305 2306 ret = gsm_disconnect(gsm); 2307 2308 if (ret) 2309 return ret; 2310 } 2311 if (need_restart) 2312 gsm_cleanup_mux(gsm); 2313 2314 gsm->initiator = c->initiator; 2315 gsm->mru = c->mru; 2316 gsm->mtu = c->mtu; 2317 gsm->encoding = c->encapsulation; 2318 gsm->adaption = c->adaption; 2319 gsm->n2 = c->n2; 2320 2321 if (c->i == 1) 2322 gsm->ftype = UIH; 2323 else if (c->i == 2) 2324 gsm->ftype = UI; 2325 2326 if (c->t1) 2327 gsm->t1 = c->t1; 2328 if (c->t2) 2329 gsm->t2 = c->t2; 2330 2331 /* 2332 * FIXME: We need to separate activation/deactivation from adding 2333 * and removing from the mux array 2334 */ 2335 if (need_restart) 2336 gsm_activate_mux(gsm); 2337 if (gsm->initiator && need_close) 2338 gsm_dlci_begin_open(gsm->dlci[0]); 2339 return 0; 2340 } 2341 2342 /** 2343 * gsmld_output - write to link 2344 * @gsm: our mux 2345 * @data: bytes to output 2346 * @len: size 2347 * 2348 * Write a block of data from the GSM mux to the data channel. This 2349 * will eventually be serialized from above but at the moment isn't. 2350 */ 2351 2352 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len) 2353 { 2354 if (tty_write_room(gsm->tty) < len) { 2355 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags); 2356 return -ENOSPC; 2357 } 2358 if (debug & 4) 2359 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET, 2360 data, len); 2361 gsm->tty->ops->write(gsm->tty, data, len); 2362 return len; 2363 } 2364 2365 /** 2366 * gsmld_attach_gsm - mode set up 2367 * @tty: our tty structure 2368 * @gsm: our mux 2369 * 2370 * Set up the MUX for basic mode and commence connecting to the 2371 * modem. Currently called from the line discipline set up but 2372 * will need moving to an ioctl path. 2373 */ 2374 2375 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm) 2376 { 2377 unsigned int base; 2378 int ret, i; 2379 2380 gsm->tty = tty_kref_get(tty); 2381 ret = gsm_activate_mux(gsm); 2382 if (ret != 0) 2383 tty_kref_put(gsm->tty); 2384 else { 2385 /* Don't register device 0 - this is the control channel and not 2386 a usable tty interface */ 2387 base = mux_num_to_base(gsm); /* Base for this MUX */ 2388 for (i = 1; i < NUM_DLCI; i++) { 2389 struct device *dev; 2390 2391 dev = tty_register_device(gsm_tty_driver, 2392 base + i, NULL); 2393 if (IS_ERR(dev)) { 2394 for (i--; i >= 1; i--) 2395 tty_unregister_device(gsm_tty_driver, 2396 base + i); 2397 return PTR_ERR(dev); 2398 } 2399 } 2400 } 2401 return ret; 2402 } 2403 2404 2405 /** 2406 * gsmld_detach_gsm - stop doing 0710 mux 2407 * @tty: tty attached to the mux 2408 * @gsm: mux 2409 * 2410 * Shutdown and then clean up the resources used by the line discipline 2411 */ 2412 2413 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm) 2414 { 2415 unsigned int base = mux_num_to_base(gsm); /* Base for this MUX */ 2416 int i; 2417 2418 WARN_ON(tty != gsm->tty); 2419 for (i = 1; i < NUM_DLCI; i++) 2420 tty_unregister_device(gsm_tty_driver, base + i); 2421 gsm_cleanup_mux(gsm); 2422 tty_kref_put(gsm->tty); 2423 gsm->tty = NULL; 2424 } 2425 2426 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp, 2427 char *fp, int count) 2428 { 2429 struct gsm_mux *gsm = tty->disc_data; 2430 char flags = TTY_NORMAL; 2431 2432 if (debug & 4) 2433 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET, 2434 cp, count); 2435 2436 for (; count; count--, cp++) { 2437 if (fp) 2438 flags = *fp++; 2439 switch (flags) { 2440 case TTY_NORMAL: 2441 gsm->receive(gsm, *cp); 2442 break; 2443 case TTY_OVERRUN: 2444 case TTY_BREAK: 2445 case TTY_PARITY: 2446 case TTY_FRAME: 2447 gsm_error(gsm, *cp, flags); 2448 break; 2449 default: 2450 WARN_ONCE(1, "%s: unknown flag %d\n", 2451 tty_name(tty), flags); 2452 break; 2453 } 2454 } 2455 /* FASYNC if needed ? */ 2456 /* If clogged call tty_throttle(tty); */ 2457 } 2458 2459 /** 2460 * gsmld_flush_buffer - clean input queue 2461 * @tty: terminal device 2462 * 2463 * Flush the input buffer. Called when the line discipline is 2464 * being closed, when the tty layer wants the buffer flushed (eg 2465 * at hangup). 2466 */ 2467 2468 static void gsmld_flush_buffer(struct tty_struct *tty) 2469 { 2470 } 2471 2472 /** 2473 * gsmld_close - close the ldisc for this tty 2474 * @tty: device 2475 * 2476 * Called from the terminal layer when this line discipline is 2477 * being shut down, either because of a close or becsuse of a 2478 * discipline change. The function will not be called while other 2479 * ldisc methods are in progress. 2480 */ 2481 2482 static void gsmld_close(struct tty_struct *tty) 2483 { 2484 struct gsm_mux *gsm = tty->disc_data; 2485 2486 gsmld_detach_gsm(tty, gsm); 2487 2488 gsmld_flush_buffer(tty); 2489 /* Do other clean up here */ 2490 mux_put(gsm); 2491 } 2492 2493 /** 2494 * gsmld_open - open an ldisc 2495 * @tty: terminal to open 2496 * 2497 * Called when this line discipline is being attached to the 2498 * terminal device. Can sleep. Called serialized so that no 2499 * other events will occur in parallel. No further open will occur 2500 * until a close. 2501 */ 2502 2503 static int gsmld_open(struct tty_struct *tty) 2504 { 2505 struct gsm_mux *gsm; 2506 int ret; 2507 2508 if (tty->ops->write == NULL) 2509 return -EINVAL; 2510 2511 /* Attach our ldisc data */ 2512 gsm = gsm_alloc_mux(); 2513 if (gsm == NULL) 2514 return -ENOMEM; 2515 2516 tty->disc_data = gsm; 2517 tty->receive_room = 65536; 2518 2519 /* Attach the initial passive connection */ 2520 gsm->encoding = 1; 2521 2522 ret = gsmld_attach_gsm(tty, gsm); 2523 if (ret != 0) { 2524 gsm_cleanup_mux(gsm); 2525 mux_put(gsm); 2526 } 2527 return ret; 2528 } 2529 2530 /** 2531 * gsmld_write_wakeup - asynchronous I/O notifier 2532 * @tty: tty device 2533 * 2534 * Required for the ptys, serial driver etc. since processes 2535 * that attach themselves to the master and rely on ASYNC 2536 * IO must be woken up 2537 */ 2538 2539 static void gsmld_write_wakeup(struct tty_struct *tty) 2540 { 2541 struct gsm_mux *gsm = tty->disc_data; 2542 unsigned long flags; 2543 2544 /* Queue poll */ 2545 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 2546 spin_lock_irqsave(&gsm->tx_lock, flags); 2547 gsm_data_kick(gsm, NULL); 2548 if (gsm->tx_bytes < TX_THRESH_LO) { 2549 gsm_dlci_data_sweep(gsm); 2550 } 2551 spin_unlock_irqrestore(&gsm->tx_lock, flags); 2552 } 2553 2554 /** 2555 * gsmld_read - read function for tty 2556 * @tty: tty device 2557 * @file: file object 2558 * @buf: userspace buffer pointer 2559 * @nr: size of I/O 2560 * 2561 * Perform reads for the line discipline. We are guaranteed that the 2562 * line discipline will not be closed under us but we may get multiple 2563 * parallel readers and must handle this ourselves. We may also get 2564 * a hangup. Always called in user context, may sleep. 2565 * 2566 * This code must be sure never to sleep through a hangup. 2567 */ 2568 2569 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file, 2570 unsigned char *buf, size_t nr, 2571 void **cookie, unsigned long offset) 2572 { 2573 return -EOPNOTSUPP; 2574 } 2575 2576 /** 2577 * gsmld_write - write function for tty 2578 * @tty: tty device 2579 * @file: file object 2580 * @buf: userspace buffer pointer 2581 * @nr: size of I/O 2582 * 2583 * Called when the owner of the device wants to send a frame 2584 * itself (or some other control data). The data is transferred 2585 * as-is and must be properly framed and checksummed as appropriate 2586 * by userspace. Frames are either sent whole or not at all as this 2587 * avoids pain user side. 2588 */ 2589 2590 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file, 2591 const unsigned char *buf, size_t nr) 2592 { 2593 int space = tty_write_room(tty); 2594 if (space >= nr) 2595 return tty->ops->write(tty, buf, nr); 2596 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 2597 return -ENOBUFS; 2598 } 2599 2600 /** 2601 * gsmld_poll - poll method for N_GSM0710 2602 * @tty: terminal device 2603 * @file: file accessing it 2604 * @wait: poll table 2605 * 2606 * Called when the line discipline is asked to poll() for data or 2607 * for special events. This code is not serialized with respect to 2608 * other events save open/close. 2609 * 2610 * This code must be sure never to sleep through a hangup. 2611 * Called without the kernel lock held - fine 2612 */ 2613 2614 static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file, 2615 poll_table *wait) 2616 { 2617 __poll_t mask = 0; 2618 struct gsm_mux *gsm = tty->disc_data; 2619 2620 poll_wait(file, &tty->read_wait, wait); 2621 poll_wait(file, &tty->write_wait, wait); 2622 if (tty_hung_up_p(file)) 2623 mask |= EPOLLHUP; 2624 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0) 2625 mask |= EPOLLOUT | EPOLLWRNORM; 2626 if (gsm->dead) 2627 mask |= EPOLLHUP; 2628 return mask; 2629 } 2630 2631 static int gsmld_ioctl(struct tty_struct *tty, struct file *file, 2632 unsigned int cmd, unsigned long arg) 2633 { 2634 struct gsm_config c; 2635 struct gsm_mux *gsm = tty->disc_data; 2636 unsigned int base; 2637 2638 switch (cmd) { 2639 case GSMIOC_GETCONF: 2640 gsm_copy_config_values(gsm, &c); 2641 if (copy_to_user((void __user *)arg, &c, sizeof(c))) 2642 return -EFAULT; 2643 return 0; 2644 case GSMIOC_SETCONF: 2645 if (copy_from_user(&c, (void __user *)arg, sizeof(c))) 2646 return -EFAULT; 2647 return gsm_config(gsm, &c); 2648 case GSMIOC_GETFIRST: 2649 base = mux_num_to_base(gsm); 2650 return put_user(base + 1, (__u32 __user *)arg); 2651 default: 2652 return n_tty_ioctl_helper(tty, file, cmd, arg); 2653 } 2654 } 2655 2656 /* 2657 * Network interface 2658 * 2659 */ 2660 2661 static int gsm_mux_net_open(struct net_device *net) 2662 { 2663 pr_debug("%s called\n", __func__); 2664 netif_start_queue(net); 2665 return 0; 2666 } 2667 2668 static int gsm_mux_net_close(struct net_device *net) 2669 { 2670 netif_stop_queue(net); 2671 return 0; 2672 } 2673 2674 static void dlci_net_free(struct gsm_dlci *dlci) 2675 { 2676 if (!dlci->net) { 2677 WARN_ON(1); 2678 return; 2679 } 2680 dlci->adaption = dlci->prev_adaption; 2681 dlci->data = dlci->prev_data; 2682 free_netdev(dlci->net); 2683 dlci->net = NULL; 2684 } 2685 static void net_free(struct kref *ref) 2686 { 2687 struct gsm_mux_net *mux_net; 2688 struct gsm_dlci *dlci; 2689 2690 mux_net = container_of(ref, struct gsm_mux_net, ref); 2691 dlci = mux_net->dlci; 2692 2693 if (dlci->net) { 2694 unregister_netdev(dlci->net); 2695 dlci_net_free(dlci); 2696 } 2697 } 2698 2699 static inline void muxnet_get(struct gsm_mux_net *mux_net) 2700 { 2701 kref_get(&mux_net->ref); 2702 } 2703 2704 static inline void muxnet_put(struct gsm_mux_net *mux_net) 2705 { 2706 kref_put(&mux_net->ref, net_free); 2707 } 2708 2709 static netdev_tx_t gsm_mux_net_start_xmit(struct sk_buff *skb, 2710 struct net_device *net) 2711 { 2712 struct gsm_mux_net *mux_net = netdev_priv(net); 2713 struct gsm_dlci *dlci = mux_net->dlci; 2714 muxnet_get(mux_net); 2715 2716 skb_queue_head(&dlci->skb_list, skb); 2717 net->stats.tx_packets++; 2718 net->stats.tx_bytes += skb->len; 2719 gsm_dlci_data_kick(dlci); 2720 /* And tell the kernel when the last transmit started. */ 2721 netif_trans_update(net); 2722 muxnet_put(mux_net); 2723 return NETDEV_TX_OK; 2724 } 2725 2726 /* called when a packet did not ack after watchdogtimeout */ 2727 static void gsm_mux_net_tx_timeout(struct net_device *net, unsigned int txqueue) 2728 { 2729 /* Tell syslog we are hosed. */ 2730 dev_dbg(&net->dev, "Tx timed out.\n"); 2731 2732 /* Update statistics */ 2733 net->stats.tx_errors++; 2734 } 2735 2736 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci, 2737 const unsigned char *in_buf, int size) 2738 { 2739 struct net_device *net = dlci->net; 2740 struct sk_buff *skb; 2741 struct gsm_mux_net *mux_net = netdev_priv(net); 2742 muxnet_get(mux_net); 2743 2744 /* Allocate an sk_buff */ 2745 skb = dev_alloc_skb(size + NET_IP_ALIGN); 2746 if (!skb) { 2747 /* We got no receive buffer. */ 2748 net->stats.rx_dropped++; 2749 muxnet_put(mux_net); 2750 return; 2751 } 2752 skb_reserve(skb, NET_IP_ALIGN); 2753 skb_put_data(skb, in_buf, size); 2754 2755 skb->dev = net; 2756 skb->protocol = htons(ETH_P_IP); 2757 2758 /* Ship it off to the kernel */ 2759 netif_rx(skb); 2760 2761 /* update out statistics */ 2762 net->stats.rx_packets++; 2763 net->stats.rx_bytes += size; 2764 muxnet_put(mux_net); 2765 return; 2766 } 2767 2768 static void gsm_mux_net_init(struct net_device *net) 2769 { 2770 static const struct net_device_ops gsm_netdev_ops = { 2771 .ndo_open = gsm_mux_net_open, 2772 .ndo_stop = gsm_mux_net_close, 2773 .ndo_start_xmit = gsm_mux_net_start_xmit, 2774 .ndo_tx_timeout = gsm_mux_net_tx_timeout, 2775 }; 2776 2777 net->netdev_ops = &gsm_netdev_ops; 2778 2779 /* fill in the other fields */ 2780 net->watchdog_timeo = GSM_NET_TX_TIMEOUT; 2781 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 2782 net->type = ARPHRD_NONE; 2783 net->tx_queue_len = 10; 2784 } 2785 2786 2787 /* caller holds the dlci mutex */ 2788 static void gsm_destroy_network(struct gsm_dlci *dlci) 2789 { 2790 struct gsm_mux_net *mux_net; 2791 2792 pr_debug("destroy network interface\n"); 2793 if (!dlci->net) 2794 return; 2795 mux_net = netdev_priv(dlci->net); 2796 muxnet_put(mux_net); 2797 } 2798 2799 2800 /* caller holds the dlci mutex */ 2801 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc) 2802 { 2803 char *netname; 2804 int retval = 0; 2805 struct net_device *net; 2806 struct gsm_mux_net *mux_net; 2807 2808 if (!capable(CAP_NET_ADMIN)) 2809 return -EPERM; 2810 2811 /* Already in a non tty mode */ 2812 if (dlci->adaption > 2) 2813 return -EBUSY; 2814 2815 if (nc->protocol != htons(ETH_P_IP)) 2816 return -EPROTONOSUPPORT; 2817 2818 if (nc->adaption != 3 && nc->adaption != 4) 2819 return -EPROTONOSUPPORT; 2820 2821 pr_debug("create network interface\n"); 2822 2823 netname = "gsm%d"; 2824 if (nc->if_name[0] != '\0') 2825 netname = nc->if_name; 2826 net = alloc_netdev(sizeof(struct gsm_mux_net), netname, 2827 NET_NAME_UNKNOWN, gsm_mux_net_init); 2828 if (!net) { 2829 pr_err("alloc_netdev failed\n"); 2830 return -ENOMEM; 2831 } 2832 net->mtu = dlci->gsm->mtu; 2833 net->min_mtu = 8; 2834 net->max_mtu = dlci->gsm->mtu; 2835 mux_net = netdev_priv(net); 2836 mux_net->dlci = dlci; 2837 kref_init(&mux_net->ref); 2838 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */ 2839 2840 /* reconfigure dlci for network */ 2841 dlci->prev_adaption = dlci->adaption; 2842 dlci->prev_data = dlci->data; 2843 dlci->adaption = nc->adaption; 2844 dlci->data = gsm_mux_rx_netchar; 2845 dlci->net = net; 2846 2847 pr_debug("register netdev\n"); 2848 retval = register_netdev(net); 2849 if (retval) { 2850 pr_err("network register fail %d\n", retval); 2851 dlci_net_free(dlci); 2852 return retval; 2853 } 2854 return net->ifindex; /* return network index */ 2855 } 2856 2857 /* Line discipline for real tty */ 2858 static struct tty_ldisc_ops tty_ldisc_packet = { 2859 .owner = THIS_MODULE, 2860 .name = "n_gsm", 2861 .open = gsmld_open, 2862 .close = gsmld_close, 2863 .flush_buffer = gsmld_flush_buffer, 2864 .read = gsmld_read, 2865 .write = gsmld_write, 2866 .ioctl = gsmld_ioctl, 2867 .poll = gsmld_poll, 2868 .receive_buf = gsmld_receive_buf, 2869 .write_wakeup = gsmld_write_wakeup 2870 }; 2871 2872 /* 2873 * Virtual tty side 2874 */ 2875 2876 #define TX_SIZE 512 2877 2878 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk) 2879 { 2880 u8 modembits[5]; 2881 struct gsm_control *ctrl; 2882 int len = 2; 2883 2884 if (brk) 2885 len++; 2886 2887 modembits[0] = len << 1 | EA; /* Data bytes */ 2888 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */ 2889 modembits[2] = gsm_encode_modem(dlci) << 1 | EA; 2890 if (brk) 2891 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */ 2892 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1); 2893 if (ctrl == NULL) 2894 return -ENOMEM; 2895 return gsm_control_wait(dlci->gsm, ctrl); 2896 } 2897 2898 static int gsm_carrier_raised(struct tty_port *port) 2899 { 2900 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 2901 struct gsm_mux *gsm = dlci->gsm; 2902 2903 /* Not yet open so no carrier info */ 2904 if (dlci->state != DLCI_OPEN) 2905 return 0; 2906 if (debug & 2) 2907 return 1; 2908 2909 /* 2910 * Basic mode with control channel in ADM mode may not respond 2911 * to CMD_MSC at all and modem_rx is empty. 2912 */ 2913 if (gsm->encoding == 0 && gsm->dlci[0]->mode == DLCI_MODE_ADM && 2914 !dlci->modem_rx) 2915 return 1; 2916 2917 return dlci->modem_rx & TIOCM_CD; 2918 } 2919 2920 static void gsm_dtr_rts(struct tty_port *port, int onoff) 2921 { 2922 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 2923 unsigned int modem_tx = dlci->modem_tx; 2924 if (onoff) 2925 modem_tx |= TIOCM_DTR | TIOCM_RTS; 2926 else 2927 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS); 2928 if (modem_tx != dlci->modem_tx) { 2929 dlci->modem_tx = modem_tx; 2930 gsmtty_modem_update(dlci, 0); 2931 } 2932 } 2933 2934 static const struct tty_port_operations gsm_port_ops = { 2935 .carrier_raised = gsm_carrier_raised, 2936 .dtr_rts = gsm_dtr_rts, 2937 .destruct = gsm_dlci_free, 2938 }; 2939 2940 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty) 2941 { 2942 struct gsm_mux *gsm; 2943 struct gsm_dlci *dlci; 2944 unsigned int line = tty->index; 2945 unsigned int mux = mux_line_to_num(line); 2946 bool alloc = false; 2947 int ret; 2948 2949 line = line & 0x3F; 2950 2951 if (mux >= MAX_MUX) 2952 return -ENXIO; 2953 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */ 2954 if (gsm_mux[mux] == NULL) 2955 return -EUNATCH; 2956 if (line == 0 || line > 61) /* 62/63 reserved */ 2957 return -ECHRNG; 2958 gsm = gsm_mux[mux]; 2959 if (gsm->dead) 2960 return -EL2HLT; 2961 /* If DLCI 0 is not yet fully open return an error. 2962 This is ok from a locking 2963 perspective as we don't have to worry about this 2964 if DLCI0 is lost */ 2965 mutex_lock(&gsm->mutex); 2966 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) { 2967 mutex_unlock(&gsm->mutex); 2968 return -EL2NSYNC; 2969 } 2970 dlci = gsm->dlci[line]; 2971 if (dlci == NULL) { 2972 alloc = true; 2973 dlci = gsm_dlci_alloc(gsm, line); 2974 } 2975 if (dlci == NULL) { 2976 mutex_unlock(&gsm->mutex); 2977 return -ENOMEM; 2978 } 2979 ret = tty_port_install(&dlci->port, driver, tty); 2980 if (ret) { 2981 if (alloc) 2982 dlci_put(dlci); 2983 mutex_unlock(&gsm->mutex); 2984 return ret; 2985 } 2986 2987 dlci_get(dlci); 2988 dlci_get(gsm->dlci[0]); 2989 mux_get(gsm); 2990 tty->driver_data = dlci; 2991 mutex_unlock(&gsm->mutex); 2992 2993 return 0; 2994 } 2995 2996 static int gsmtty_open(struct tty_struct *tty, struct file *filp) 2997 { 2998 struct gsm_dlci *dlci = tty->driver_data; 2999 struct tty_port *port = &dlci->port; 3000 3001 port->count++; 3002 tty_port_tty_set(port, tty); 3003 3004 dlci->modem_rx = 0; 3005 /* We could in theory open and close before we wait - eg if we get 3006 a DM straight back. This is ok as that will have caused a hangup */ 3007 tty_port_set_initialized(port, 1); 3008 /* Start sending off SABM messages */ 3009 gsm_dlci_begin_open(dlci); 3010 /* And wait for virtual carrier */ 3011 return tty_port_block_til_ready(port, tty, filp); 3012 } 3013 3014 static void gsmtty_close(struct tty_struct *tty, struct file *filp) 3015 { 3016 struct gsm_dlci *dlci = tty->driver_data; 3017 3018 if (dlci == NULL) 3019 return; 3020 if (dlci->state == DLCI_CLOSED) 3021 return; 3022 mutex_lock(&dlci->mutex); 3023 gsm_destroy_network(dlci); 3024 mutex_unlock(&dlci->mutex); 3025 if (tty_port_close_start(&dlci->port, tty, filp) == 0) 3026 return; 3027 gsm_dlci_begin_close(dlci); 3028 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty)) 3029 tty_port_lower_dtr_rts(&dlci->port); 3030 tty_port_close_end(&dlci->port, tty); 3031 tty_port_tty_set(&dlci->port, NULL); 3032 return; 3033 } 3034 3035 static void gsmtty_hangup(struct tty_struct *tty) 3036 { 3037 struct gsm_dlci *dlci = tty->driver_data; 3038 if (dlci->state == DLCI_CLOSED) 3039 return; 3040 tty_port_hangup(&dlci->port); 3041 gsm_dlci_begin_close(dlci); 3042 } 3043 3044 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf, 3045 int len) 3046 { 3047 int sent; 3048 struct gsm_dlci *dlci = tty->driver_data; 3049 if (dlci->state == DLCI_CLOSED) 3050 return -EINVAL; 3051 /* Stuff the bytes into the fifo queue */ 3052 sent = kfifo_in_locked(&dlci->fifo, buf, len, &dlci->lock); 3053 /* Need to kick the channel */ 3054 gsm_dlci_data_kick(dlci); 3055 return sent; 3056 } 3057 3058 static int gsmtty_write_room(struct tty_struct *tty) 3059 { 3060 struct gsm_dlci *dlci = tty->driver_data; 3061 if (dlci->state == DLCI_CLOSED) 3062 return 0; 3063 return TX_SIZE - kfifo_len(&dlci->fifo); 3064 } 3065 3066 static int gsmtty_chars_in_buffer(struct tty_struct *tty) 3067 { 3068 struct gsm_dlci *dlci = tty->driver_data; 3069 if (dlci->state == DLCI_CLOSED) 3070 return 0; 3071 return kfifo_len(&dlci->fifo); 3072 } 3073 3074 static void gsmtty_flush_buffer(struct tty_struct *tty) 3075 { 3076 struct gsm_dlci *dlci = tty->driver_data; 3077 if (dlci->state == DLCI_CLOSED) 3078 return; 3079 /* Caution needed: If we implement reliable transport classes 3080 then the data being transmitted can't simply be junked once 3081 it has first hit the stack. Until then we can just blow it 3082 away */ 3083 kfifo_reset(&dlci->fifo); 3084 /* Need to unhook this DLCI from the transmit queue logic */ 3085 } 3086 3087 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout) 3088 { 3089 /* The FIFO handles the queue so the kernel will do the right 3090 thing waiting on chars_in_buffer before calling us. No work 3091 to do here */ 3092 } 3093 3094 static int gsmtty_tiocmget(struct tty_struct *tty) 3095 { 3096 struct gsm_dlci *dlci = tty->driver_data; 3097 if (dlci->state == DLCI_CLOSED) 3098 return -EINVAL; 3099 return dlci->modem_rx; 3100 } 3101 3102 static int gsmtty_tiocmset(struct tty_struct *tty, 3103 unsigned int set, unsigned int clear) 3104 { 3105 struct gsm_dlci *dlci = tty->driver_data; 3106 unsigned int modem_tx = dlci->modem_tx; 3107 3108 if (dlci->state == DLCI_CLOSED) 3109 return -EINVAL; 3110 modem_tx &= ~clear; 3111 modem_tx |= set; 3112 3113 if (modem_tx != dlci->modem_tx) { 3114 dlci->modem_tx = modem_tx; 3115 return gsmtty_modem_update(dlci, 0); 3116 } 3117 return 0; 3118 } 3119 3120 3121 static int gsmtty_ioctl(struct tty_struct *tty, 3122 unsigned int cmd, unsigned long arg) 3123 { 3124 struct gsm_dlci *dlci = tty->driver_data; 3125 struct gsm_netconfig nc; 3126 int index; 3127 3128 if (dlci->state == DLCI_CLOSED) 3129 return -EINVAL; 3130 switch (cmd) { 3131 case GSMIOC_ENABLE_NET: 3132 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc))) 3133 return -EFAULT; 3134 nc.if_name[IFNAMSIZ-1] = '\0'; 3135 /* return net interface index or error code */ 3136 mutex_lock(&dlci->mutex); 3137 index = gsm_create_network(dlci, &nc); 3138 mutex_unlock(&dlci->mutex); 3139 if (copy_to_user((void __user *)arg, &nc, sizeof(nc))) 3140 return -EFAULT; 3141 return index; 3142 case GSMIOC_DISABLE_NET: 3143 if (!capable(CAP_NET_ADMIN)) 3144 return -EPERM; 3145 mutex_lock(&dlci->mutex); 3146 gsm_destroy_network(dlci); 3147 mutex_unlock(&dlci->mutex); 3148 return 0; 3149 default: 3150 return -ENOIOCTLCMD; 3151 } 3152 } 3153 3154 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old) 3155 { 3156 struct gsm_dlci *dlci = tty->driver_data; 3157 if (dlci->state == DLCI_CLOSED) 3158 return; 3159 /* For the moment its fixed. In actual fact the speed information 3160 for the virtual channel can be propogated in both directions by 3161 the RPN control message. This however rapidly gets nasty as we 3162 then have to remap modem signals each way according to whether 3163 our virtual cable is null modem etc .. */ 3164 tty_termios_copy_hw(&tty->termios, old); 3165 } 3166 3167 static void gsmtty_throttle(struct tty_struct *tty) 3168 { 3169 struct gsm_dlci *dlci = tty->driver_data; 3170 if (dlci->state == DLCI_CLOSED) 3171 return; 3172 if (C_CRTSCTS(tty)) 3173 dlci->modem_tx &= ~TIOCM_DTR; 3174 dlci->throttled = true; 3175 /* Send an MSC with DTR cleared */ 3176 gsmtty_modem_update(dlci, 0); 3177 } 3178 3179 static void gsmtty_unthrottle(struct tty_struct *tty) 3180 { 3181 struct gsm_dlci *dlci = tty->driver_data; 3182 if (dlci->state == DLCI_CLOSED) 3183 return; 3184 if (C_CRTSCTS(tty)) 3185 dlci->modem_tx |= TIOCM_DTR; 3186 dlci->throttled = false; 3187 /* Send an MSC with DTR set */ 3188 gsmtty_modem_update(dlci, 0); 3189 } 3190 3191 static int gsmtty_break_ctl(struct tty_struct *tty, int state) 3192 { 3193 struct gsm_dlci *dlci = tty->driver_data; 3194 int encode = 0; /* Off */ 3195 if (dlci->state == DLCI_CLOSED) 3196 return -EINVAL; 3197 3198 if (state == -1) /* "On indefinitely" - we can't encode this 3199 properly */ 3200 encode = 0x0F; 3201 else if (state > 0) { 3202 encode = state / 200; /* mS to encoding */ 3203 if (encode > 0x0F) 3204 encode = 0x0F; /* Best effort */ 3205 } 3206 return gsmtty_modem_update(dlci, encode); 3207 } 3208 3209 static void gsmtty_cleanup(struct tty_struct *tty) 3210 { 3211 struct gsm_dlci *dlci = tty->driver_data; 3212 struct gsm_mux *gsm = dlci->gsm; 3213 3214 dlci_put(dlci); 3215 dlci_put(gsm->dlci[0]); 3216 mux_put(gsm); 3217 } 3218 3219 /* Virtual ttys for the demux */ 3220 static const struct tty_operations gsmtty_ops = { 3221 .install = gsmtty_install, 3222 .open = gsmtty_open, 3223 .close = gsmtty_close, 3224 .write = gsmtty_write, 3225 .write_room = gsmtty_write_room, 3226 .chars_in_buffer = gsmtty_chars_in_buffer, 3227 .flush_buffer = gsmtty_flush_buffer, 3228 .ioctl = gsmtty_ioctl, 3229 .throttle = gsmtty_throttle, 3230 .unthrottle = gsmtty_unthrottle, 3231 .set_termios = gsmtty_set_termios, 3232 .hangup = gsmtty_hangup, 3233 .wait_until_sent = gsmtty_wait_until_sent, 3234 .tiocmget = gsmtty_tiocmget, 3235 .tiocmset = gsmtty_tiocmset, 3236 .break_ctl = gsmtty_break_ctl, 3237 .cleanup = gsmtty_cleanup, 3238 }; 3239 3240 3241 3242 static int __init gsm_init(void) 3243 { 3244 /* Fill in our line protocol discipline, and register it */ 3245 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet); 3246 if (status != 0) { 3247 pr_err("n_gsm: can't register line discipline (err = %d)\n", 3248 status); 3249 return status; 3250 } 3251 3252 gsm_tty_driver = alloc_tty_driver(256); 3253 if (!gsm_tty_driver) { 3254 tty_unregister_ldisc(N_GSM0710); 3255 pr_err("gsm_init: tty allocation failed.\n"); 3256 return -EINVAL; 3257 } 3258 gsm_tty_driver->driver_name = "gsmtty"; 3259 gsm_tty_driver->name = "gsmtty"; 3260 gsm_tty_driver->major = 0; /* Dynamic */ 3261 gsm_tty_driver->minor_start = 0; 3262 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 3263 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 3264 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV 3265 | TTY_DRIVER_HARDWARE_BREAK; 3266 gsm_tty_driver->init_termios = tty_std_termios; 3267 /* Fixme */ 3268 gsm_tty_driver->init_termios.c_lflag &= ~ECHO; 3269 tty_set_operations(gsm_tty_driver, &gsmtty_ops); 3270 3271 if (tty_register_driver(gsm_tty_driver)) { 3272 put_tty_driver(gsm_tty_driver); 3273 tty_unregister_ldisc(N_GSM0710); 3274 pr_err("gsm_init: tty registration failed.\n"); 3275 return -EBUSY; 3276 } 3277 pr_debug("gsm_init: loaded as %d,%d.\n", 3278 gsm_tty_driver->major, gsm_tty_driver->minor_start); 3279 return 0; 3280 } 3281 3282 static void __exit gsm_exit(void) 3283 { 3284 int status = tty_unregister_ldisc(N_GSM0710); 3285 if (status != 0) 3286 pr_err("n_gsm: can't unregister line discipline (err = %d)\n", 3287 status); 3288 tty_unregister_driver(gsm_tty_driver); 3289 put_tty_driver(gsm_tty_driver); 3290 } 3291 3292 module_init(gsm_init); 3293 module_exit(gsm_exit); 3294 3295 3296 MODULE_LICENSE("GPL"); 3297 MODULE_ALIAS_LDISC(N_GSM0710); 3298