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 * Outgoing path: 9 * tty -> DLCI fifo -> scheduler -> GSM MUX data queue ---o-> ldisc 10 * control message -> GSM MUX control queue --´ 11 * 12 * Incoming path: 13 * ldisc -> gsm_queue() -o--> tty 14 * `-> gsm_control_response() 15 * 16 * TO DO: 17 * Mostly done: ioctls for setting modes/timing 18 * Partly done: hooks so you can pull off frames to non tty devs 19 * Restart DLCI 0 when it closes ? 20 * Improve the tx engine 21 * Resolve tx side locking by adding a queue_head and routing 22 * all control traffic via it 23 * General tidy/document 24 * Review the locking/move to refcounts more (mux now moved to an 25 * alloc/free model ready) 26 * Use newest tty open/close port helpers and install hooks 27 * What to do about power functions ? 28 * Termios setting and negotiation 29 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets 30 * 31 */ 32 33 #include <linux/types.h> 34 #include <linux/major.h> 35 #include <linux/errno.h> 36 #include <linux/signal.h> 37 #include <linux/fcntl.h> 38 #include <linux/sched/signal.h> 39 #include <linux/interrupt.h> 40 #include <linux/tty.h> 41 #include <linux/bitfield.h> 42 #include <linux/ctype.h> 43 #include <linux/mm.h> 44 #include <linux/math.h> 45 #include <linux/nospec.h> 46 #include <linux/string.h> 47 #include <linux/slab.h> 48 #include <linux/poll.h> 49 #include <linux/bitops.h> 50 #include <linux/file.h> 51 #include <linux/uaccess.h> 52 #include <linux/module.h> 53 #include <linux/timer.h> 54 #include <linux/tty_flip.h> 55 #include <linux/tty_driver.h> 56 #include <linux/serial.h> 57 #include <linux/kfifo.h> 58 #include <linux/skbuff.h> 59 #include <net/arp.h> 60 #include <linux/ip.h> 61 #include <linux/netdevice.h> 62 #include <linux/etherdevice.h> 63 #include <linux/gsmmux.h> 64 #include "tty.h" 65 66 static int debug; 67 module_param(debug, int, 0600); 68 69 /* Module debug bits */ 70 #define DBG_DUMP BIT(0) /* Data transmission dump. */ 71 #define DBG_CD_ON BIT(1) /* Always assume CD line on. */ 72 #define DBG_DATA BIT(2) /* Data transmission details. */ 73 #define DBG_ERRORS BIT(3) /* Details for fail conditions. */ 74 #define DBG_TTY BIT(4) /* Transmission statistics for DLCI TTYs. */ 75 #define DBG_PAYLOAD BIT(5) /* Limits DBG_DUMP to payload frames. */ 76 77 /* Defaults: these are from the specification */ 78 79 #define T1 10 /* 100mS */ 80 #define T2 34 /* 333mS */ 81 #define T3 10 /* 10s */ 82 #define N2 3 /* Retry 3 times */ 83 #define K 2 /* outstanding I frames */ 84 85 #define MAX_T3 255 /* In seconds. */ 86 #define MAX_WINDOW_SIZE 7 /* Limit of K in error recovery mode. */ 87 88 /* Use long timers for testing at low speed with debug on */ 89 #ifdef DEBUG_TIMING 90 #define T1 100 91 #define T2 200 92 #endif 93 94 /* 95 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte 96 * limits so this is plenty 97 */ 98 #define MAX_MRU 1500 99 #define MAX_MTU 1500 100 #define MIN_MTU (PROT_OVERHEAD + 1) 101 /* SOF, ADDR, CTRL, LEN1, LEN2, ..., FCS, EOF */ 102 #define PROT_OVERHEAD 7 103 #define GSM_NET_TX_TIMEOUT (HZ*10) 104 105 /* 106 * struct gsm_mux_net - network interface 107 * 108 * Created when net interface is initialized. 109 */ 110 struct gsm_mux_net { 111 struct kref ref; 112 struct gsm_dlci *dlci; 113 }; 114 115 /* 116 * Each block of data we have queued to go out is in the form of 117 * a gsm_msg which holds everything we need in a link layer independent 118 * format 119 */ 120 121 struct gsm_msg { 122 struct list_head list; 123 u8 addr; /* DLCI address + flags */ 124 u8 ctrl; /* Control byte + flags */ 125 unsigned int len; /* Length of data block (can be zero) */ 126 unsigned char *data; /* Points into buffer but not at the start */ 127 unsigned char buffer[]; 128 }; 129 130 enum gsm_dlci_state { 131 DLCI_CLOSED, 132 DLCI_WAITING_CONFIG, /* Waiting for DLCI configuration from user */ 133 DLCI_CONFIGURE, /* Sending PN (for adaption > 1) */ 134 DLCI_OPENING, /* Sending SABM not seen UA */ 135 DLCI_OPEN, /* SABM/UA complete */ 136 DLCI_CLOSING, /* Sending DISC not seen UA/DM */ 137 }; 138 139 enum gsm_dlci_mode { 140 DLCI_MODE_ABM, /* Normal Asynchronous Balanced Mode */ 141 DLCI_MODE_ADM, /* Asynchronous Disconnected Mode */ 142 }; 143 144 /* 145 * Each active data link has a gsm_dlci structure associated which ties 146 * the link layer to an optional tty (if the tty side is open). To avoid 147 * complexity right now these are only ever freed up when the mux is 148 * shut down. 149 * 150 * At the moment we don't free DLCI objects until the mux is torn down 151 * this avoid object life time issues but might be worth review later. 152 */ 153 154 struct gsm_dlci { 155 struct gsm_mux *gsm; 156 int addr; 157 enum gsm_dlci_state state; 158 struct mutex mutex; 159 160 /* Link layer */ 161 enum gsm_dlci_mode mode; 162 spinlock_t lock; /* Protects the internal state */ 163 struct timer_list t1; /* Retransmit timer for SABM and UA */ 164 int retries; 165 /* Uplink tty if active */ 166 struct tty_port port; /* The tty bound to this DLCI if there is one */ 167 #define TX_SIZE 4096 /* Must be power of 2. */ 168 struct kfifo fifo; /* Queue fifo for the DLCI */ 169 int adaption; /* Adaption layer in use */ 170 int prev_adaption; 171 u32 modem_rx; /* Our incoming virtual modem lines */ 172 u32 modem_tx; /* Our outgoing modem lines */ 173 unsigned int mtu; 174 bool dead; /* Refuse re-open */ 175 /* Configuration */ 176 u8 prio; /* Priority */ 177 u8 ftype; /* Frame type */ 178 u8 k; /* Window size */ 179 /* Flow control */ 180 bool throttled; /* Private copy of throttle state */ 181 bool constipated; /* Throttle status for outgoing */ 182 /* Packetised I/O */ 183 struct sk_buff *skb; /* Frame being sent */ 184 struct sk_buff_head skb_list; /* Queued frames */ 185 /* Data handling callback */ 186 void (*data)(struct gsm_dlci *dlci, const u8 *data, int len); 187 void (*prev_data)(struct gsm_dlci *dlci, const u8 *data, int len); 188 struct net_device *net; /* network interface, if created */ 189 }; 190 191 /* 192 * Parameter bits used for parameter negotiation according to 3GPP 27.010 193 * chapter 5.4.6.3.1. 194 */ 195 196 struct gsm_dlci_param_bits { 197 u8 d_bits; 198 u8 i_cl_bits; 199 u8 p_bits; 200 u8 t_bits; 201 __le16 n_bits; 202 u8 na_bits; 203 u8 k_bits; 204 }; 205 206 static_assert(sizeof(struct gsm_dlci_param_bits) == 8); 207 208 #define PN_D_FIELD_DLCI GENMASK(5, 0) 209 #define PN_I_CL_FIELD_FTYPE GENMASK(3, 0) 210 #define PN_I_CL_FIELD_ADAPTION GENMASK(7, 4) 211 #define PN_P_FIELD_PRIO GENMASK(5, 0) 212 #define PN_T_FIELD_T1 GENMASK(7, 0) 213 #define PN_N_FIELD_N1 GENMASK(15, 0) 214 #define PN_NA_FIELD_N2 GENMASK(7, 0) 215 #define PN_K_FIELD_K GENMASK(2, 0) 216 217 /* Total number of supported devices */ 218 #define GSM_TTY_MINORS 256 219 220 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */ 221 222 #define NUM_DLCI 64 223 224 /* 225 * DLCI 0 is used to pass control blocks out of band of the data 226 * flow (and with a higher link priority). One command can be outstanding 227 * at a time and we use this structure to manage them. They are created 228 * and destroyed by the user context, and updated by the receive paths 229 * and timers 230 */ 231 232 struct gsm_control { 233 u8 cmd; /* Command we are issuing */ 234 u8 *data; /* Data for the command in case we retransmit */ 235 int len; /* Length of block for retransmission */ 236 int done; /* Done flag */ 237 int error; /* Error if any */ 238 }; 239 240 enum gsm_encoding { 241 GSM_BASIC_OPT, 242 GSM_ADV_OPT, 243 }; 244 245 enum gsm_mux_state { 246 GSM_SEARCH, 247 GSM_START, 248 GSM_ADDRESS, 249 GSM_CONTROL, 250 GSM_LEN, 251 GSM_DATA, 252 GSM_FCS, 253 GSM_OVERRUN, 254 GSM_LEN0, 255 GSM_LEN1, 256 GSM_SSOF, 257 }; 258 259 /* 260 * Each GSM mux we have is represented by this structure. If we are 261 * operating as an ldisc then we use this structure as our ldisc 262 * state. We need to sort out lifetimes and locking with respect 263 * to the gsm mux array. For now we don't free DLCI objects that 264 * have been instantiated until the mux itself is terminated. 265 * 266 * To consider further: tty open versus mux shutdown. 267 */ 268 269 struct gsm_mux { 270 struct tty_struct *tty; /* The tty our ldisc is bound to */ 271 spinlock_t lock; 272 struct mutex mutex; 273 unsigned int num; 274 struct kref ref; 275 276 /* Events on the GSM channel */ 277 wait_queue_head_t event; 278 279 /* ldisc send work */ 280 struct work_struct tx_work; 281 282 /* Bits for GSM mode decoding */ 283 284 /* Framing Layer */ 285 unsigned char *buf; 286 enum gsm_mux_state state; 287 unsigned int len; 288 unsigned int address; 289 unsigned int count; 290 bool escape; 291 enum gsm_encoding encoding; 292 u8 control; 293 u8 fcs; 294 u8 *txframe; /* TX framing buffer */ 295 296 /* Method for the receiver side */ 297 void (*receive)(struct gsm_mux *gsm, u8 ch); 298 299 /* Link Layer */ 300 unsigned int mru; 301 unsigned int mtu; 302 int initiator; /* Did we initiate connection */ 303 bool dead; /* Has the mux been shut down */ 304 struct gsm_dlci *dlci[NUM_DLCI]; 305 int old_c_iflag; /* termios c_iflag value before attach */ 306 bool constipated; /* Asked by remote to shut up */ 307 bool has_devices; /* Devices were registered */ 308 309 spinlock_t tx_lock; 310 unsigned int tx_bytes; /* TX data outstanding */ 311 #define TX_THRESH_HI 8192 312 #define TX_THRESH_LO 2048 313 struct list_head tx_ctrl_list; /* Pending control packets */ 314 struct list_head tx_data_list; /* Pending data packets */ 315 316 /* Control messages */ 317 struct timer_list kick_timer; /* Kick TX queuing on timeout */ 318 struct timer_list t2_timer; /* Retransmit timer for commands */ 319 int cretries; /* Command retry counter */ 320 struct gsm_control *pending_cmd;/* Our current pending command */ 321 spinlock_t control_lock; /* Protects the pending command */ 322 323 /* Keep-alive */ 324 struct timer_list ka_timer; /* Keep-alive response timer */ 325 u8 ka_num; /* Keep-alive match pattern */ 326 signed int ka_retries; /* Keep-alive retry counter, -1 if not yet initialized */ 327 328 /* Configuration */ 329 int adaption; /* 1 or 2 supported */ 330 u8 ftype; /* UI or UIH */ 331 int t1, t2; /* Timers in 1/100th of a sec */ 332 unsigned int t3; /* Power wake-up timer in seconds. */ 333 int n2; /* Retry count */ 334 u8 k; /* Window size */ 335 bool wait_config; /* Wait for configuration by ioctl before DLCI open */ 336 u32 keep_alive; /* Control channel keep-alive in 10ms */ 337 338 /* Statistics (not currently exposed) */ 339 unsigned long bad_fcs; 340 unsigned long malformed; 341 unsigned long io_error; 342 unsigned long bad_size; 343 unsigned long unsupported; 344 }; 345 346 347 /* 348 * Mux objects - needed so that we can translate a tty index into the 349 * relevant mux and DLCI. 350 */ 351 352 #define MAX_MUX 4 /* 256 minors */ 353 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */ 354 static DEFINE_SPINLOCK(gsm_mux_lock); 355 356 static struct tty_driver *gsm_tty_driver; 357 358 /* 359 * This section of the driver logic implements the GSM encodings 360 * both the basic and the 'advanced'. Reliable transport is not 361 * supported. 362 */ 363 364 #define CR 0x02 365 #define EA 0x01 366 #define PF 0x10 367 368 /* I is special: the rest are ..*/ 369 #define RR 0x01 370 #define UI 0x03 371 #define RNR 0x05 372 #define REJ 0x09 373 #define DM 0x0F 374 #define SABM 0x2F 375 #define DISC 0x43 376 #define UA 0x63 377 #define UIH 0xEF 378 379 /* Channel commands */ 380 #define CMD_NSC 0x09 381 #define CMD_TEST 0x11 382 #define CMD_PSC 0x21 383 #define CMD_RLS 0x29 384 #define CMD_FCOFF 0x31 385 #define CMD_PN 0x41 386 #define CMD_RPN 0x49 387 #define CMD_FCON 0x51 388 #define CMD_CLD 0x61 389 #define CMD_SNC 0x69 390 #define CMD_MSC 0x71 391 392 /* Virtual modem bits */ 393 #define MDM_FC 0x01 394 #define MDM_RTC 0x02 395 #define MDM_RTR 0x04 396 #define MDM_IC 0x20 397 #define MDM_DV 0x40 398 399 #define GSM0_SOF 0xF9 400 #define GSM1_SOF 0x7E 401 #define GSM1_ESCAPE 0x7D 402 #define GSM1_ESCAPE_BITS 0x20 403 #define XON 0x11 404 #define XOFF 0x13 405 #define ISO_IEC_646_MASK 0x7F 406 407 static const struct tty_port_operations gsm_port_ops; 408 409 /* 410 * CRC table for GSM 0710 411 */ 412 413 static const u8 gsm_fcs8[256] = { 414 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75, 415 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B, 416 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69, 417 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67, 418 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D, 419 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43, 420 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51, 421 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F, 422 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05, 423 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B, 424 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19, 425 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17, 426 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D, 427 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33, 428 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21, 429 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F, 430 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95, 431 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B, 432 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89, 433 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87, 434 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD, 435 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3, 436 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1, 437 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF, 438 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5, 439 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB, 440 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9, 441 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7, 442 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD, 443 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3, 444 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1, 445 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF 446 }; 447 448 #define INIT_FCS 0xFF 449 #define GOOD_FCS 0xCF 450 451 static void gsm_dlci_close(struct gsm_dlci *dlci); 452 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len); 453 static int gsm_modem_update(struct gsm_dlci *dlci, u8 brk); 454 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len, 455 u8 ctrl); 456 static int gsm_send_packet(struct gsm_mux *gsm, struct gsm_msg *msg); 457 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr); 458 static void gsmld_write_trigger(struct gsm_mux *gsm); 459 static void gsmld_write_task(struct work_struct *work); 460 461 /** 462 * gsm_fcs_add - update FCS 463 * @fcs: Current FCS 464 * @c: Next data 465 * 466 * Update the FCS to include c. Uses the algorithm in the specification 467 * notes. 468 */ 469 470 static inline u8 gsm_fcs_add(u8 fcs, u8 c) 471 { 472 return gsm_fcs8[fcs ^ c]; 473 } 474 475 /** 476 * gsm_fcs_add_block - update FCS for a block 477 * @fcs: Current FCS 478 * @c: buffer of data 479 * @len: length of buffer 480 * 481 * Update the FCS to include c. Uses the algorithm in the specification 482 * notes. 483 */ 484 485 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len) 486 { 487 while (len--) 488 fcs = gsm_fcs8[fcs ^ *c++]; 489 return fcs; 490 } 491 492 /** 493 * gsm_read_ea - read a byte into an EA 494 * @val: variable holding value 495 * @c: byte going into the EA 496 * 497 * Processes one byte of an EA. Updates the passed variable 498 * and returns 1 if the EA is now completely read 499 */ 500 501 static int gsm_read_ea(unsigned int *val, u8 c) 502 { 503 /* Add the next 7 bits into the value */ 504 *val <<= 7; 505 *val |= c >> 1; 506 /* Was this the last byte of the EA 1 = yes*/ 507 return c & EA; 508 } 509 510 /** 511 * gsm_read_ea_val - read a value until EA 512 * @val: variable holding value 513 * @data: buffer of data 514 * @dlen: length of data 515 * 516 * Processes an EA value. Updates the passed variable and 517 * returns the processed data length. 518 */ 519 static unsigned int gsm_read_ea_val(unsigned int *val, const u8 *data, int dlen) 520 { 521 unsigned int len = 0; 522 523 for (; dlen > 0; dlen--) { 524 len++; 525 if (gsm_read_ea(val, *data++)) 526 break; 527 } 528 return len; 529 } 530 531 /** 532 * gsm_encode_modem - encode modem data bits 533 * @dlci: DLCI to encode from 534 * 535 * Returns the correct GSM encoded modem status bits (6 bit field) for 536 * the current status of the DLCI and attached tty object 537 */ 538 539 static u8 gsm_encode_modem(const struct gsm_dlci *dlci) 540 { 541 u8 modembits = 0; 542 /* FC is true flow control not modem bits */ 543 if (dlci->throttled) 544 modembits |= MDM_FC; 545 if (dlci->modem_tx & TIOCM_DTR) 546 modembits |= MDM_RTC; 547 if (dlci->modem_tx & TIOCM_RTS) 548 modembits |= MDM_RTR; 549 if (dlci->modem_tx & TIOCM_RI) 550 modembits |= MDM_IC; 551 if (dlci->modem_tx & TIOCM_CD || dlci->gsm->initiator) 552 modembits |= MDM_DV; 553 /* special mappings for passive side to operate as UE */ 554 if (dlci->modem_tx & TIOCM_OUT1) 555 modembits |= MDM_IC; 556 if (dlci->modem_tx & TIOCM_OUT2) 557 modembits |= MDM_DV; 558 return modembits; 559 } 560 561 static void gsm_hex_dump_bytes(const char *fname, const u8 *data, 562 unsigned long len) 563 { 564 char *prefix; 565 566 if (!fname) { 567 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, data, len, 568 true); 569 return; 570 } 571 572 prefix = kasprintf(GFP_ATOMIC, "%s: ", fname); 573 if (!prefix) 574 return; 575 print_hex_dump(KERN_INFO, prefix, DUMP_PREFIX_OFFSET, 16, 1, data, len, 576 true); 577 kfree(prefix); 578 } 579 580 /** 581 * gsm_encode_params - encode DLCI parameters 582 * @dlci: DLCI to encode from 583 * @params: buffer to fill with the encoded parameters 584 * 585 * Encodes the parameters according to GSM 07.10 section 5.4.6.3.1 586 * table 3. 587 */ 588 static int gsm_encode_params(const struct gsm_dlci *dlci, 589 struct gsm_dlci_param_bits *params) 590 { 591 const struct gsm_mux *gsm = dlci->gsm; 592 unsigned int i, cl; 593 594 switch (dlci->ftype) { 595 case UIH: 596 i = 0; /* UIH */ 597 break; 598 case UI: 599 i = 1; /* UI */ 600 break; 601 default: 602 pr_debug("unsupported frame type %d\n", dlci->ftype); 603 return -EINVAL; 604 } 605 606 switch (dlci->adaption) { 607 case 1: /* Unstructured */ 608 cl = 0; /* convergence layer type 1 */ 609 break; 610 case 2: /* Unstructured with modem bits. */ 611 cl = 1; /* convergence layer type 2 */ 612 break; 613 default: 614 pr_debug("unsupported adaption %d\n", dlci->adaption); 615 return -EINVAL; 616 } 617 618 params->d_bits = FIELD_PREP(PN_D_FIELD_DLCI, dlci->addr); 619 /* UIH, convergence layer type 1 */ 620 params->i_cl_bits = FIELD_PREP(PN_I_CL_FIELD_FTYPE, i) | 621 FIELD_PREP(PN_I_CL_FIELD_ADAPTION, cl); 622 params->p_bits = FIELD_PREP(PN_P_FIELD_PRIO, dlci->prio); 623 params->t_bits = FIELD_PREP(PN_T_FIELD_T1, gsm->t1); 624 params->n_bits = cpu_to_le16(FIELD_PREP(PN_N_FIELD_N1, dlci->mtu)); 625 params->na_bits = FIELD_PREP(PN_NA_FIELD_N2, gsm->n2); 626 params->k_bits = FIELD_PREP(PN_K_FIELD_K, dlci->k); 627 628 return 0; 629 } 630 631 /** 632 * gsm_register_devices - register all tty devices for a given mux index 633 * 634 * @driver: the tty driver that describes the tty devices 635 * @index: the mux number is used to calculate the minor numbers of the 636 * ttys for this mux and may differ from the position in the 637 * mux array. 638 */ 639 static int gsm_register_devices(struct tty_driver *driver, unsigned int index) 640 { 641 struct device *dev; 642 int i; 643 unsigned int base; 644 645 if (!driver || index >= MAX_MUX) 646 return -EINVAL; 647 648 base = index * NUM_DLCI; /* first minor for this index */ 649 for (i = 1; i < NUM_DLCI; i++) { 650 /* Don't register device 0 - this is the control channel 651 * and not a usable tty interface 652 */ 653 dev = tty_register_device(gsm_tty_driver, base + i, NULL); 654 if (IS_ERR(dev)) { 655 if (debug & DBG_ERRORS) 656 pr_info("%s failed to register device minor %u", 657 __func__, base + i); 658 for (i--; i >= 1; i--) 659 tty_unregister_device(gsm_tty_driver, base + i); 660 return PTR_ERR(dev); 661 } 662 } 663 664 return 0; 665 } 666 667 /** 668 * gsm_unregister_devices - unregister all tty devices for a given mux index 669 * 670 * @driver: the tty driver that describes the tty devices 671 * @index: the mux number is used to calculate the minor numbers of the 672 * ttys for this mux and may differ from the position in the 673 * mux array. 674 */ 675 static void gsm_unregister_devices(struct tty_driver *driver, 676 unsigned int index) 677 { 678 int i; 679 unsigned int base; 680 681 if (!driver || index >= MAX_MUX) 682 return; 683 684 base = index * NUM_DLCI; /* first minor for this index */ 685 for (i = 1; i < NUM_DLCI; i++) { 686 /* Don't unregister device 0 - this is the control 687 * channel and not a usable tty interface 688 */ 689 tty_unregister_device(gsm_tty_driver, base + i); 690 } 691 } 692 693 /** 694 * gsm_print_packet - display a frame for debug 695 * @hdr: header to print before decode 696 * @addr: address EA from the frame 697 * @cr: C/R bit seen as initiator 698 * @control: control including PF bit 699 * @data: following data bytes 700 * @dlen: length of data 701 * 702 * Displays a packet in human readable format for debugging purposes. The 703 * style is based on amateur radio LAP-B dump display. 704 */ 705 706 static void gsm_print_packet(const char *hdr, int addr, int cr, 707 u8 control, const u8 *data, int dlen) 708 { 709 if (!(debug & DBG_DUMP)) 710 return; 711 /* Only show user payload frames if debug & DBG_PAYLOAD */ 712 if (!(debug & DBG_PAYLOAD) && addr != 0) 713 if ((control & ~PF) == UI || (control & ~PF) == UIH) 714 return; 715 716 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]); 717 718 switch (control & ~PF) { 719 case SABM: 720 pr_cont("SABM"); 721 break; 722 case UA: 723 pr_cont("UA"); 724 break; 725 case DISC: 726 pr_cont("DISC"); 727 break; 728 case DM: 729 pr_cont("DM"); 730 break; 731 case UI: 732 pr_cont("UI"); 733 break; 734 case UIH: 735 pr_cont("UIH"); 736 break; 737 default: 738 if (!(control & 0x01)) { 739 pr_cont("I N(S)%d N(R)%d", 740 (control & 0x0E) >> 1, (control & 0xE0) >> 5); 741 } else switch (control & 0x0F) { 742 case RR: 743 pr_cont("RR(%d)", (control & 0xE0) >> 5); 744 break; 745 case RNR: 746 pr_cont("RNR(%d)", (control & 0xE0) >> 5); 747 break; 748 case REJ: 749 pr_cont("REJ(%d)", (control & 0xE0) >> 5); 750 break; 751 default: 752 pr_cont("[%02X]", control); 753 } 754 } 755 756 if (control & PF) 757 pr_cont("(P)"); 758 else 759 pr_cont("(F)"); 760 761 gsm_hex_dump_bytes(NULL, data, dlen); 762 } 763 764 765 /* 766 * Link level transmission side 767 */ 768 769 /** 770 * gsm_stuff_frame - bytestuff a packet 771 * @input: input buffer 772 * @output: output buffer 773 * @len: length of input 774 * 775 * Expand a buffer by bytestuffing it. The worst case size change 776 * is doubling and the caller is responsible for handing out 777 * suitable sized buffers. 778 */ 779 780 static int gsm_stuff_frame(const u8 *input, u8 *output, int len) 781 { 782 int olen = 0; 783 while (len--) { 784 if (*input == GSM1_SOF || *input == GSM1_ESCAPE 785 || (*input & ISO_IEC_646_MASK) == XON 786 || (*input & ISO_IEC_646_MASK) == XOFF) { 787 *output++ = GSM1_ESCAPE; 788 *output++ = *input++ ^ GSM1_ESCAPE_BITS; 789 olen++; 790 } else 791 *output++ = *input++; 792 olen++; 793 } 794 return olen; 795 } 796 797 /** 798 * gsm_send - send a control frame 799 * @gsm: our GSM mux 800 * @addr: address for control frame 801 * @cr: command/response bit seen as initiator 802 * @control: control byte including PF bit 803 * 804 * Format up and transmit a control frame. These should be transmitted 805 * ahead of data when they are needed. 806 */ 807 static int gsm_send(struct gsm_mux *gsm, int addr, int cr, int control) 808 { 809 struct gsm_msg *msg; 810 u8 *dp; 811 int ocr; 812 unsigned long flags; 813 814 msg = gsm_data_alloc(gsm, addr, 0, control); 815 if (!msg) 816 return -ENOMEM; 817 818 /* toggle C/R coding if not initiator */ 819 ocr = cr ^ (gsm->initiator ? 0 : 1); 820 821 msg->data -= 3; 822 dp = msg->data; 823 *dp++ = (addr << 2) | (ocr << 1) | EA; 824 *dp++ = control; 825 826 if (gsm->encoding == GSM_BASIC_OPT) 827 *dp++ = EA; /* Length of data = 0 */ 828 829 *dp = 0xFF - gsm_fcs_add_block(INIT_FCS, msg->data, dp - msg->data); 830 msg->len = (dp - msg->data) + 1; 831 832 gsm_print_packet("Q->", addr, cr, control, NULL, 0); 833 834 spin_lock_irqsave(&gsm->tx_lock, flags); 835 list_add_tail(&msg->list, &gsm->tx_ctrl_list); 836 gsm->tx_bytes += msg->len; 837 spin_unlock_irqrestore(&gsm->tx_lock, flags); 838 gsmld_write_trigger(gsm); 839 840 return 0; 841 } 842 843 /** 844 * gsm_dlci_clear_queues - remove outstanding data for a DLCI 845 * @gsm: mux 846 * @dlci: clear for this DLCI 847 * 848 * Clears the data queues for a given DLCI. 849 */ 850 static void gsm_dlci_clear_queues(struct gsm_mux *gsm, struct gsm_dlci *dlci) 851 { 852 struct gsm_msg *msg, *nmsg; 853 int addr = dlci->addr; 854 unsigned long flags; 855 856 /* Clear DLCI write fifo first */ 857 spin_lock_irqsave(&dlci->lock, flags); 858 kfifo_reset(&dlci->fifo); 859 spin_unlock_irqrestore(&dlci->lock, flags); 860 861 /* Clear data packets in MUX write queue */ 862 spin_lock_irqsave(&gsm->tx_lock, flags); 863 list_for_each_entry_safe(msg, nmsg, &gsm->tx_data_list, list) { 864 if (msg->addr != addr) 865 continue; 866 gsm->tx_bytes -= msg->len; 867 list_del(&msg->list); 868 kfree(msg); 869 } 870 spin_unlock_irqrestore(&gsm->tx_lock, flags); 871 } 872 873 /** 874 * gsm_response - send a control response 875 * @gsm: our GSM mux 876 * @addr: address for control frame 877 * @control: control byte including PF bit 878 * 879 * Format up and transmit a link level response frame. 880 */ 881 882 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control) 883 { 884 gsm_send(gsm, addr, 0, control); 885 } 886 887 /** 888 * gsm_command - send a control command 889 * @gsm: our GSM mux 890 * @addr: address for control frame 891 * @control: control byte including PF bit 892 * 893 * Format up and transmit a link level command frame. 894 */ 895 896 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control) 897 { 898 gsm_send(gsm, addr, 1, control); 899 } 900 901 /* Data transmission */ 902 903 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */ 904 905 /** 906 * gsm_data_alloc - allocate data frame 907 * @gsm: GSM mux 908 * @addr: DLCI address 909 * @len: length excluding header and FCS 910 * @ctrl: control byte 911 * 912 * Allocate a new data buffer for sending frames with data. Space is left 913 * at the front for header bytes but that is treated as an implementation 914 * detail and not for the high level code to use 915 */ 916 917 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len, 918 u8 ctrl) 919 { 920 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN, 921 GFP_ATOMIC); 922 if (m == NULL) 923 return NULL; 924 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */ 925 m->len = len; 926 m->addr = addr; 927 m->ctrl = ctrl; 928 INIT_LIST_HEAD(&m->list); 929 return m; 930 } 931 932 /** 933 * gsm_send_packet - sends a single packet 934 * @gsm: GSM Mux 935 * @msg: packet to send 936 * 937 * The given packet is encoded and sent out. No memory is freed. 938 * The caller must hold the gsm tx lock. 939 */ 940 static int gsm_send_packet(struct gsm_mux *gsm, struct gsm_msg *msg) 941 { 942 int len, ret; 943 944 945 if (gsm->encoding == GSM_BASIC_OPT) { 946 gsm->txframe[0] = GSM0_SOF; 947 memcpy(gsm->txframe + 1, msg->data, msg->len); 948 gsm->txframe[msg->len + 1] = GSM0_SOF; 949 len = msg->len + 2; 950 } else { 951 gsm->txframe[0] = GSM1_SOF; 952 len = gsm_stuff_frame(msg->data, gsm->txframe + 1, msg->len); 953 gsm->txframe[len + 1] = GSM1_SOF; 954 len += 2; 955 } 956 957 if (debug & DBG_DATA) 958 gsm_hex_dump_bytes(__func__, gsm->txframe, len); 959 gsm_print_packet("-->", msg->addr, gsm->initiator, msg->ctrl, msg->data, 960 msg->len); 961 962 ret = gsmld_output(gsm, gsm->txframe, len); 963 if (ret <= 0) 964 return ret; 965 /* FIXME: Can eliminate one SOF in many more cases */ 966 gsm->tx_bytes -= msg->len; 967 968 return 0; 969 } 970 971 /** 972 * gsm_is_flow_ctrl_msg - checks if flow control message 973 * @msg: message to check 974 * 975 * Returns true if the given message is a flow control command of the 976 * control channel. False is returned in any other case. 977 */ 978 static bool gsm_is_flow_ctrl_msg(struct gsm_msg *msg) 979 { 980 unsigned int cmd; 981 982 if (msg->addr > 0) 983 return false; 984 985 switch (msg->ctrl & ~PF) { 986 case UI: 987 case UIH: 988 cmd = 0; 989 if (gsm_read_ea_val(&cmd, msg->data + 2, msg->len - 2) < 1) 990 break; 991 switch (cmd & ~PF) { 992 case CMD_FCOFF: 993 case CMD_FCON: 994 return true; 995 } 996 break; 997 } 998 999 return false; 1000 } 1001 1002 /** 1003 * gsm_data_kick - poke the queue 1004 * @gsm: GSM Mux 1005 * 1006 * The tty device has called us to indicate that room has appeared in 1007 * the transmit queue. Ram more data into the pipe if we have any. 1008 * If we have been flow-stopped by a CMD_FCOFF, then we can only 1009 * send messages on DLCI0 until CMD_FCON. The caller must hold 1010 * the gsm tx lock. 1011 */ 1012 static int gsm_data_kick(struct gsm_mux *gsm) 1013 { 1014 struct gsm_msg *msg, *nmsg; 1015 struct gsm_dlci *dlci; 1016 int ret; 1017 1018 clear_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags); 1019 1020 /* Serialize control messages and control channel messages first */ 1021 list_for_each_entry_safe(msg, nmsg, &gsm->tx_ctrl_list, list) { 1022 if (gsm->constipated && !gsm_is_flow_ctrl_msg(msg)) 1023 continue; 1024 ret = gsm_send_packet(gsm, msg); 1025 switch (ret) { 1026 case -ENOSPC: 1027 return -ENOSPC; 1028 case -ENODEV: 1029 /* ldisc not open */ 1030 gsm->tx_bytes -= msg->len; 1031 list_del(&msg->list); 1032 kfree(msg); 1033 continue; 1034 default: 1035 if (ret >= 0) { 1036 list_del(&msg->list); 1037 kfree(msg); 1038 } 1039 break; 1040 } 1041 } 1042 1043 if (gsm->constipated) 1044 return -EAGAIN; 1045 1046 /* Serialize other channels */ 1047 if (list_empty(&gsm->tx_data_list)) 1048 return 0; 1049 list_for_each_entry_safe(msg, nmsg, &gsm->tx_data_list, list) { 1050 dlci = gsm->dlci[msg->addr]; 1051 /* Send only messages for DLCIs with valid state */ 1052 if (dlci->state != DLCI_OPEN) { 1053 gsm->tx_bytes -= msg->len; 1054 list_del(&msg->list); 1055 kfree(msg); 1056 continue; 1057 } 1058 ret = gsm_send_packet(gsm, msg); 1059 switch (ret) { 1060 case -ENOSPC: 1061 return -ENOSPC; 1062 case -ENODEV: 1063 /* ldisc not open */ 1064 gsm->tx_bytes -= msg->len; 1065 list_del(&msg->list); 1066 kfree(msg); 1067 continue; 1068 default: 1069 if (ret >= 0) { 1070 list_del(&msg->list); 1071 kfree(msg); 1072 } 1073 break; 1074 } 1075 } 1076 1077 return 1; 1078 } 1079 1080 /** 1081 * __gsm_data_queue - queue a UI or UIH frame 1082 * @dlci: DLCI sending the data 1083 * @msg: message queued 1084 * 1085 * Add data to the transmit queue and try and get stuff moving 1086 * out of the mux tty if not already doing so. The Caller must hold 1087 * the gsm tx lock. 1088 */ 1089 1090 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg) 1091 { 1092 struct gsm_mux *gsm = dlci->gsm; 1093 u8 *dp = msg->data; 1094 u8 *fcs = dp + msg->len; 1095 1096 /* Fill in the header */ 1097 if (gsm->encoding == GSM_BASIC_OPT) { 1098 if (msg->len < 128) 1099 *--dp = (msg->len << 1) | EA; 1100 else { 1101 *--dp = (msg->len >> 7); /* bits 7 - 15 */ 1102 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */ 1103 } 1104 } 1105 1106 *--dp = msg->ctrl; 1107 if (gsm->initiator) 1108 *--dp = (msg->addr << 2) | CR | EA; 1109 else 1110 *--dp = (msg->addr << 2) | EA; 1111 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp); 1112 /* Ugly protocol layering violation */ 1113 if (msg->ctrl == UI || msg->ctrl == (UI|PF)) 1114 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len); 1115 *fcs = 0xFF - *fcs; 1116 1117 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl, 1118 msg->data, msg->len); 1119 1120 /* Move the header back and adjust the length, also allow for the FCS 1121 now tacked on the end */ 1122 msg->len += (msg->data - dp) + 1; 1123 msg->data = dp; 1124 1125 /* Add to the actual output queue */ 1126 switch (msg->ctrl & ~PF) { 1127 case UI: 1128 case UIH: 1129 if (msg->addr > 0) { 1130 list_add_tail(&msg->list, &gsm->tx_data_list); 1131 break; 1132 } 1133 fallthrough; 1134 default: 1135 list_add_tail(&msg->list, &gsm->tx_ctrl_list); 1136 break; 1137 } 1138 gsm->tx_bytes += msg->len; 1139 1140 gsmld_write_trigger(gsm); 1141 mod_timer(&gsm->kick_timer, jiffies + 10 * gsm->t1 * HZ / 100); 1142 } 1143 1144 /** 1145 * gsm_data_queue - queue a UI or UIH frame 1146 * @dlci: DLCI sending the data 1147 * @msg: message queued 1148 * 1149 * Add data to the transmit queue and try and get stuff moving 1150 * out of the mux tty if not already doing so. Take the 1151 * the gsm tx lock and dlci lock. 1152 */ 1153 1154 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg) 1155 { 1156 unsigned long flags; 1157 spin_lock_irqsave(&dlci->gsm->tx_lock, flags); 1158 __gsm_data_queue(dlci, msg); 1159 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags); 1160 } 1161 1162 /** 1163 * gsm_dlci_data_output - try and push data out of a DLCI 1164 * @gsm: mux 1165 * @dlci: the DLCI to pull data from 1166 * 1167 * Pull data from a DLCI and send it into the transmit queue if there 1168 * is data. Keep to the MRU of the mux. This path handles the usual tty 1169 * interface which is a byte stream with optional modem data. 1170 * 1171 * Caller must hold the tx_lock of the mux. 1172 */ 1173 1174 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci) 1175 { 1176 struct gsm_msg *msg; 1177 u8 *dp; 1178 int h, len, size; 1179 1180 /* for modem bits without break data */ 1181 h = ((dlci->adaption == 1) ? 0 : 1); 1182 1183 len = kfifo_len(&dlci->fifo); 1184 if (len == 0) 1185 return 0; 1186 1187 /* MTU/MRU count only the data bits but watch adaption mode */ 1188 if ((len + h) > dlci->mtu) 1189 len = dlci->mtu - h; 1190 1191 size = len + h; 1192 1193 msg = gsm_data_alloc(gsm, dlci->addr, size, dlci->ftype); 1194 if (!msg) 1195 return -ENOMEM; 1196 dp = msg->data; 1197 switch (dlci->adaption) { 1198 case 1: /* Unstructured */ 1199 break; 1200 case 2: /* Unstructured with modem bits. 1201 * Always one byte as we never send inline break data 1202 */ 1203 *dp++ = (gsm_encode_modem(dlci) << 1) | EA; 1204 break; 1205 default: 1206 pr_err("%s: unsupported adaption %d\n", __func__, 1207 dlci->adaption); 1208 break; 1209 } 1210 1211 WARN_ON(len != kfifo_out_locked(&dlci->fifo, dp, len, 1212 &dlci->lock)); 1213 1214 /* Notify upper layer about available send space. */ 1215 tty_port_tty_wakeup(&dlci->port); 1216 1217 __gsm_data_queue(dlci, msg); 1218 /* Bytes of data we used up */ 1219 return size; 1220 } 1221 1222 /** 1223 * gsm_dlci_data_output_framed - try and push data out of a DLCI 1224 * @gsm: mux 1225 * @dlci: the DLCI to pull data from 1226 * 1227 * Pull data from a DLCI and send it into the transmit queue if there 1228 * is data. Keep to the MRU of the mux. This path handles framed data 1229 * queued as skbuffs to the DLCI. 1230 * 1231 * Caller must hold the tx_lock of the mux. 1232 */ 1233 1234 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm, 1235 struct gsm_dlci *dlci) 1236 { 1237 struct gsm_msg *msg; 1238 u8 *dp; 1239 int len, size; 1240 int last = 0, first = 0; 1241 int overhead = 0; 1242 1243 /* One byte per frame is used for B/F flags */ 1244 if (dlci->adaption == 4) 1245 overhead = 1; 1246 1247 /* dlci->skb is locked by tx_lock */ 1248 if (dlci->skb == NULL) { 1249 dlci->skb = skb_dequeue_tail(&dlci->skb_list); 1250 if (dlci->skb == NULL) 1251 return 0; 1252 first = 1; 1253 } 1254 len = dlci->skb->len + overhead; 1255 1256 /* MTU/MRU count only the data bits */ 1257 if (len > dlci->mtu) { 1258 if (dlci->adaption == 3) { 1259 /* Over long frame, bin it */ 1260 dev_kfree_skb_any(dlci->skb); 1261 dlci->skb = NULL; 1262 return 0; 1263 } 1264 len = dlci->mtu; 1265 } else 1266 last = 1; 1267 1268 size = len + overhead; 1269 msg = gsm_data_alloc(gsm, dlci->addr, size, dlci->ftype); 1270 if (msg == NULL) { 1271 skb_queue_tail(&dlci->skb_list, dlci->skb); 1272 dlci->skb = NULL; 1273 return -ENOMEM; 1274 } 1275 dp = msg->data; 1276 1277 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */ 1278 /* Flag byte to carry the start/end info */ 1279 *dp++ = last << 7 | first << 6 | 1; /* EA */ 1280 len--; 1281 } 1282 memcpy(dp, dlci->skb->data, len); 1283 skb_pull(dlci->skb, len); 1284 __gsm_data_queue(dlci, msg); 1285 if (last) { 1286 dev_kfree_skb_any(dlci->skb); 1287 dlci->skb = NULL; 1288 } 1289 return size; 1290 } 1291 1292 /** 1293 * gsm_dlci_modem_output - try and push modem status out of a DLCI 1294 * @gsm: mux 1295 * @dlci: the DLCI to pull modem status from 1296 * @brk: break signal 1297 * 1298 * Push an empty frame in to the transmit queue to update the modem status 1299 * bits and to transmit an optional break. 1300 * 1301 * Caller must hold the tx_lock of the mux. 1302 */ 1303 1304 static int gsm_dlci_modem_output(struct gsm_mux *gsm, struct gsm_dlci *dlci, 1305 u8 brk) 1306 { 1307 u8 *dp = NULL; 1308 struct gsm_msg *msg; 1309 int size = 0; 1310 1311 /* for modem bits without break data */ 1312 switch (dlci->adaption) { 1313 case 1: /* Unstructured */ 1314 break; 1315 case 2: /* Unstructured with modem bits. */ 1316 size++; 1317 if (brk > 0) 1318 size++; 1319 break; 1320 default: 1321 pr_err("%s: unsupported adaption %d\n", __func__, 1322 dlci->adaption); 1323 return -EINVAL; 1324 } 1325 1326 msg = gsm_data_alloc(gsm, dlci->addr, size, dlci->ftype); 1327 if (!msg) { 1328 pr_err("%s: gsm_data_alloc error", __func__); 1329 return -ENOMEM; 1330 } 1331 dp = msg->data; 1332 switch (dlci->adaption) { 1333 case 1: /* Unstructured */ 1334 break; 1335 case 2: /* Unstructured with modem bits. */ 1336 if (brk == 0) { 1337 *dp++ = (gsm_encode_modem(dlci) << 1) | EA; 1338 } else { 1339 *dp++ = gsm_encode_modem(dlci) << 1; 1340 *dp++ = (brk << 4) | 2 | EA; /* Length, Break, EA */ 1341 } 1342 break; 1343 default: 1344 /* Handled above */ 1345 break; 1346 } 1347 1348 __gsm_data_queue(dlci, msg); 1349 return size; 1350 } 1351 1352 /** 1353 * gsm_dlci_data_sweep - look for data to send 1354 * @gsm: the GSM mux 1355 * 1356 * Sweep the GSM mux channels in priority order looking for ones with 1357 * data to send. We could do with optimising this scan a bit. We aim 1358 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit 1359 * TX_THRESH_LO we get called again 1360 * 1361 * FIXME: We should round robin between groups and in theory you can 1362 * renegotiate DLCI priorities with optional stuff. Needs optimising. 1363 */ 1364 1365 static int gsm_dlci_data_sweep(struct gsm_mux *gsm) 1366 { 1367 /* Priority ordering: We should do priority with RR of the groups */ 1368 int i, len, ret = 0; 1369 bool sent; 1370 struct gsm_dlci *dlci; 1371 1372 while (gsm->tx_bytes < TX_THRESH_HI) { 1373 for (sent = false, i = 1; i < NUM_DLCI; i++) { 1374 dlci = gsm->dlci[i]; 1375 /* skip unused or blocked channel */ 1376 if (!dlci || dlci->constipated) 1377 continue; 1378 /* skip channels with invalid state */ 1379 if (dlci->state != DLCI_OPEN) 1380 continue; 1381 /* count the sent data per adaption */ 1382 if (dlci->adaption < 3 && !dlci->net) 1383 len = gsm_dlci_data_output(gsm, dlci); 1384 else 1385 len = gsm_dlci_data_output_framed(gsm, dlci); 1386 /* on error exit */ 1387 if (len < 0) 1388 return ret; 1389 if (len > 0) { 1390 ret++; 1391 sent = true; 1392 /* The lower DLCs can starve the higher DLCs! */ 1393 break; 1394 } 1395 /* try next */ 1396 } 1397 if (!sent) 1398 break; 1399 } 1400 1401 return ret; 1402 } 1403 1404 /** 1405 * gsm_dlci_data_kick - transmit if possible 1406 * @dlci: DLCI to kick 1407 * 1408 * Transmit data from this DLCI if the queue is empty. We can't rely on 1409 * a tty wakeup except when we filled the pipe so we need to fire off 1410 * new data ourselves in other cases. 1411 */ 1412 1413 static void gsm_dlci_data_kick(struct gsm_dlci *dlci) 1414 { 1415 unsigned long flags; 1416 int sweep; 1417 1418 if (dlci->constipated) 1419 return; 1420 1421 spin_lock_irqsave(&dlci->gsm->tx_lock, flags); 1422 /* If we have nothing running then we need to fire up */ 1423 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO); 1424 if (dlci->gsm->tx_bytes == 0) { 1425 if (dlci->net) 1426 gsm_dlci_data_output_framed(dlci->gsm, dlci); 1427 else 1428 gsm_dlci_data_output(dlci->gsm, dlci); 1429 } 1430 if (sweep) 1431 gsm_dlci_data_sweep(dlci->gsm); 1432 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags); 1433 } 1434 1435 /* 1436 * Control message processing 1437 */ 1438 1439 1440 /** 1441 * gsm_control_command - send a command frame to a control 1442 * @gsm: gsm channel 1443 * @cmd: the command to use 1444 * @data: data to follow encoded info 1445 * @dlen: length of data 1446 * 1447 * Encode up and queue a UI/UIH frame containing our command. 1448 */ 1449 static int gsm_control_command(struct gsm_mux *gsm, int cmd, const u8 *data, 1450 int dlen) 1451 { 1452 struct gsm_msg *msg; 1453 1454 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->dlci[0]->ftype); 1455 if (msg == NULL) 1456 return -ENOMEM; 1457 1458 msg->data[0] = (cmd << 1) | CR | EA; /* Set C/R */ 1459 msg->data[1] = (dlen << 1) | EA; 1460 memcpy(msg->data + 2, data, dlen); 1461 gsm_data_queue(gsm->dlci[0], msg); 1462 1463 return 0; 1464 } 1465 1466 /** 1467 * gsm_control_reply - send a response frame to a control 1468 * @gsm: gsm channel 1469 * @cmd: the command to use 1470 * @data: data to follow encoded info 1471 * @dlen: length of data 1472 * 1473 * Encode up and queue a UI/UIH frame containing our response. 1474 */ 1475 1476 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, const u8 *data, 1477 int dlen) 1478 { 1479 struct gsm_msg *msg; 1480 1481 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->dlci[0]->ftype); 1482 if (msg == NULL) 1483 return; 1484 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */ 1485 msg->data[1] = (dlen << 1) | EA; 1486 memcpy(msg->data + 2, data, dlen); 1487 gsm_data_queue(gsm->dlci[0], msg); 1488 } 1489 1490 /** 1491 * gsm_process_modem - process received modem status 1492 * @tty: virtual tty bound to the DLCI 1493 * @dlci: DLCI to affect 1494 * @modem: modem bits (full EA) 1495 * @slen: number of signal octets 1496 * 1497 * Used when a modem control message or line state inline in adaption 1498 * layer 2 is processed. Sort out the local modem state and throttles 1499 */ 1500 1501 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci, 1502 u32 modem, int slen) 1503 { 1504 int mlines = 0; 1505 u8 brk = 0; 1506 int fc; 1507 1508 /* The modem status command can either contain one octet (V.24 signals) 1509 * or two octets (V.24 signals + break signals). This is specified in 1510 * section 5.4.6.3.7 of the 07.10 mux spec. 1511 */ 1512 1513 if (slen == 1) 1514 modem = modem & 0x7f; 1515 else { 1516 brk = modem & 0x7f; 1517 modem = (modem >> 7) & 0x7f; 1518 } 1519 1520 /* Flow control/ready to communicate */ 1521 fc = (modem & MDM_FC) || !(modem & MDM_RTR); 1522 if (fc && !dlci->constipated) { 1523 /* Need to throttle our output on this device */ 1524 dlci->constipated = true; 1525 } else if (!fc && dlci->constipated) { 1526 dlci->constipated = false; 1527 gsm_dlci_data_kick(dlci); 1528 } 1529 1530 /* Map modem bits */ 1531 if (modem & MDM_RTC) 1532 mlines |= TIOCM_DSR | TIOCM_DTR; 1533 if (modem & MDM_RTR) 1534 mlines |= TIOCM_RTS | TIOCM_CTS; 1535 if (modem & MDM_IC) 1536 mlines |= TIOCM_RI; 1537 if (modem & MDM_DV) 1538 mlines |= TIOCM_CD; 1539 1540 /* Carrier drop -> hangup */ 1541 if (tty) { 1542 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD)) 1543 if (!C_CLOCAL(tty)) 1544 tty_hangup(tty); 1545 } 1546 if (brk & 0x01) 1547 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK); 1548 dlci->modem_rx = mlines; 1549 wake_up_interruptible(&dlci->gsm->event); 1550 } 1551 1552 /** 1553 * gsm_process_negotiation - process received parameters 1554 * @gsm: GSM channel 1555 * @addr: DLCI address 1556 * @cr: command/response 1557 * @params: encoded parameters from the parameter negotiation message 1558 * 1559 * Used when the response for our parameter negotiation command was 1560 * received. 1561 */ 1562 static int gsm_process_negotiation(struct gsm_mux *gsm, unsigned int addr, 1563 unsigned int cr, 1564 const struct gsm_dlci_param_bits *params) 1565 { 1566 struct gsm_dlci *dlci = gsm->dlci[addr]; 1567 unsigned int ftype, i, adaption, prio, n1, k; 1568 1569 i = FIELD_GET(PN_I_CL_FIELD_FTYPE, params->i_cl_bits); 1570 adaption = FIELD_GET(PN_I_CL_FIELD_ADAPTION, params->i_cl_bits) + 1; 1571 prio = FIELD_GET(PN_P_FIELD_PRIO, params->p_bits); 1572 n1 = FIELD_GET(PN_N_FIELD_N1, get_unaligned_le16(¶ms->n_bits)); 1573 k = FIELD_GET(PN_K_FIELD_K, params->k_bits); 1574 1575 if (n1 < MIN_MTU) { 1576 if (debug & DBG_ERRORS) 1577 pr_info("%s N1 out of range in PN\n", __func__); 1578 return -EINVAL; 1579 } 1580 1581 switch (i) { 1582 case 0x00: 1583 ftype = UIH; 1584 break; 1585 case 0x01: 1586 ftype = UI; 1587 break; 1588 case 0x02: /* I frames are not supported */ 1589 if (debug & DBG_ERRORS) 1590 pr_info("%s unsupported I frame request in PN\n", 1591 __func__); 1592 return -EINVAL; 1593 default: 1594 if (debug & DBG_ERRORS) 1595 pr_info("%s i out of range in PN\n", __func__); 1596 return -EINVAL; 1597 } 1598 1599 if (!cr && gsm->initiator) { 1600 if (adaption != dlci->adaption) { 1601 if (debug & DBG_ERRORS) 1602 pr_info("%s invalid adaption %d in PN\n", 1603 __func__, adaption); 1604 return -EINVAL; 1605 } 1606 if (prio != dlci->prio) { 1607 if (debug & DBG_ERRORS) 1608 pr_info("%s invalid priority %d in PN", 1609 __func__, prio); 1610 return -EINVAL; 1611 } 1612 if (n1 > gsm->mru || n1 > dlci->mtu) { 1613 /* We requested a frame size but the other party wants 1614 * to send larger frames. The standard allows only a 1615 * smaller response value than requested (5.4.6.3.1). 1616 */ 1617 if (debug & DBG_ERRORS) 1618 pr_info("%s invalid N1 %d in PN\n", __func__, 1619 n1); 1620 return -EINVAL; 1621 } 1622 dlci->mtu = n1; 1623 if (ftype != dlci->ftype) { 1624 if (debug & DBG_ERRORS) 1625 pr_info("%s invalid i %d in PN\n", __func__, i); 1626 return -EINVAL; 1627 } 1628 if (ftype != UI && ftype != UIH && k > dlci->k) { 1629 if (debug & DBG_ERRORS) 1630 pr_info("%s invalid k %d in PN\n", __func__, k); 1631 return -EINVAL; 1632 } 1633 dlci->k = k; 1634 } else if (cr && !gsm->initiator) { 1635 /* Only convergence layer type 1 and 2 are supported. */ 1636 if (adaption != 1 && adaption != 2) { 1637 if (debug & DBG_ERRORS) 1638 pr_info("%s invalid adaption %d in PN\n", 1639 __func__, adaption); 1640 return -EINVAL; 1641 } 1642 dlci->adaption = adaption; 1643 if (n1 > gsm->mru) { 1644 /* Propose a smaller value */ 1645 dlci->mtu = gsm->mru; 1646 } else if (n1 > MAX_MTU) { 1647 /* Propose a smaller value */ 1648 dlci->mtu = MAX_MTU; 1649 } else { 1650 dlci->mtu = n1; 1651 } 1652 dlci->prio = prio; 1653 dlci->ftype = ftype; 1654 dlci->k = k; 1655 } else { 1656 return -EINVAL; 1657 } 1658 1659 return 0; 1660 } 1661 1662 /** 1663 * gsm_control_modem - modem status received 1664 * @gsm: GSM channel 1665 * @data: data following command 1666 * @clen: command length 1667 * 1668 * We have received a modem status control message. This is used by 1669 * the GSM mux protocol to pass virtual modem line status and optionally 1670 * to indicate break signals. Unpack it, convert to Linux representation 1671 * and if need be stuff a break message down the tty. 1672 */ 1673 1674 static void gsm_control_modem(struct gsm_mux *gsm, const u8 *data, int clen) 1675 { 1676 unsigned int addr = 0; 1677 unsigned int modem = 0; 1678 struct gsm_dlci *dlci; 1679 int len = clen; 1680 int cl = clen; 1681 const u8 *dp = data; 1682 struct tty_struct *tty; 1683 1684 len = gsm_read_ea_val(&addr, data, cl); 1685 if (len < 1) 1686 return; 1687 1688 addr >>= 1; 1689 /* Closed port, or invalid ? */ 1690 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL) 1691 return; 1692 dlci = gsm->dlci[addr]; 1693 1694 /* Must be at least one byte following the EA */ 1695 if ((cl - len) < 1) 1696 return; 1697 1698 dp += len; 1699 cl -= len; 1700 1701 /* get the modem status */ 1702 len = gsm_read_ea_val(&modem, dp, cl); 1703 if (len < 1) 1704 return; 1705 1706 tty = tty_port_tty_get(&dlci->port); 1707 gsm_process_modem(tty, dlci, modem, cl); 1708 if (tty) { 1709 tty_wakeup(tty); 1710 tty_kref_put(tty); 1711 } 1712 gsm_control_reply(gsm, CMD_MSC, data, clen); 1713 } 1714 1715 /** 1716 * gsm_control_negotiation - parameter negotiation received 1717 * @gsm: GSM channel 1718 * @cr: command/response flag 1719 * @data: data following command 1720 * @dlen: data length 1721 * 1722 * We have received a parameter negotiation message. This is used by 1723 * the GSM mux protocol to configure protocol parameters for a new DLCI. 1724 */ 1725 static void gsm_control_negotiation(struct gsm_mux *gsm, unsigned int cr, 1726 const u8 *data, unsigned int dlen) 1727 { 1728 unsigned int addr; 1729 struct gsm_dlci_param_bits pn_reply; 1730 struct gsm_dlci *dlci; 1731 struct gsm_dlci_param_bits *params; 1732 1733 if (dlen < sizeof(struct gsm_dlci_param_bits)) 1734 return; 1735 1736 /* Invalid DLCI? */ 1737 params = (struct gsm_dlci_param_bits *)data; 1738 addr = FIELD_GET(PN_D_FIELD_DLCI, params->d_bits); 1739 if (addr == 0 || addr >= NUM_DLCI || !gsm->dlci[addr]) 1740 return; 1741 dlci = gsm->dlci[addr]; 1742 1743 /* Too late for parameter negotiation? */ 1744 if ((!cr && dlci->state == DLCI_OPENING) || dlci->state == DLCI_OPEN) 1745 return; 1746 1747 /* Process the received parameters */ 1748 if (gsm_process_negotiation(gsm, addr, cr, params) != 0) { 1749 /* Negotiation failed. Close the link. */ 1750 if (debug & DBG_ERRORS) 1751 pr_info("%s PN failed\n", __func__); 1752 gsm_dlci_close(dlci); 1753 return; 1754 } 1755 1756 if (cr) { 1757 /* Reply command with accepted parameters. */ 1758 if (gsm_encode_params(dlci, &pn_reply) == 0) 1759 gsm_control_reply(gsm, CMD_PN, (const u8 *)&pn_reply, 1760 sizeof(pn_reply)); 1761 else if (debug & DBG_ERRORS) 1762 pr_info("%s PN invalid\n", __func__); 1763 } else if (dlci->state == DLCI_CONFIGURE) { 1764 /* Proceed with link setup by sending SABM before UA */ 1765 dlci->state = DLCI_OPENING; 1766 gsm_command(gsm, dlci->addr, SABM|PF); 1767 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 1768 } else { 1769 if (debug & DBG_ERRORS) 1770 pr_info("%s PN in invalid state\n", __func__); 1771 } 1772 } 1773 1774 /** 1775 * gsm_control_rls - remote line status 1776 * @gsm: GSM channel 1777 * @data: data bytes 1778 * @clen: data length 1779 * 1780 * The modem sends us a two byte message on the control channel whenever 1781 * it wishes to send us an error state from the virtual link. Stuff 1782 * this into the uplink tty if present 1783 */ 1784 1785 static void gsm_control_rls(struct gsm_mux *gsm, const u8 *data, int clen) 1786 { 1787 struct tty_port *port; 1788 unsigned int addr = 0; 1789 u8 bits; 1790 int len = clen; 1791 const u8 *dp = data; 1792 1793 while (gsm_read_ea(&addr, *dp++) == 0) { 1794 len--; 1795 if (len == 0) 1796 return; 1797 } 1798 /* Must be at least one byte following ea */ 1799 len--; 1800 if (len <= 0) 1801 return; 1802 addr >>= 1; 1803 /* Closed port, or invalid ? */ 1804 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL) 1805 return; 1806 /* No error ? */ 1807 bits = *dp; 1808 if ((bits & 1) == 0) 1809 return; 1810 1811 port = &gsm->dlci[addr]->port; 1812 1813 if (bits & 2) 1814 tty_insert_flip_char(port, 0, TTY_OVERRUN); 1815 if (bits & 4) 1816 tty_insert_flip_char(port, 0, TTY_PARITY); 1817 if (bits & 8) 1818 tty_insert_flip_char(port, 0, TTY_FRAME); 1819 1820 tty_flip_buffer_push(port); 1821 1822 gsm_control_reply(gsm, CMD_RLS, data, clen); 1823 } 1824 1825 static void gsm_dlci_begin_close(struct gsm_dlci *dlci); 1826 1827 /** 1828 * gsm_control_message - DLCI 0 control processing 1829 * @gsm: our GSM mux 1830 * @command: the command EA 1831 * @data: data beyond the command/length EAs 1832 * @clen: length 1833 * 1834 * Input processor for control messages from the other end of the link. 1835 * Processes the incoming request and queues a response frame or an 1836 * NSC response if not supported 1837 */ 1838 1839 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command, 1840 const u8 *data, int clen) 1841 { 1842 u8 buf[1]; 1843 1844 switch (command) { 1845 case CMD_CLD: { 1846 struct gsm_dlci *dlci = gsm->dlci[0]; 1847 /* Modem wishes to close down */ 1848 if (dlci) { 1849 dlci->dead = true; 1850 gsm->dead = true; 1851 gsm_dlci_begin_close(dlci); 1852 } 1853 } 1854 break; 1855 case CMD_TEST: 1856 /* Modem wishes to test, reply with the data */ 1857 gsm_control_reply(gsm, CMD_TEST, data, clen); 1858 break; 1859 case CMD_FCON: 1860 /* Modem can accept data again */ 1861 gsm->constipated = false; 1862 gsm_control_reply(gsm, CMD_FCON, NULL, 0); 1863 /* Kick the link in case it is idling */ 1864 gsmld_write_trigger(gsm); 1865 break; 1866 case CMD_FCOFF: 1867 /* Modem wants us to STFU */ 1868 gsm->constipated = true; 1869 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0); 1870 break; 1871 case CMD_MSC: 1872 /* Out of band modem line change indicator for a DLCI */ 1873 gsm_control_modem(gsm, data, clen); 1874 break; 1875 case CMD_RLS: 1876 /* Out of band error reception for a DLCI */ 1877 gsm_control_rls(gsm, data, clen); 1878 break; 1879 case CMD_PSC: 1880 /* Modem wishes to enter power saving state */ 1881 gsm_control_reply(gsm, CMD_PSC, NULL, 0); 1882 break; 1883 /* Optional commands */ 1884 case CMD_PN: 1885 /* Modem sends a parameter negotiation command */ 1886 gsm_control_negotiation(gsm, 1, data, clen); 1887 break; 1888 /* Optional unsupported commands */ 1889 case CMD_RPN: /* Remote port negotiation */ 1890 case CMD_SNC: /* Service negotiation command */ 1891 default: 1892 /* Reply to bad commands with an NSC */ 1893 buf[0] = command; 1894 gsm_control_reply(gsm, CMD_NSC, buf, 1); 1895 break; 1896 } 1897 } 1898 1899 /** 1900 * gsm_control_response - process a response to our control 1901 * @gsm: our GSM mux 1902 * @command: the command (response) EA 1903 * @data: data beyond the command/length EA 1904 * @clen: length 1905 * 1906 * Process a response to an outstanding command. We only allow a single 1907 * control message in flight so this is fairly easy. All the clean up 1908 * is done by the caller, we just update the fields, flag it as done 1909 * and return 1910 */ 1911 1912 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command, 1913 const u8 *data, int clen) 1914 { 1915 struct gsm_control *ctrl; 1916 struct gsm_dlci *dlci; 1917 unsigned long flags; 1918 1919 spin_lock_irqsave(&gsm->control_lock, flags); 1920 1921 ctrl = gsm->pending_cmd; 1922 dlci = gsm->dlci[0]; 1923 command |= 1; 1924 /* Does the reply match our command */ 1925 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) { 1926 /* Our command was replied to, kill the retry timer */ 1927 del_timer(&gsm->t2_timer); 1928 gsm->pending_cmd = NULL; 1929 /* Rejected by the other end */ 1930 if (command == CMD_NSC) 1931 ctrl->error = -EOPNOTSUPP; 1932 ctrl->done = 1; 1933 wake_up(&gsm->event); 1934 /* Or did we receive the PN response to our PN command */ 1935 } else if (command == CMD_PN) { 1936 gsm_control_negotiation(gsm, 0, data, clen); 1937 /* Or did we receive the TEST response to our TEST command */ 1938 } else if (command == CMD_TEST && clen == 1 && *data == gsm->ka_num) { 1939 gsm->ka_retries = -1; /* trigger new keep-alive message */ 1940 if (dlci && !dlci->dead) 1941 mod_timer(&gsm->ka_timer, jiffies + gsm->keep_alive * HZ / 100); 1942 } 1943 spin_unlock_irqrestore(&gsm->control_lock, flags); 1944 } 1945 1946 /** 1947 * gsm_control_keep_alive - check timeout or start keep-alive 1948 * @t: timer contained in our gsm object 1949 * 1950 * Called off the keep-alive timer expiry signaling that our link 1951 * partner is not responding anymore. Link will be closed. 1952 * This is also called to startup our timer. 1953 */ 1954 1955 static void gsm_control_keep_alive(struct timer_list *t) 1956 { 1957 struct gsm_mux *gsm = from_timer(gsm, t, ka_timer); 1958 unsigned long flags; 1959 1960 spin_lock_irqsave(&gsm->control_lock, flags); 1961 if (gsm->ka_num && gsm->ka_retries == 0) { 1962 /* Keep-alive expired -> close the link */ 1963 if (debug & DBG_ERRORS) 1964 pr_debug("%s keep-alive timed out\n", __func__); 1965 spin_unlock_irqrestore(&gsm->control_lock, flags); 1966 if (gsm->dlci[0]) 1967 gsm_dlci_begin_close(gsm->dlci[0]); 1968 return; 1969 } else if (gsm->keep_alive && gsm->dlci[0] && !gsm->dlci[0]->dead) { 1970 if (gsm->ka_retries > 0) { 1971 /* T2 expired for keep-alive -> resend */ 1972 gsm->ka_retries--; 1973 } else { 1974 /* Start keep-alive timer */ 1975 gsm->ka_num++; 1976 if (!gsm->ka_num) 1977 gsm->ka_num++; 1978 gsm->ka_retries = (signed int)gsm->n2; 1979 } 1980 gsm_control_command(gsm, CMD_TEST, &gsm->ka_num, 1981 sizeof(gsm->ka_num)); 1982 mod_timer(&gsm->ka_timer, 1983 jiffies + gsm->t2 * HZ / 100); 1984 } 1985 spin_unlock_irqrestore(&gsm->control_lock, flags); 1986 } 1987 1988 /** 1989 * gsm_control_transmit - send control packet 1990 * @gsm: gsm mux 1991 * @ctrl: frame to send 1992 * 1993 * Send out a pending control command (called under control lock) 1994 */ 1995 1996 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl) 1997 { 1998 gsm_control_command(gsm, ctrl->cmd, ctrl->data, ctrl->len); 1999 } 2000 2001 /** 2002 * gsm_control_retransmit - retransmit a control frame 2003 * @t: timer contained in our gsm object 2004 * 2005 * Called off the T2 timer expiry in order to retransmit control frames 2006 * that have been lost in the system somewhere. The control_lock protects 2007 * us from colliding with another sender or a receive completion event. 2008 * In that situation the timer may still occur in a small window but 2009 * gsm->pending_cmd will be NULL and we just let the timer expire. 2010 */ 2011 2012 static void gsm_control_retransmit(struct timer_list *t) 2013 { 2014 struct gsm_mux *gsm = from_timer(gsm, t, t2_timer); 2015 struct gsm_control *ctrl; 2016 unsigned long flags; 2017 spin_lock_irqsave(&gsm->control_lock, flags); 2018 ctrl = gsm->pending_cmd; 2019 if (ctrl) { 2020 if (gsm->cretries == 0 || !gsm->dlci[0] || gsm->dlci[0]->dead) { 2021 gsm->pending_cmd = NULL; 2022 ctrl->error = -ETIMEDOUT; 2023 ctrl->done = 1; 2024 spin_unlock_irqrestore(&gsm->control_lock, flags); 2025 wake_up(&gsm->event); 2026 return; 2027 } 2028 gsm->cretries--; 2029 gsm_control_transmit(gsm, ctrl); 2030 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100); 2031 } 2032 spin_unlock_irqrestore(&gsm->control_lock, flags); 2033 } 2034 2035 /** 2036 * gsm_control_send - send a control frame on DLCI 0 2037 * @gsm: the GSM channel 2038 * @command: command to send including CR bit 2039 * @data: bytes of data (must be kmalloced) 2040 * @clen: length of the block to send 2041 * 2042 * Queue and dispatch a control command. Only one command can be 2043 * active at a time. In theory more can be outstanding but the matching 2044 * gets really complicated so for now stick to one outstanding. 2045 */ 2046 2047 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm, 2048 unsigned int command, u8 *data, int clen) 2049 { 2050 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control), 2051 GFP_ATOMIC); 2052 unsigned long flags; 2053 if (ctrl == NULL) 2054 return NULL; 2055 retry: 2056 wait_event(gsm->event, gsm->pending_cmd == NULL); 2057 spin_lock_irqsave(&gsm->control_lock, flags); 2058 if (gsm->pending_cmd != NULL) { 2059 spin_unlock_irqrestore(&gsm->control_lock, flags); 2060 goto retry; 2061 } 2062 ctrl->cmd = command; 2063 ctrl->data = data; 2064 ctrl->len = clen; 2065 gsm->pending_cmd = ctrl; 2066 2067 /* If DLCI0 is in ADM mode skip retries, it won't respond */ 2068 if (gsm->dlci[0]->mode == DLCI_MODE_ADM) 2069 gsm->cretries = 0; 2070 else 2071 gsm->cretries = gsm->n2; 2072 2073 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100); 2074 gsm_control_transmit(gsm, ctrl); 2075 spin_unlock_irqrestore(&gsm->control_lock, flags); 2076 return ctrl; 2077 } 2078 2079 /** 2080 * gsm_control_wait - wait for a control to finish 2081 * @gsm: GSM mux 2082 * @control: control we are waiting on 2083 * 2084 * Waits for the control to complete or time out. Frees any used 2085 * resources and returns 0 for success, or an error if the remote 2086 * rejected or ignored the request. 2087 */ 2088 2089 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control) 2090 { 2091 int err; 2092 wait_event(gsm->event, control->done == 1); 2093 err = control->error; 2094 kfree(control); 2095 return err; 2096 } 2097 2098 2099 /* 2100 * DLCI level handling: Needs krefs 2101 */ 2102 2103 /* 2104 * State transitions and timers 2105 */ 2106 2107 /** 2108 * gsm_dlci_close - a DLCI has closed 2109 * @dlci: DLCI that closed 2110 * 2111 * Perform processing when moving a DLCI into closed state. If there 2112 * is an attached tty this is hung up 2113 */ 2114 2115 static void gsm_dlci_close(struct gsm_dlci *dlci) 2116 { 2117 del_timer(&dlci->t1); 2118 if (debug & DBG_ERRORS) 2119 pr_debug("DLCI %d goes closed.\n", dlci->addr); 2120 dlci->state = DLCI_CLOSED; 2121 /* Prevent us from sending data before the link is up again */ 2122 dlci->constipated = true; 2123 if (dlci->addr != 0) { 2124 tty_port_tty_hangup(&dlci->port, false); 2125 gsm_dlci_clear_queues(dlci->gsm, dlci); 2126 /* Ensure that gsmtty_open() can return. */ 2127 tty_port_set_initialized(&dlci->port, false); 2128 wake_up_interruptible(&dlci->port.open_wait); 2129 } else { 2130 del_timer(&dlci->gsm->ka_timer); 2131 dlci->gsm->dead = true; 2132 } 2133 /* A DLCI 0 close is a MUX termination so we need to kick that 2134 back to userspace somehow */ 2135 gsm_dlci_data_kick(dlci); 2136 wake_up_all(&dlci->gsm->event); 2137 } 2138 2139 /** 2140 * gsm_dlci_open - a DLCI has opened 2141 * @dlci: DLCI that opened 2142 * 2143 * Perform processing when moving a DLCI into open state. 2144 */ 2145 2146 static void gsm_dlci_open(struct gsm_dlci *dlci) 2147 { 2148 struct gsm_mux *gsm = dlci->gsm; 2149 2150 /* Note that SABM UA .. SABM UA first UA lost can mean that we go 2151 open -> open */ 2152 del_timer(&dlci->t1); 2153 /* This will let a tty open continue */ 2154 dlci->state = DLCI_OPEN; 2155 dlci->constipated = false; 2156 if (debug & DBG_ERRORS) 2157 pr_debug("DLCI %d goes open.\n", dlci->addr); 2158 /* Send current modem state */ 2159 if (dlci->addr) { 2160 gsm_modem_update(dlci, 0); 2161 } else { 2162 /* Start keep-alive control */ 2163 gsm->ka_num = 0; 2164 gsm->ka_retries = -1; 2165 mod_timer(&gsm->ka_timer, 2166 jiffies + gsm->keep_alive * HZ / 100); 2167 } 2168 gsm_dlci_data_kick(dlci); 2169 wake_up(&dlci->gsm->event); 2170 } 2171 2172 /** 2173 * gsm_dlci_negotiate - start parameter negotiation 2174 * @dlci: DLCI to open 2175 * 2176 * Starts the parameter negotiation for the new DLCI. This needs to be done 2177 * before the DLCI initialized the channel via SABM. 2178 */ 2179 static int gsm_dlci_negotiate(struct gsm_dlci *dlci) 2180 { 2181 struct gsm_mux *gsm = dlci->gsm; 2182 struct gsm_dlci_param_bits params; 2183 int ret; 2184 2185 ret = gsm_encode_params(dlci, ¶ms); 2186 if (ret != 0) 2187 return ret; 2188 2189 /* We cannot asynchronous wait for the command response with 2190 * gsm_command() and gsm_control_wait() at this point. 2191 */ 2192 ret = gsm_control_command(gsm, CMD_PN, (const u8 *)¶ms, 2193 sizeof(params)); 2194 2195 return ret; 2196 } 2197 2198 /** 2199 * gsm_dlci_t1 - T1 timer expiry 2200 * @t: timer contained in the DLCI that opened 2201 * 2202 * The T1 timer handles retransmits of control frames (essentially of 2203 * SABM and DISC). We resend the command until the retry count runs out 2204 * in which case an opening port goes back to closed and a closing port 2205 * is simply put into closed state (any further frames from the other 2206 * end will get a DM response) 2207 * 2208 * Some control dlci can stay in ADM mode with other dlci working just 2209 * fine. In that case we can just keep the control dlci open after the 2210 * DLCI_OPENING retries time out. 2211 */ 2212 2213 static void gsm_dlci_t1(struct timer_list *t) 2214 { 2215 struct gsm_dlci *dlci = from_timer(dlci, t, t1); 2216 struct gsm_mux *gsm = dlci->gsm; 2217 2218 switch (dlci->state) { 2219 case DLCI_CONFIGURE: 2220 if (dlci->retries && gsm_dlci_negotiate(dlci) == 0) { 2221 dlci->retries--; 2222 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 2223 } else { 2224 gsm_dlci_begin_close(dlci); /* prevent half open link */ 2225 } 2226 break; 2227 case DLCI_OPENING: 2228 if (dlci->retries) { 2229 dlci->retries--; 2230 gsm_command(dlci->gsm, dlci->addr, SABM|PF); 2231 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 2232 } else if (!dlci->addr && gsm->control == (DM | PF)) { 2233 if (debug & DBG_ERRORS) 2234 pr_info("DLCI %d opening in ADM mode.\n", 2235 dlci->addr); 2236 dlci->mode = DLCI_MODE_ADM; 2237 gsm_dlci_open(dlci); 2238 } else { 2239 gsm_dlci_begin_close(dlci); /* prevent half open link */ 2240 } 2241 2242 break; 2243 case DLCI_CLOSING: 2244 if (dlci->retries) { 2245 dlci->retries--; 2246 gsm_command(dlci->gsm, dlci->addr, DISC|PF); 2247 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 2248 } else 2249 gsm_dlci_close(dlci); 2250 break; 2251 default: 2252 pr_debug("%s: unhandled state: %d\n", __func__, dlci->state); 2253 break; 2254 } 2255 } 2256 2257 /** 2258 * gsm_dlci_begin_open - start channel open procedure 2259 * @dlci: DLCI to open 2260 * 2261 * Commence opening a DLCI from the Linux side. We issue SABM messages 2262 * to the modem which should then reply with a UA or ADM, at which point 2263 * we will move into open state. Opening is done asynchronously with retry 2264 * running off timers and the responses. 2265 * Parameter negotiation is performed before SABM if required. 2266 */ 2267 2268 static void gsm_dlci_begin_open(struct gsm_dlci *dlci) 2269 { 2270 struct gsm_mux *gsm = dlci ? dlci->gsm : NULL; 2271 bool need_pn = false; 2272 2273 if (!gsm) 2274 return; 2275 2276 if (dlci->addr != 0) { 2277 if (gsm->adaption != 1 || gsm->adaption != dlci->adaption) 2278 need_pn = true; 2279 if (dlci->prio != (roundup(dlci->addr + 1, 8) - 1)) 2280 need_pn = true; 2281 if (gsm->ftype != dlci->ftype) 2282 need_pn = true; 2283 } 2284 2285 switch (dlci->state) { 2286 case DLCI_CLOSED: 2287 case DLCI_WAITING_CONFIG: 2288 case DLCI_CLOSING: 2289 dlci->retries = gsm->n2; 2290 if (!need_pn) { 2291 dlci->state = DLCI_OPENING; 2292 gsm_command(gsm, dlci->addr, SABM|PF); 2293 } else { 2294 /* Configure DLCI before setup */ 2295 dlci->state = DLCI_CONFIGURE; 2296 if (gsm_dlci_negotiate(dlci) != 0) { 2297 gsm_dlci_close(dlci); 2298 return; 2299 } 2300 } 2301 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 2302 break; 2303 default: 2304 break; 2305 } 2306 } 2307 2308 /** 2309 * gsm_dlci_set_opening - change state to opening 2310 * @dlci: DLCI to open 2311 * 2312 * Change internal state to wait for DLCI open from initiator side. 2313 * We set off timers and responses upon reception of an SABM. 2314 */ 2315 static void gsm_dlci_set_opening(struct gsm_dlci *dlci) 2316 { 2317 switch (dlci->state) { 2318 case DLCI_CLOSED: 2319 case DLCI_WAITING_CONFIG: 2320 case DLCI_CLOSING: 2321 dlci->state = DLCI_OPENING; 2322 break; 2323 default: 2324 break; 2325 } 2326 } 2327 2328 /** 2329 * gsm_dlci_set_wait_config - wait for channel configuration 2330 * @dlci: DLCI to configure 2331 * 2332 * Wait for a DLCI configuration from the application. 2333 */ 2334 static void gsm_dlci_set_wait_config(struct gsm_dlci *dlci) 2335 { 2336 switch (dlci->state) { 2337 case DLCI_CLOSED: 2338 case DLCI_CLOSING: 2339 dlci->state = DLCI_WAITING_CONFIG; 2340 break; 2341 default: 2342 break; 2343 } 2344 } 2345 2346 /** 2347 * gsm_dlci_begin_close - start channel open procedure 2348 * @dlci: DLCI to open 2349 * 2350 * Commence closing a DLCI from the Linux side. We issue DISC messages 2351 * to the modem which should then reply with a UA, at which point we 2352 * will move into closed state. Closing is done asynchronously with retry 2353 * off timers. We may also receive a DM reply from the other end which 2354 * indicates the channel was already closed. 2355 */ 2356 2357 static void gsm_dlci_begin_close(struct gsm_dlci *dlci) 2358 { 2359 struct gsm_mux *gsm = dlci->gsm; 2360 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING) 2361 return; 2362 dlci->retries = gsm->n2; 2363 dlci->state = DLCI_CLOSING; 2364 gsm_command(dlci->gsm, dlci->addr, DISC|PF); 2365 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); 2366 wake_up_interruptible(&gsm->event); 2367 } 2368 2369 /** 2370 * gsm_dlci_data - data arrived 2371 * @dlci: channel 2372 * @data: block of bytes received 2373 * @clen: length of received block 2374 * 2375 * A UI or UIH frame has arrived which contains data for a channel 2376 * other than the control channel. If the relevant virtual tty is 2377 * open we shovel the bits down it, if not we drop them. 2378 */ 2379 2380 static void gsm_dlci_data(struct gsm_dlci *dlci, const u8 *data, int clen) 2381 { 2382 /* krefs .. */ 2383 struct tty_port *port = &dlci->port; 2384 struct tty_struct *tty; 2385 unsigned int modem = 0; 2386 int len; 2387 2388 if (debug & DBG_TTY) 2389 pr_debug("%d bytes for tty\n", clen); 2390 switch (dlci->adaption) { 2391 /* Unsupported types */ 2392 case 4: /* Packetised interruptible data */ 2393 break; 2394 case 3: /* Packetised uininterruptible voice/data */ 2395 break; 2396 case 2: /* Asynchronous serial with line state in each frame */ 2397 len = gsm_read_ea_val(&modem, data, clen); 2398 if (len < 1) 2399 return; 2400 tty = tty_port_tty_get(port); 2401 if (tty) { 2402 gsm_process_modem(tty, dlci, modem, len); 2403 tty_wakeup(tty); 2404 tty_kref_put(tty); 2405 } 2406 /* Skip processed modem data */ 2407 data += len; 2408 clen -= len; 2409 fallthrough; 2410 case 1: /* Line state will go via DLCI 0 controls only */ 2411 default: 2412 tty_insert_flip_string(port, data, clen); 2413 tty_flip_buffer_push(port); 2414 } 2415 } 2416 2417 /** 2418 * gsm_dlci_command - data arrived on control channel 2419 * @dlci: channel 2420 * @data: block of bytes received 2421 * @len: length of received block 2422 * 2423 * A UI or UIH frame has arrived which contains data for DLCI 0 the 2424 * control channel. This should contain a command EA followed by 2425 * control data bytes. The command EA contains a command/response bit 2426 * and we divide up the work accordingly. 2427 */ 2428 2429 static void gsm_dlci_command(struct gsm_dlci *dlci, const u8 *data, int len) 2430 { 2431 /* See what command is involved */ 2432 unsigned int command = 0; 2433 unsigned int clen = 0; 2434 unsigned int dlen; 2435 2436 /* read the command */ 2437 dlen = gsm_read_ea_val(&command, data, len); 2438 len -= dlen; 2439 data += dlen; 2440 2441 /* read any control data */ 2442 dlen = gsm_read_ea_val(&clen, data, len); 2443 len -= dlen; 2444 data += dlen; 2445 2446 /* Malformed command? */ 2447 if (clen > len) 2448 return; 2449 2450 if (command & 1) 2451 gsm_control_message(dlci->gsm, command, data, clen); 2452 else 2453 gsm_control_response(dlci->gsm, command, data, clen); 2454 } 2455 2456 /** 2457 * gsm_kick_timer - transmit if possible 2458 * @t: timer contained in our gsm object 2459 * 2460 * Transmit data from DLCIs if the queue is empty. We can't rely on 2461 * a tty wakeup except when we filled the pipe so we need to fire off 2462 * new data ourselves in other cases. 2463 */ 2464 static void gsm_kick_timer(struct timer_list *t) 2465 { 2466 struct gsm_mux *gsm = from_timer(gsm, t, kick_timer); 2467 unsigned long flags; 2468 int sent = 0; 2469 2470 spin_lock_irqsave(&gsm->tx_lock, flags); 2471 /* If we have nothing running then we need to fire up */ 2472 if (gsm->tx_bytes < TX_THRESH_LO) 2473 sent = gsm_dlci_data_sweep(gsm); 2474 spin_unlock_irqrestore(&gsm->tx_lock, flags); 2475 2476 if (sent && debug & DBG_DATA) 2477 pr_info("%s TX queue stalled\n", __func__); 2478 } 2479 2480 /** 2481 * gsm_dlci_copy_config_values - copy DLCI configuration 2482 * @dlci: source DLCI 2483 * @dc: configuration structure to fill 2484 */ 2485 static void gsm_dlci_copy_config_values(struct gsm_dlci *dlci, struct gsm_dlci_config *dc) 2486 { 2487 memset(dc, 0, sizeof(*dc)); 2488 dc->channel = (u32)dlci->addr; 2489 dc->adaption = (u32)dlci->adaption; 2490 dc->mtu = (u32)dlci->mtu; 2491 dc->priority = (u32)dlci->prio; 2492 if (dlci->ftype == UIH) 2493 dc->i = 1; 2494 else 2495 dc->i = 2; 2496 dc->k = (u32)dlci->k; 2497 } 2498 2499 /** 2500 * gsm_dlci_config - configure DLCI from configuration 2501 * @dlci: DLCI to configure 2502 * @dc: DLCI configuration 2503 * @open: open DLCI after configuration? 2504 */ 2505 static int gsm_dlci_config(struct gsm_dlci *dlci, struct gsm_dlci_config *dc, int open) 2506 { 2507 struct gsm_mux *gsm; 2508 bool need_restart = false; 2509 bool need_open = false; 2510 unsigned int i; 2511 2512 /* 2513 * Check that userspace doesn't put stuff in here to prevent breakages 2514 * in the future. 2515 */ 2516 for (i = 0; i < ARRAY_SIZE(dc->reserved); i++) 2517 if (dc->reserved[i]) 2518 return -EINVAL; 2519 2520 if (!dlci) 2521 return -EINVAL; 2522 gsm = dlci->gsm; 2523 2524 /* Stuff we don't support yet - I frame transport */ 2525 if (dc->adaption != 1 && dc->adaption != 2) 2526 return -EOPNOTSUPP; 2527 if (dc->mtu > MAX_MTU || dc->mtu < MIN_MTU || dc->mtu > gsm->mru) 2528 return -EINVAL; 2529 if (dc->priority >= 64) 2530 return -EINVAL; 2531 if (dc->i == 0 || dc->i > 2) /* UIH and UI only */ 2532 return -EINVAL; 2533 if (dc->k > 7) 2534 return -EINVAL; 2535 2536 /* 2537 * See what is needed for reconfiguration 2538 */ 2539 /* Framing fields */ 2540 if (dc->adaption != dlci->adaption) 2541 need_restart = true; 2542 if (dc->mtu != dlci->mtu) 2543 need_restart = true; 2544 if (dc->i != dlci->ftype) 2545 need_restart = true; 2546 /* Requires care */ 2547 if (dc->priority != dlci->prio) 2548 need_restart = true; 2549 2550 if ((open && gsm->wait_config) || need_restart) 2551 need_open = true; 2552 if (dlci->state == DLCI_WAITING_CONFIG) { 2553 need_restart = false; 2554 need_open = true; 2555 } 2556 2557 /* 2558 * Close down what is needed, restart and initiate the new 2559 * configuration. 2560 */ 2561 if (need_restart) { 2562 gsm_dlci_begin_close(dlci); 2563 wait_event_interruptible(gsm->event, dlci->state == DLCI_CLOSED); 2564 if (signal_pending(current)) 2565 return -EINTR; 2566 } 2567 /* 2568 * Setup the new configuration values 2569 */ 2570 dlci->adaption = (int)dc->adaption; 2571 2572 if (dc->mtu) 2573 dlci->mtu = (unsigned int)dc->mtu; 2574 else 2575 dlci->mtu = gsm->mtu; 2576 2577 if (dc->priority) 2578 dlci->prio = (u8)dc->priority; 2579 else 2580 dlci->prio = roundup(dlci->addr + 1, 8) - 1; 2581 2582 if (dc->i == 1) 2583 dlci->ftype = UIH; 2584 else if (dc->i == 2) 2585 dlci->ftype = UI; 2586 2587 if (dc->k) 2588 dlci->k = (u8)dc->k; 2589 else 2590 dlci->k = gsm->k; 2591 2592 if (need_open) { 2593 if (gsm->initiator) 2594 gsm_dlci_begin_open(dlci); 2595 else 2596 gsm_dlci_set_opening(dlci); 2597 } 2598 2599 return 0; 2600 } 2601 2602 /* 2603 * Allocate/Free DLCI channels 2604 */ 2605 2606 /** 2607 * gsm_dlci_alloc - allocate a DLCI 2608 * @gsm: GSM mux 2609 * @addr: address of the DLCI 2610 * 2611 * Allocate and install a new DLCI object into the GSM mux. 2612 * 2613 * FIXME: review locking races 2614 */ 2615 2616 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr) 2617 { 2618 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC); 2619 if (dlci == NULL) 2620 return NULL; 2621 spin_lock_init(&dlci->lock); 2622 mutex_init(&dlci->mutex); 2623 if (kfifo_alloc(&dlci->fifo, TX_SIZE, GFP_KERNEL) < 0) { 2624 kfree(dlci); 2625 return NULL; 2626 } 2627 2628 skb_queue_head_init(&dlci->skb_list); 2629 timer_setup(&dlci->t1, gsm_dlci_t1, 0); 2630 tty_port_init(&dlci->port); 2631 dlci->port.ops = &gsm_port_ops; 2632 dlci->gsm = gsm; 2633 dlci->addr = addr; 2634 dlci->adaption = gsm->adaption; 2635 dlci->mtu = gsm->mtu; 2636 if (addr == 0) 2637 dlci->prio = 0; 2638 else 2639 dlci->prio = roundup(addr + 1, 8) - 1; 2640 dlci->ftype = gsm->ftype; 2641 dlci->k = gsm->k; 2642 dlci->state = DLCI_CLOSED; 2643 if (addr) { 2644 dlci->data = gsm_dlci_data; 2645 /* Prevent us from sending data before the link is up */ 2646 dlci->constipated = true; 2647 } else { 2648 dlci->data = gsm_dlci_command; 2649 } 2650 gsm->dlci[addr] = dlci; 2651 return dlci; 2652 } 2653 2654 /** 2655 * gsm_dlci_free - free DLCI 2656 * @port: tty port for DLCI to free 2657 * 2658 * Free up a DLCI. 2659 * 2660 * Can sleep. 2661 */ 2662 static void gsm_dlci_free(struct tty_port *port) 2663 { 2664 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 2665 2666 timer_shutdown_sync(&dlci->t1); 2667 dlci->gsm->dlci[dlci->addr] = NULL; 2668 kfifo_free(&dlci->fifo); 2669 while ((dlci->skb = skb_dequeue(&dlci->skb_list))) 2670 dev_kfree_skb(dlci->skb); 2671 kfree(dlci); 2672 } 2673 2674 static inline void dlci_get(struct gsm_dlci *dlci) 2675 { 2676 tty_port_get(&dlci->port); 2677 } 2678 2679 static inline void dlci_put(struct gsm_dlci *dlci) 2680 { 2681 tty_port_put(&dlci->port); 2682 } 2683 2684 static void gsm_destroy_network(struct gsm_dlci *dlci); 2685 2686 /** 2687 * gsm_dlci_release - release DLCI 2688 * @dlci: DLCI to destroy 2689 * 2690 * Release a DLCI. Actual free is deferred until either 2691 * mux is closed or tty is closed - whichever is last. 2692 * 2693 * Can sleep. 2694 */ 2695 static void gsm_dlci_release(struct gsm_dlci *dlci) 2696 { 2697 struct tty_struct *tty = tty_port_tty_get(&dlci->port); 2698 if (tty) { 2699 mutex_lock(&dlci->mutex); 2700 gsm_destroy_network(dlci); 2701 mutex_unlock(&dlci->mutex); 2702 2703 /* We cannot use tty_hangup() because in tty_kref_put() the tty 2704 * driver assumes that the hangup queue is free and reuses it to 2705 * queue release_one_tty() -> NULL pointer panic in 2706 * process_one_work(). 2707 */ 2708 tty_vhangup(tty); 2709 2710 tty_port_tty_set(&dlci->port, NULL); 2711 tty_kref_put(tty); 2712 } 2713 dlci->state = DLCI_CLOSED; 2714 dlci_put(dlci); 2715 } 2716 2717 /* 2718 * LAPBish link layer logic 2719 */ 2720 2721 /** 2722 * gsm_queue - a GSM frame is ready to process 2723 * @gsm: pointer to our gsm mux 2724 * 2725 * At this point in time a frame has arrived and been demangled from 2726 * the line encoding. All the differences between the encodings have 2727 * been handled below us and the frame is unpacked into the structures. 2728 * The fcs holds the header FCS but any data FCS must be added here. 2729 */ 2730 2731 static void gsm_queue(struct gsm_mux *gsm) 2732 { 2733 struct gsm_dlci *dlci; 2734 u8 cr; 2735 int address; 2736 2737 if (gsm->fcs != GOOD_FCS) { 2738 gsm->bad_fcs++; 2739 if (debug & DBG_DATA) 2740 pr_debug("BAD FCS %02x\n", gsm->fcs); 2741 return; 2742 } 2743 address = gsm->address >> 1; 2744 if (address >= NUM_DLCI) 2745 goto invalid; 2746 2747 cr = gsm->address & 1; /* C/R bit */ 2748 cr ^= gsm->initiator ? 0 : 1; /* Flip so 1 always means command */ 2749 2750 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len); 2751 2752 dlci = gsm->dlci[address]; 2753 2754 switch (gsm->control) { 2755 case SABM|PF: 2756 if (cr == 1) 2757 goto invalid; 2758 if (dlci == NULL) 2759 dlci = gsm_dlci_alloc(gsm, address); 2760 if (dlci == NULL) 2761 return; 2762 if (dlci->dead) 2763 gsm_response(gsm, address, DM|PF); 2764 else { 2765 gsm_response(gsm, address, UA|PF); 2766 gsm_dlci_open(dlci); 2767 } 2768 break; 2769 case DISC|PF: 2770 if (cr == 1) 2771 goto invalid; 2772 if (dlci == NULL || dlci->state == DLCI_CLOSED) { 2773 gsm_response(gsm, address, DM|PF); 2774 return; 2775 } 2776 /* Real close complete */ 2777 gsm_response(gsm, address, UA|PF); 2778 gsm_dlci_close(dlci); 2779 break; 2780 case UA|PF: 2781 if (cr == 0 || dlci == NULL) 2782 break; 2783 switch (dlci->state) { 2784 case DLCI_CLOSING: 2785 gsm_dlci_close(dlci); 2786 break; 2787 case DLCI_OPENING: 2788 gsm_dlci_open(dlci); 2789 break; 2790 default: 2791 pr_debug("%s: unhandled state: %d\n", __func__, 2792 dlci->state); 2793 break; 2794 } 2795 break; 2796 case DM: /* DM can be valid unsolicited */ 2797 case DM|PF: 2798 if (cr) 2799 goto invalid; 2800 if (dlci == NULL) 2801 return; 2802 gsm_dlci_close(dlci); 2803 break; 2804 case UI: 2805 case UI|PF: 2806 case UIH: 2807 case UIH|PF: 2808 if (dlci == NULL || dlci->state != DLCI_OPEN) { 2809 gsm_response(gsm, address, DM|PF); 2810 return; 2811 } 2812 dlci->data(dlci, gsm->buf, gsm->len); 2813 break; 2814 default: 2815 goto invalid; 2816 } 2817 return; 2818 invalid: 2819 gsm->malformed++; 2820 return; 2821 } 2822 2823 2824 /** 2825 * gsm0_receive - perform processing for non-transparency 2826 * @gsm: gsm data for this ldisc instance 2827 * @c: character 2828 * 2829 * Receive bytes in gsm mode 0 2830 */ 2831 2832 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c) 2833 { 2834 unsigned int len; 2835 2836 switch (gsm->state) { 2837 case GSM_SEARCH: /* SOF marker */ 2838 if (c == GSM0_SOF) { 2839 gsm->state = GSM_ADDRESS; 2840 gsm->address = 0; 2841 gsm->len = 0; 2842 gsm->fcs = INIT_FCS; 2843 } 2844 break; 2845 case GSM_ADDRESS: /* Address EA */ 2846 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2847 if (gsm_read_ea(&gsm->address, c)) 2848 gsm->state = GSM_CONTROL; 2849 break; 2850 case GSM_CONTROL: /* Control Byte */ 2851 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2852 gsm->control = c; 2853 gsm->state = GSM_LEN0; 2854 break; 2855 case GSM_LEN0: /* Length EA */ 2856 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2857 if (gsm_read_ea(&gsm->len, c)) { 2858 if (gsm->len > gsm->mru) { 2859 gsm->bad_size++; 2860 gsm->state = GSM_SEARCH; 2861 break; 2862 } 2863 gsm->count = 0; 2864 if (!gsm->len) 2865 gsm->state = GSM_FCS; 2866 else 2867 gsm->state = GSM_DATA; 2868 break; 2869 } 2870 gsm->state = GSM_LEN1; 2871 break; 2872 case GSM_LEN1: 2873 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2874 len = c; 2875 gsm->len |= len << 7; 2876 if (gsm->len > gsm->mru) { 2877 gsm->bad_size++; 2878 gsm->state = GSM_SEARCH; 2879 break; 2880 } 2881 gsm->count = 0; 2882 if (!gsm->len) 2883 gsm->state = GSM_FCS; 2884 else 2885 gsm->state = GSM_DATA; 2886 break; 2887 case GSM_DATA: /* Data */ 2888 gsm->buf[gsm->count++] = c; 2889 if (gsm->count == gsm->len) { 2890 /* Calculate final FCS for UI frames over all data */ 2891 if ((gsm->control & ~PF) != UIH) { 2892 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, 2893 gsm->count); 2894 } 2895 gsm->state = GSM_FCS; 2896 } 2897 break; 2898 case GSM_FCS: /* FCS follows the packet */ 2899 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2900 gsm->state = GSM_SSOF; 2901 break; 2902 case GSM_SSOF: 2903 gsm->state = GSM_SEARCH; 2904 if (c == GSM0_SOF) 2905 gsm_queue(gsm); 2906 else 2907 gsm->bad_size++; 2908 break; 2909 default: 2910 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state); 2911 break; 2912 } 2913 } 2914 2915 /** 2916 * gsm1_receive - perform processing for non-transparency 2917 * @gsm: gsm data for this ldisc instance 2918 * @c: character 2919 * 2920 * Receive bytes in mode 1 (Advanced option) 2921 */ 2922 2923 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c) 2924 { 2925 /* handle XON/XOFF */ 2926 if ((c & ISO_IEC_646_MASK) == XON) { 2927 gsm->constipated = true; 2928 return; 2929 } else if ((c & ISO_IEC_646_MASK) == XOFF) { 2930 gsm->constipated = false; 2931 /* Kick the link in case it is idling */ 2932 gsmld_write_trigger(gsm); 2933 return; 2934 } 2935 if (c == GSM1_SOF) { 2936 /* EOF is only valid in frame if we have got to the data state */ 2937 if (gsm->state == GSM_DATA) { 2938 if (gsm->count < 1) { 2939 /* Missing FSC */ 2940 gsm->malformed++; 2941 gsm->state = GSM_START; 2942 return; 2943 } 2944 /* Remove the FCS from data */ 2945 gsm->count--; 2946 if ((gsm->control & ~PF) != UIH) { 2947 /* Calculate final FCS for UI frames over all 2948 * data but FCS 2949 */ 2950 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, 2951 gsm->count); 2952 } 2953 /* Add the FCS itself to test against GOOD_FCS */ 2954 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]); 2955 gsm->len = gsm->count; 2956 gsm_queue(gsm); 2957 gsm->state = GSM_START; 2958 return; 2959 } 2960 /* Any partial frame was a runt so go back to start */ 2961 if (gsm->state != GSM_START) { 2962 if (gsm->state != GSM_SEARCH) 2963 gsm->malformed++; 2964 gsm->state = GSM_START; 2965 } 2966 /* A SOF in GSM_START means we are still reading idling or 2967 framing bytes */ 2968 return; 2969 } 2970 2971 if (c == GSM1_ESCAPE) { 2972 gsm->escape = true; 2973 return; 2974 } 2975 2976 /* Only an unescaped SOF gets us out of GSM search */ 2977 if (gsm->state == GSM_SEARCH) 2978 return; 2979 2980 if (gsm->escape) { 2981 c ^= GSM1_ESCAPE_BITS; 2982 gsm->escape = false; 2983 } 2984 switch (gsm->state) { 2985 case GSM_START: /* First byte after SOF */ 2986 gsm->address = 0; 2987 gsm->state = GSM_ADDRESS; 2988 gsm->fcs = INIT_FCS; 2989 fallthrough; 2990 case GSM_ADDRESS: /* Address continuation */ 2991 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2992 if (gsm_read_ea(&gsm->address, c)) 2993 gsm->state = GSM_CONTROL; 2994 break; 2995 case GSM_CONTROL: /* Control Byte */ 2996 gsm->fcs = gsm_fcs_add(gsm->fcs, c); 2997 gsm->control = c; 2998 gsm->count = 0; 2999 gsm->state = GSM_DATA; 3000 break; 3001 case GSM_DATA: /* Data */ 3002 if (gsm->count > gsm->mru) { /* Allow one for the FCS */ 3003 gsm->state = GSM_OVERRUN; 3004 gsm->bad_size++; 3005 } else 3006 gsm->buf[gsm->count++] = c; 3007 break; 3008 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */ 3009 break; 3010 default: 3011 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state); 3012 break; 3013 } 3014 } 3015 3016 /** 3017 * gsm_error - handle tty error 3018 * @gsm: ldisc data 3019 * 3020 * Handle an error in the receipt of data for a frame. Currently we just 3021 * go back to hunting for a SOF. 3022 * 3023 * FIXME: better diagnostics ? 3024 */ 3025 3026 static void gsm_error(struct gsm_mux *gsm) 3027 { 3028 gsm->state = GSM_SEARCH; 3029 gsm->io_error++; 3030 } 3031 3032 /** 3033 * gsm_cleanup_mux - generic GSM protocol cleanup 3034 * @gsm: our mux 3035 * @disc: disconnect link? 3036 * 3037 * Clean up the bits of the mux which are the same for all framing 3038 * protocols. Remove the mux from the mux table, stop all the timers 3039 * and then shut down each device hanging up the channels as we go. 3040 */ 3041 3042 static void gsm_cleanup_mux(struct gsm_mux *gsm, bool disc) 3043 { 3044 int i; 3045 struct gsm_dlci *dlci = gsm->dlci[0]; 3046 struct gsm_msg *txq, *ntxq; 3047 3048 gsm->dead = true; 3049 mutex_lock(&gsm->mutex); 3050 3051 if (dlci) { 3052 if (disc && dlci->state != DLCI_CLOSED) { 3053 gsm_dlci_begin_close(dlci); 3054 wait_event(gsm->event, dlci->state == DLCI_CLOSED); 3055 } 3056 dlci->dead = true; 3057 } 3058 3059 /* Finish outstanding timers, making sure they are done */ 3060 del_timer_sync(&gsm->kick_timer); 3061 del_timer_sync(&gsm->t2_timer); 3062 del_timer_sync(&gsm->ka_timer); 3063 3064 /* Finish writing to ldisc */ 3065 flush_work(&gsm->tx_work); 3066 3067 /* Free up any link layer users and finally the control channel */ 3068 if (gsm->has_devices) { 3069 gsm_unregister_devices(gsm_tty_driver, gsm->num); 3070 gsm->has_devices = false; 3071 } 3072 for (i = NUM_DLCI - 1; i >= 0; i--) 3073 if (gsm->dlci[i]) 3074 gsm_dlci_release(gsm->dlci[i]); 3075 mutex_unlock(&gsm->mutex); 3076 /* Now wipe the queues */ 3077 tty_ldisc_flush(gsm->tty); 3078 list_for_each_entry_safe(txq, ntxq, &gsm->tx_ctrl_list, list) 3079 kfree(txq); 3080 INIT_LIST_HEAD(&gsm->tx_ctrl_list); 3081 list_for_each_entry_safe(txq, ntxq, &gsm->tx_data_list, list) 3082 kfree(txq); 3083 INIT_LIST_HEAD(&gsm->tx_data_list); 3084 } 3085 3086 /** 3087 * gsm_activate_mux - generic GSM setup 3088 * @gsm: our mux 3089 * 3090 * Set up the bits of the mux which are the same for all framing 3091 * protocols. Add the mux to the mux table so it can be opened and 3092 * finally kick off connecting to DLCI 0 on the modem. 3093 */ 3094 3095 static int gsm_activate_mux(struct gsm_mux *gsm) 3096 { 3097 struct gsm_dlci *dlci; 3098 int ret; 3099 3100 dlci = gsm_dlci_alloc(gsm, 0); 3101 if (dlci == NULL) 3102 return -ENOMEM; 3103 3104 if (gsm->encoding == GSM_BASIC_OPT) 3105 gsm->receive = gsm0_receive; 3106 else 3107 gsm->receive = gsm1_receive; 3108 3109 ret = gsm_register_devices(gsm_tty_driver, gsm->num); 3110 if (ret) 3111 return ret; 3112 3113 gsm->has_devices = true; 3114 gsm->dead = false; /* Tty opens are now permissible */ 3115 return 0; 3116 } 3117 3118 /** 3119 * gsm_free_mux - free up a mux 3120 * @gsm: mux to free 3121 * 3122 * Dispose of allocated resources for a dead mux 3123 */ 3124 static void gsm_free_mux(struct gsm_mux *gsm) 3125 { 3126 int i; 3127 3128 for (i = 0; i < MAX_MUX; i++) { 3129 if (gsm == gsm_mux[i]) { 3130 gsm_mux[i] = NULL; 3131 break; 3132 } 3133 } 3134 mutex_destroy(&gsm->mutex); 3135 kfree(gsm->txframe); 3136 kfree(gsm->buf); 3137 kfree(gsm); 3138 } 3139 3140 /** 3141 * gsm_free_muxr - free up a mux 3142 * @ref: kreference to the mux to free 3143 * 3144 * Dispose of allocated resources for a dead mux 3145 */ 3146 static void gsm_free_muxr(struct kref *ref) 3147 { 3148 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref); 3149 gsm_free_mux(gsm); 3150 } 3151 3152 static inline void mux_get(struct gsm_mux *gsm) 3153 { 3154 unsigned long flags; 3155 3156 spin_lock_irqsave(&gsm_mux_lock, flags); 3157 kref_get(&gsm->ref); 3158 spin_unlock_irqrestore(&gsm_mux_lock, flags); 3159 } 3160 3161 static inline void mux_put(struct gsm_mux *gsm) 3162 { 3163 unsigned long flags; 3164 3165 spin_lock_irqsave(&gsm_mux_lock, flags); 3166 kref_put(&gsm->ref, gsm_free_muxr); 3167 spin_unlock_irqrestore(&gsm_mux_lock, flags); 3168 } 3169 3170 static inline unsigned int mux_num_to_base(struct gsm_mux *gsm) 3171 { 3172 return gsm->num * NUM_DLCI; 3173 } 3174 3175 static inline unsigned int mux_line_to_num(unsigned int line) 3176 { 3177 return line / NUM_DLCI; 3178 } 3179 3180 /** 3181 * gsm_alloc_mux - allocate a mux 3182 * 3183 * Creates a new mux ready for activation. 3184 */ 3185 3186 static struct gsm_mux *gsm_alloc_mux(void) 3187 { 3188 int i; 3189 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL); 3190 if (gsm == NULL) 3191 return NULL; 3192 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL); 3193 if (gsm->buf == NULL) { 3194 kfree(gsm); 3195 return NULL; 3196 } 3197 gsm->txframe = kmalloc(2 * (MAX_MTU + PROT_OVERHEAD - 1), GFP_KERNEL); 3198 if (gsm->txframe == NULL) { 3199 kfree(gsm->buf); 3200 kfree(gsm); 3201 return NULL; 3202 } 3203 spin_lock_init(&gsm->lock); 3204 mutex_init(&gsm->mutex); 3205 kref_init(&gsm->ref); 3206 INIT_LIST_HEAD(&gsm->tx_ctrl_list); 3207 INIT_LIST_HEAD(&gsm->tx_data_list); 3208 timer_setup(&gsm->kick_timer, gsm_kick_timer, 0); 3209 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0); 3210 timer_setup(&gsm->ka_timer, gsm_control_keep_alive, 0); 3211 INIT_WORK(&gsm->tx_work, gsmld_write_task); 3212 init_waitqueue_head(&gsm->event); 3213 spin_lock_init(&gsm->control_lock); 3214 spin_lock_init(&gsm->tx_lock); 3215 3216 gsm->t1 = T1; 3217 gsm->t2 = T2; 3218 gsm->t3 = T3; 3219 gsm->n2 = N2; 3220 gsm->k = K; 3221 gsm->ftype = UIH; 3222 gsm->adaption = 1; 3223 gsm->encoding = GSM_ADV_OPT; 3224 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */ 3225 gsm->mtu = 64; 3226 gsm->dead = true; /* Avoid early tty opens */ 3227 gsm->wait_config = false; /* Disabled */ 3228 gsm->keep_alive = 0; /* Disabled */ 3229 3230 /* Store the instance to the mux array or abort if no space is 3231 * available. 3232 */ 3233 spin_lock(&gsm_mux_lock); 3234 for (i = 0; i < MAX_MUX; i++) { 3235 if (!gsm_mux[i]) { 3236 gsm_mux[i] = gsm; 3237 gsm->num = i; 3238 break; 3239 } 3240 } 3241 spin_unlock(&gsm_mux_lock); 3242 if (i == MAX_MUX) { 3243 mutex_destroy(&gsm->mutex); 3244 kfree(gsm->txframe); 3245 kfree(gsm->buf); 3246 kfree(gsm); 3247 return NULL; 3248 } 3249 3250 return gsm; 3251 } 3252 3253 static void gsm_copy_config_values(struct gsm_mux *gsm, 3254 struct gsm_config *c) 3255 { 3256 memset(c, 0, sizeof(*c)); 3257 c->adaption = gsm->adaption; 3258 c->encapsulation = gsm->encoding; 3259 c->initiator = gsm->initiator; 3260 c->t1 = gsm->t1; 3261 c->t2 = gsm->t2; 3262 c->t3 = gsm->t3; 3263 c->n2 = gsm->n2; 3264 if (gsm->ftype == UIH) 3265 c->i = 1; 3266 else 3267 c->i = 2; 3268 pr_debug("Ftype %d i %d\n", gsm->ftype, c->i); 3269 c->mru = gsm->mru; 3270 c->mtu = gsm->mtu; 3271 c->k = gsm->k; 3272 } 3273 3274 static int gsm_config(struct gsm_mux *gsm, struct gsm_config *c) 3275 { 3276 int ret = 0; 3277 int need_close = 0; 3278 int need_restart = 0; 3279 3280 /* Stuff we don't support yet - UI or I frame transport */ 3281 if (c->adaption != 1 && c->adaption != 2) 3282 return -EOPNOTSUPP; 3283 /* Check the MRU/MTU range looks sane */ 3284 if (c->mru < MIN_MTU || c->mtu < MIN_MTU) 3285 return -EINVAL; 3286 if (c->mru > MAX_MRU || c->mtu > MAX_MTU) 3287 return -EINVAL; 3288 if (c->t3 > MAX_T3) 3289 return -EINVAL; 3290 if (c->n2 > 255) 3291 return -EINVAL; 3292 if (c->encapsulation > 1) /* Basic, advanced, no I */ 3293 return -EINVAL; 3294 if (c->initiator > 1) 3295 return -EINVAL; 3296 if (c->k > MAX_WINDOW_SIZE) 3297 return -EINVAL; 3298 if (c->i == 0 || c->i > 2) /* UIH and UI only */ 3299 return -EINVAL; 3300 /* 3301 * See what is needed for reconfiguration 3302 */ 3303 3304 /* Timing fields */ 3305 if (c->t1 != 0 && c->t1 != gsm->t1) 3306 need_restart = 1; 3307 if (c->t2 != 0 && c->t2 != gsm->t2) 3308 need_restart = 1; 3309 if (c->encapsulation != gsm->encoding) 3310 need_restart = 1; 3311 if (c->adaption != gsm->adaption) 3312 need_restart = 1; 3313 /* Requires care */ 3314 if (c->initiator != gsm->initiator) 3315 need_close = 1; 3316 if (c->mru != gsm->mru) 3317 need_restart = 1; 3318 if (c->mtu != gsm->mtu) 3319 need_restart = 1; 3320 3321 /* 3322 * Close down what is needed, restart and initiate the new 3323 * configuration. On the first time there is no DLCI[0] 3324 * and closing or cleaning up is not necessary. 3325 */ 3326 if (need_close || need_restart) 3327 gsm_cleanup_mux(gsm, true); 3328 3329 gsm->initiator = c->initiator; 3330 gsm->mru = c->mru; 3331 gsm->mtu = c->mtu; 3332 gsm->encoding = c->encapsulation ? GSM_ADV_OPT : GSM_BASIC_OPT; 3333 gsm->adaption = c->adaption; 3334 gsm->n2 = c->n2; 3335 3336 if (c->i == 1) 3337 gsm->ftype = UIH; 3338 else if (c->i == 2) 3339 gsm->ftype = UI; 3340 3341 if (c->t1) 3342 gsm->t1 = c->t1; 3343 if (c->t2) 3344 gsm->t2 = c->t2; 3345 if (c->t3) 3346 gsm->t3 = c->t3; 3347 if (c->k) 3348 gsm->k = c->k; 3349 3350 /* 3351 * FIXME: We need to separate activation/deactivation from adding 3352 * and removing from the mux array 3353 */ 3354 if (gsm->dead) { 3355 ret = gsm_activate_mux(gsm); 3356 if (ret) 3357 return ret; 3358 if (gsm->initiator) 3359 gsm_dlci_begin_open(gsm->dlci[0]); 3360 } 3361 return 0; 3362 } 3363 3364 static void gsm_copy_config_ext_values(struct gsm_mux *gsm, 3365 struct gsm_config_ext *ce) 3366 { 3367 memset(ce, 0, sizeof(*ce)); 3368 ce->wait_config = gsm->wait_config ? 1 : 0; 3369 ce->keep_alive = gsm->keep_alive; 3370 } 3371 3372 static int gsm_config_ext(struct gsm_mux *gsm, struct gsm_config_ext *ce) 3373 { 3374 unsigned int i; 3375 3376 /* 3377 * Check that userspace doesn't put stuff in here to prevent breakages 3378 * in the future. 3379 */ 3380 for (i = 0; i < ARRAY_SIZE(ce->reserved); i++) 3381 if (ce->reserved[i]) 3382 return -EINVAL; 3383 3384 /* 3385 * Setup the new configuration values 3386 */ 3387 gsm->wait_config = ce->wait_config ? true : false; 3388 gsm->keep_alive = ce->keep_alive; 3389 3390 return 0; 3391 } 3392 3393 /** 3394 * gsmld_output - write to link 3395 * @gsm: our mux 3396 * @data: bytes to output 3397 * @len: size 3398 * 3399 * Write a block of data from the GSM mux to the data channel. This 3400 * will eventually be serialized from above but at the moment isn't. 3401 */ 3402 3403 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len) 3404 { 3405 if (tty_write_room(gsm->tty) < len) { 3406 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags); 3407 return -ENOSPC; 3408 } 3409 if (debug & DBG_DATA) 3410 gsm_hex_dump_bytes(__func__, data, len); 3411 return gsm->tty->ops->write(gsm->tty, data, len); 3412 } 3413 3414 3415 /** 3416 * gsmld_write_trigger - schedule ldisc write task 3417 * @gsm: our mux 3418 */ 3419 static void gsmld_write_trigger(struct gsm_mux *gsm) 3420 { 3421 if (!gsm || !gsm->dlci[0] || gsm->dlci[0]->dead) 3422 return; 3423 schedule_work(&gsm->tx_work); 3424 } 3425 3426 3427 /** 3428 * gsmld_write_task - ldisc write task 3429 * @work: our tx write work 3430 * 3431 * Writes out data to the ldisc if possible. We are doing this here to 3432 * avoid dead-locking. This returns if no space or data is left for output. 3433 */ 3434 static void gsmld_write_task(struct work_struct *work) 3435 { 3436 struct gsm_mux *gsm = container_of(work, struct gsm_mux, tx_work); 3437 unsigned long flags; 3438 int i, ret; 3439 3440 /* All outstanding control channel and control messages and one data 3441 * frame is sent. 3442 */ 3443 ret = -ENODEV; 3444 spin_lock_irqsave(&gsm->tx_lock, flags); 3445 if (gsm->tty) 3446 ret = gsm_data_kick(gsm); 3447 spin_unlock_irqrestore(&gsm->tx_lock, flags); 3448 3449 if (ret >= 0) 3450 for (i = 0; i < NUM_DLCI; i++) 3451 if (gsm->dlci[i]) 3452 tty_port_tty_wakeup(&gsm->dlci[i]->port); 3453 } 3454 3455 /** 3456 * gsmld_attach_gsm - mode set up 3457 * @tty: our tty structure 3458 * @gsm: our mux 3459 * 3460 * Set up the MUX for basic mode and commence connecting to the 3461 * modem. Currently called from the line discipline set up but 3462 * will need moving to an ioctl path. 3463 */ 3464 3465 static void gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm) 3466 { 3467 gsm->tty = tty_kref_get(tty); 3468 /* Turn off tty XON/XOFF handling to handle it explicitly. */ 3469 gsm->old_c_iflag = tty->termios.c_iflag; 3470 tty->termios.c_iflag &= (IXON | IXOFF); 3471 } 3472 3473 /** 3474 * gsmld_detach_gsm - stop doing 0710 mux 3475 * @tty: tty attached to the mux 3476 * @gsm: mux 3477 * 3478 * Shutdown and then clean up the resources used by the line discipline 3479 */ 3480 3481 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm) 3482 { 3483 WARN_ON(tty != gsm->tty); 3484 /* Restore tty XON/XOFF handling. */ 3485 gsm->tty->termios.c_iflag = gsm->old_c_iflag; 3486 tty_kref_put(gsm->tty); 3487 gsm->tty = NULL; 3488 } 3489 3490 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp, 3491 const char *fp, int count) 3492 { 3493 struct gsm_mux *gsm = tty->disc_data; 3494 char flags = TTY_NORMAL; 3495 3496 if (debug & DBG_DATA) 3497 gsm_hex_dump_bytes(__func__, cp, count); 3498 3499 for (; count; count--, cp++) { 3500 if (fp) 3501 flags = *fp++; 3502 switch (flags) { 3503 case TTY_NORMAL: 3504 if (gsm->receive) 3505 gsm->receive(gsm, *cp); 3506 break; 3507 case TTY_OVERRUN: 3508 case TTY_BREAK: 3509 case TTY_PARITY: 3510 case TTY_FRAME: 3511 gsm_error(gsm); 3512 break; 3513 default: 3514 WARN_ONCE(1, "%s: unknown flag %d\n", 3515 tty_name(tty), flags); 3516 break; 3517 } 3518 } 3519 /* FASYNC if needed ? */ 3520 /* If clogged call tty_throttle(tty); */ 3521 } 3522 3523 /** 3524 * gsmld_flush_buffer - clean input queue 3525 * @tty: terminal device 3526 * 3527 * Flush the input buffer. Called when the line discipline is 3528 * being closed, when the tty layer wants the buffer flushed (eg 3529 * at hangup). 3530 */ 3531 3532 static void gsmld_flush_buffer(struct tty_struct *tty) 3533 { 3534 } 3535 3536 /** 3537 * gsmld_close - close the ldisc for this tty 3538 * @tty: device 3539 * 3540 * Called from the terminal layer when this line discipline is 3541 * being shut down, either because of a close or becsuse of a 3542 * discipline change. The function will not be called while other 3543 * ldisc methods are in progress. 3544 */ 3545 3546 static void gsmld_close(struct tty_struct *tty) 3547 { 3548 struct gsm_mux *gsm = tty->disc_data; 3549 3550 /* The ldisc locks and closes the port before calling our close. This 3551 * means we have no way to do a proper disconnect. We will not bother 3552 * to do one. 3553 */ 3554 gsm_cleanup_mux(gsm, false); 3555 3556 gsmld_detach_gsm(tty, gsm); 3557 3558 gsmld_flush_buffer(tty); 3559 /* Do other clean up here */ 3560 mux_put(gsm); 3561 } 3562 3563 /** 3564 * gsmld_open - open an ldisc 3565 * @tty: terminal to open 3566 * 3567 * Called when this line discipline is being attached to the 3568 * terminal device. Can sleep. Called serialized so that no 3569 * other events will occur in parallel. No further open will occur 3570 * until a close. 3571 */ 3572 3573 static int gsmld_open(struct tty_struct *tty) 3574 { 3575 struct gsm_mux *gsm; 3576 3577 if (tty->ops->write == NULL) 3578 return -EINVAL; 3579 3580 /* Attach our ldisc data */ 3581 gsm = gsm_alloc_mux(); 3582 if (gsm == NULL) 3583 return -ENOMEM; 3584 3585 tty->disc_data = gsm; 3586 tty->receive_room = 65536; 3587 3588 /* Attach the initial passive connection */ 3589 gsmld_attach_gsm(tty, gsm); 3590 3591 /* The mux will not be activated yet, we wait for correct 3592 * configuration first. 3593 */ 3594 if (gsm->encoding == GSM_BASIC_OPT) 3595 gsm->receive = gsm0_receive; 3596 else 3597 gsm->receive = gsm1_receive; 3598 3599 return 0; 3600 } 3601 3602 /** 3603 * gsmld_write_wakeup - asynchronous I/O notifier 3604 * @tty: tty device 3605 * 3606 * Required for the ptys, serial driver etc. since processes 3607 * that attach themselves to the master and rely on ASYNC 3608 * IO must be woken up 3609 */ 3610 3611 static void gsmld_write_wakeup(struct tty_struct *tty) 3612 { 3613 struct gsm_mux *gsm = tty->disc_data; 3614 3615 /* Queue poll */ 3616 gsmld_write_trigger(gsm); 3617 } 3618 3619 /** 3620 * gsmld_read - read function for tty 3621 * @tty: tty device 3622 * @file: file object 3623 * @buf: userspace buffer pointer 3624 * @nr: size of I/O 3625 * @cookie: unused 3626 * @offset: unused 3627 * 3628 * Perform reads for the line discipline. We are guaranteed that the 3629 * line discipline will not be closed under us but we may get multiple 3630 * parallel readers and must handle this ourselves. We may also get 3631 * a hangup. Always called in user context, may sleep. 3632 * 3633 * This code must be sure never to sleep through a hangup. 3634 */ 3635 3636 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file, 3637 unsigned char *buf, size_t nr, 3638 void **cookie, unsigned long offset) 3639 { 3640 return -EOPNOTSUPP; 3641 } 3642 3643 /** 3644 * gsmld_write - write function for tty 3645 * @tty: tty device 3646 * @file: file object 3647 * @buf: userspace buffer pointer 3648 * @nr: size of I/O 3649 * 3650 * Called when the owner of the device wants to send a frame 3651 * itself (or some other control data). The data is transferred 3652 * as-is and must be properly framed and checksummed as appropriate 3653 * by userspace. Frames are either sent whole or not at all as this 3654 * avoids pain user side. 3655 */ 3656 3657 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file, 3658 const unsigned char *buf, size_t nr) 3659 { 3660 struct gsm_mux *gsm = tty->disc_data; 3661 unsigned long flags; 3662 int space; 3663 int ret; 3664 3665 if (!gsm) 3666 return -ENODEV; 3667 3668 ret = -ENOBUFS; 3669 spin_lock_irqsave(&gsm->tx_lock, flags); 3670 space = tty_write_room(tty); 3671 if (space >= nr) 3672 ret = tty->ops->write(tty, buf, nr); 3673 else 3674 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 3675 spin_unlock_irqrestore(&gsm->tx_lock, flags); 3676 3677 return ret; 3678 } 3679 3680 /** 3681 * gsmld_poll - poll method for N_GSM0710 3682 * @tty: terminal device 3683 * @file: file accessing it 3684 * @wait: poll table 3685 * 3686 * Called when the line discipline is asked to poll() for data or 3687 * for special events. This code is not serialized with respect to 3688 * other events save open/close. 3689 * 3690 * This code must be sure never to sleep through a hangup. 3691 * Called without the kernel lock held - fine 3692 */ 3693 3694 static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file, 3695 poll_table *wait) 3696 { 3697 __poll_t mask = 0; 3698 struct gsm_mux *gsm = tty->disc_data; 3699 3700 poll_wait(file, &tty->read_wait, wait); 3701 poll_wait(file, &tty->write_wait, wait); 3702 3703 if (gsm->dead) 3704 mask |= EPOLLHUP; 3705 if (tty_hung_up_p(file)) 3706 mask |= EPOLLHUP; 3707 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 3708 mask |= EPOLLHUP; 3709 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0) 3710 mask |= EPOLLOUT | EPOLLWRNORM; 3711 return mask; 3712 } 3713 3714 static int gsmld_ioctl(struct tty_struct *tty, unsigned int cmd, 3715 unsigned long arg) 3716 { 3717 struct gsm_config c; 3718 struct gsm_config_ext ce; 3719 struct gsm_dlci_config dc; 3720 struct gsm_mux *gsm = tty->disc_data; 3721 unsigned int base, addr; 3722 struct gsm_dlci *dlci; 3723 3724 switch (cmd) { 3725 case GSMIOC_GETCONF: 3726 gsm_copy_config_values(gsm, &c); 3727 if (copy_to_user((void __user *)arg, &c, sizeof(c))) 3728 return -EFAULT; 3729 return 0; 3730 case GSMIOC_SETCONF: 3731 if (copy_from_user(&c, (void __user *)arg, sizeof(c))) 3732 return -EFAULT; 3733 return gsm_config(gsm, &c); 3734 case GSMIOC_GETFIRST: 3735 base = mux_num_to_base(gsm); 3736 return put_user(base + 1, (__u32 __user *)arg); 3737 case GSMIOC_GETCONF_EXT: 3738 gsm_copy_config_ext_values(gsm, &ce); 3739 if (copy_to_user((void __user *)arg, &ce, sizeof(ce))) 3740 return -EFAULT; 3741 return 0; 3742 case GSMIOC_SETCONF_EXT: 3743 if (copy_from_user(&ce, (void __user *)arg, sizeof(ce))) 3744 return -EFAULT; 3745 return gsm_config_ext(gsm, &ce); 3746 case GSMIOC_GETCONF_DLCI: 3747 if (copy_from_user(&dc, (void __user *)arg, sizeof(dc))) 3748 return -EFAULT; 3749 if (dc.channel == 0 || dc.channel >= NUM_DLCI) 3750 return -EINVAL; 3751 addr = array_index_nospec(dc.channel, NUM_DLCI); 3752 dlci = gsm->dlci[addr]; 3753 if (!dlci) { 3754 dlci = gsm_dlci_alloc(gsm, addr); 3755 if (!dlci) 3756 return -ENOMEM; 3757 } 3758 gsm_dlci_copy_config_values(dlci, &dc); 3759 if (copy_to_user((void __user *)arg, &dc, sizeof(dc))) 3760 return -EFAULT; 3761 return 0; 3762 case GSMIOC_SETCONF_DLCI: 3763 if (copy_from_user(&dc, (void __user *)arg, sizeof(dc))) 3764 return -EFAULT; 3765 if (dc.channel == 0 || dc.channel >= NUM_DLCI) 3766 return -EINVAL; 3767 addr = array_index_nospec(dc.channel, NUM_DLCI); 3768 dlci = gsm->dlci[addr]; 3769 if (!dlci) { 3770 dlci = gsm_dlci_alloc(gsm, addr); 3771 if (!dlci) 3772 return -ENOMEM; 3773 } 3774 return gsm_dlci_config(dlci, &dc, 0); 3775 default: 3776 return n_tty_ioctl_helper(tty, cmd, arg); 3777 } 3778 } 3779 3780 /* 3781 * Network interface 3782 * 3783 */ 3784 3785 static int gsm_mux_net_open(struct net_device *net) 3786 { 3787 pr_debug("%s called\n", __func__); 3788 netif_start_queue(net); 3789 return 0; 3790 } 3791 3792 static int gsm_mux_net_close(struct net_device *net) 3793 { 3794 netif_stop_queue(net); 3795 return 0; 3796 } 3797 3798 static void dlci_net_free(struct gsm_dlci *dlci) 3799 { 3800 if (!dlci->net) { 3801 WARN_ON(1); 3802 return; 3803 } 3804 dlci->adaption = dlci->prev_adaption; 3805 dlci->data = dlci->prev_data; 3806 free_netdev(dlci->net); 3807 dlci->net = NULL; 3808 } 3809 static void net_free(struct kref *ref) 3810 { 3811 struct gsm_mux_net *mux_net; 3812 struct gsm_dlci *dlci; 3813 3814 mux_net = container_of(ref, struct gsm_mux_net, ref); 3815 dlci = mux_net->dlci; 3816 3817 if (dlci->net) { 3818 unregister_netdev(dlci->net); 3819 dlci_net_free(dlci); 3820 } 3821 } 3822 3823 static inline void muxnet_get(struct gsm_mux_net *mux_net) 3824 { 3825 kref_get(&mux_net->ref); 3826 } 3827 3828 static inline void muxnet_put(struct gsm_mux_net *mux_net) 3829 { 3830 kref_put(&mux_net->ref, net_free); 3831 } 3832 3833 static netdev_tx_t gsm_mux_net_start_xmit(struct sk_buff *skb, 3834 struct net_device *net) 3835 { 3836 struct gsm_mux_net *mux_net = netdev_priv(net); 3837 struct gsm_dlci *dlci = mux_net->dlci; 3838 muxnet_get(mux_net); 3839 3840 skb_queue_head(&dlci->skb_list, skb); 3841 net->stats.tx_packets++; 3842 net->stats.tx_bytes += skb->len; 3843 gsm_dlci_data_kick(dlci); 3844 /* And tell the kernel when the last transmit started. */ 3845 netif_trans_update(net); 3846 muxnet_put(mux_net); 3847 return NETDEV_TX_OK; 3848 } 3849 3850 /* called when a packet did not ack after watchdogtimeout */ 3851 static void gsm_mux_net_tx_timeout(struct net_device *net, unsigned int txqueue) 3852 { 3853 /* Tell syslog we are hosed. */ 3854 dev_dbg(&net->dev, "Tx timed out.\n"); 3855 3856 /* Update statistics */ 3857 net->stats.tx_errors++; 3858 } 3859 3860 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci, 3861 const unsigned char *in_buf, int size) 3862 { 3863 struct net_device *net = dlci->net; 3864 struct sk_buff *skb; 3865 struct gsm_mux_net *mux_net = netdev_priv(net); 3866 muxnet_get(mux_net); 3867 3868 /* Allocate an sk_buff */ 3869 skb = dev_alloc_skb(size + NET_IP_ALIGN); 3870 if (!skb) { 3871 /* We got no receive buffer. */ 3872 net->stats.rx_dropped++; 3873 muxnet_put(mux_net); 3874 return; 3875 } 3876 skb_reserve(skb, NET_IP_ALIGN); 3877 skb_put_data(skb, in_buf, size); 3878 3879 skb->dev = net; 3880 skb->protocol = htons(ETH_P_IP); 3881 3882 /* Ship it off to the kernel */ 3883 netif_rx(skb); 3884 3885 /* update out statistics */ 3886 net->stats.rx_packets++; 3887 net->stats.rx_bytes += size; 3888 muxnet_put(mux_net); 3889 return; 3890 } 3891 3892 static void gsm_mux_net_init(struct net_device *net) 3893 { 3894 static const struct net_device_ops gsm_netdev_ops = { 3895 .ndo_open = gsm_mux_net_open, 3896 .ndo_stop = gsm_mux_net_close, 3897 .ndo_start_xmit = gsm_mux_net_start_xmit, 3898 .ndo_tx_timeout = gsm_mux_net_tx_timeout, 3899 }; 3900 3901 net->netdev_ops = &gsm_netdev_ops; 3902 3903 /* fill in the other fields */ 3904 net->watchdog_timeo = GSM_NET_TX_TIMEOUT; 3905 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 3906 net->type = ARPHRD_NONE; 3907 net->tx_queue_len = 10; 3908 } 3909 3910 3911 /* caller holds the dlci mutex */ 3912 static void gsm_destroy_network(struct gsm_dlci *dlci) 3913 { 3914 struct gsm_mux_net *mux_net; 3915 3916 pr_debug("destroy network interface\n"); 3917 if (!dlci->net) 3918 return; 3919 mux_net = netdev_priv(dlci->net); 3920 muxnet_put(mux_net); 3921 } 3922 3923 3924 /* caller holds the dlci mutex */ 3925 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc) 3926 { 3927 char *netname; 3928 int retval = 0; 3929 struct net_device *net; 3930 struct gsm_mux_net *mux_net; 3931 3932 if (!capable(CAP_NET_ADMIN)) 3933 return -EPERM; 3934 3935 /* Already in a non tty mode */ 3936 if (dlci->adaption > 2) 3937 return -EBUSY; 3938 3939 if (nc->protocol != htons(ETH_P_IP)) 3940 return -EPROTONOSUPPORT; 3941 3942 if (nc->adaption != 3 && nc->adaption != 4) 3943 return -EPROTONOSUPPORT; 3944 3945 pr_debug("create network interface\n"); 3946 3947 netname = "gsm%d"; 3948 if (nc->if_name[0] != '\0') 3949 netname = nc->if_name; 3950 net = alloc_netdev(sizeof(struct gsm_mux_net), netname, 3951 NET_NAME_UNKNOWN, gsm_mux_net_init); 3952 if (!net) { 3953 pr_err("alloc_netdev failed\n"); 3954 return -ENOMEM; 3955 } 3956 net->mtu = dlci->mtu; 3957 net->min_mtu = MIN_MTU; 3958 net->max_mtu = dlci->mtu; 3959 mux_net = netdev_priv(net); 3960 mux_net->dlci = dlci; 3961 kref_init(&mux_net->ref); 3962 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */ 3963 3964 /* reconfigure dlci for network */ 3965 dlci->prev_adaption = dlci->adaption; 3966 dlci->prev_data = dlci->data; 3967 dlci->adaption = nc->adaption; 3968 dlci->data = gsm_mux_rx_netchar; 3969 dlci->net = net; 3970 3971 pr_debug("register netdev\n"); 3972 retval = register_netdev(net); 3973 if (retval) { 3974 pr_err("network register fail %d\n", retval); 3975 dlci_net_free(dlci); 3976 return retval; 3977 } 3978 return net->ifindex; /* return network index */ 3979 } 3980 3981 /* Line discipline for real tty */ 3982 static struct tty_ldisc_ops tty_ldisc_packet = { 3983 .owner = THIS_MODULE, 3984 .num = N_GSM0710, 3985 .name = "n_gsm", 3986 .open = gsmld_open, 3987 .close = gsmld_close, 3988 .flush_buffer = gsmld_flush_buffer, 3989 .read = gsmld_read, 3990 .write = gsmld_write, 3991 .ioctl = gsmld_ioctl, 3992 .poll = gsmld_poll, 3993 .receive_buf = gsmld_receive_buf, 3994 .write_wakeup = gsmld_write_wakeup 3995 }; 3996 3997 /* 3998 * Virtual tty side 3999 */ 4000 4001 /** 4002 * gsm_modem_upd_via_data - send modem bits via convergence layer 4003 * @dlci: channel 4004 * @brk: break signal 4005 * 4006 * Send an empty frame to signal mobile state changes and to transmit the 4007 * break signal for adaption 2. 4008 */ 4009 4010 static void gsm_modem_upd_via_data(struct gsm_dlci *dlci, u8 brk) 4011 { 4012 struct gsm_mux *gsm = dlci->gsm; 4013 unsigned long flags; 4014 4015 if (dlci->state != DLCI_OPEN || dlci->adaption != 2) 4016 return; 4017 4018 spin_lock_irqsave(&gsm->tx_lock, flags); 4019 gsm_dlci_modem_output(gsm, dlci, brk); 4020 spin_unlock_irqrestore(&gsm->tx_lock, flags); 4021 } 4022 4023 /** 4024 * gsm_modem_upd_via_msc - send modem bits via control frame 4025 * @dlci: channel 4026 * @brk: break signal 4027 */ 4028 4029 static int gsm_modem_upd_via_msc(struct gsm_dlci *dlci, u8 brk) 4030 { 4031 u8 modembits[3]; 4032 struct gsm_control *ctrl; 4033 int len = 2; 4034 4035 if (dlci->gsm->encoding != GSM_BASIC_OPT) 4036 return 0; 4037 4038 modembits[0] = (dlci->addr << 2) | 2 | EA; /* DLCI, Valid, EA */ 4039 if (!brk) { 4040 modembits[1] = (gsm_encode_modem(dlci) << 1) | EA; 4041 } else { 4042 modembits[1] = gsm_encode_modem(dlci) << 1; 4043 modembits[2] = (brk << 4) | 2 | EA; /* Length, Break, EA */ 4044 len++; 4045 } 4046 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len); 4047 if (ctrl == NULL) 4048 return -ENOMEM; 4049 return gsm_control_wait(dlci->gsm, ctrl); 4050 } 4051 4052 /** 4053 * gsm_modem_update - send modem status line state 4054 * @dlci: channel 4055 * @brk: break signal 4056 */ 4057 4058 static int gsm_modem_update(struct gsm_dlci *dlci, u8 brk) 4059 { 4060 if (dlci->adaption == 2) { 4061 /* Send convergence layer type 2 empty data frame. */ 4062 gsm_modem_upd_via_data(dlci, brk); 4063 return 0; 4064 } else if (dlci->gsm->encoding == GSM_BASIC_OPT) { 4065 /* Send as MSC control message. */ 4066 return gsm_modem_upd_via_msc(dlci, brk); 4067 } 4068 4069 /* Modem status lines are not supported. */ 4070 return -EPROTONOSUPPORT; 4071 } 4072 4073 /** 4074 * gsm_wait_modem_change - wait for modem status line change 4075 * @dlci: channel 4076 * @mask: modem status line bits 4077 * 4078 * The function returns if: 4079 * - any given modem status line bit changed 4080 * - the wait event function got interrupted (e.g. by a signal) 4081 * - the underlying DLCI was closed 4082 * - the underlying ldisc device was removed 4083 */ 4084 static int gsm_wait_modem_change(struct gsm_dlci *dlci, u32 mask) 4085 { 4086 struct gsm_mux *gsm = dlci->gsm; 4087 u32 old = dlci->modem_rx; 4088 int ret; 4089 4090 ret = wait_event_interruptible(gsm->event, gsm->dead || 4091 dlci->state != DLCI_OPEN || 4092 (old ^ dlci->modem_rx) & mask); 4093 if (gsm->dead) 4094 return -ENODEV; 4095 if (dlci->state != DLCI_OPEN) 4096 return -EL2NSYNC; 4097 return ret; 4098 } 4099 4100 static bool gsm_carrier_raised(struct tty_port *port) 4101 { 4102 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 4103 struct gsm_mux *gsm = dlci->gsm; 4104 4105 /* Not yet open so no carrier info */ 4106 if (dlci->state != DLCI_OPEN) 4107 return false; 4108 if (debug & DBG_CD_ON) 4109 return true; 4110 4111 /* 4112 * Basic mode with control channel in ADM mode may not respond 4113 * to CMD_MSC at all and modem_rx is empty. 4114 */ 4115 if (gsm->encoding == GSM_BASIC_OPT && 4116 gsm->dlci[0]->mode == DLCI_MODE_ADM && !dlci->modem_rx) 4117 return true; 4118 4119 return dlci->modem_rx & TIOCM_CD; 4120 } 4121 4122 static void gsm_dtr_rts(struct tty_port *port, bool active) 4123 { 4124 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 4125 unsigned int modem_tx = dlci->modem_tx; 4126 if (active) 4127 modem_tx |= TIOCM_DTR | TIOCM_RTS; 4128 else 4129 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS); 4130 if (modem_tx != dlci->modem_tx) { 4131 dlci->modem_tx = modem_tx; 4132 gsm_modem_update(dlci, 0); 4133 } 4134 } 4135 4136 static const struct tty_port_operations gsm_port_ops = { 4137 .carrier_raised = gsm_carrier_raised, 4138 .dtr_rts = gsm_dtr_rts, 4139 .destruct = gsm_dlci_free, 4140 }; 4141 4142 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty) 4143 { 4144 struct gsm_mux *gsm; 4145 struct gsm_dlci *dlci; 4146 unsigned int line = tty->index; 4147 unsigned int mux = mux_line_to_num(line); 4148 bool alloc = false; 4149 int ret; 4150 4151 line = line & 0x3F; 4152 4153 if (mux >= MAX_MUX) 4154 return -ENXIO; 4155 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */ 4156 if (gsm_mux[mux] == NULL) 4157 return -EUNATCH; 4158 if (line == 0 || line > 61) /* 62/63 reserved */ 4159 return -ECHRNG; 4160 gsm = gsm_mux[mux]; 4161 if (gsm->dead) 4162 return -EL2HLT; 4163 /* If DLCI 0 is not yet fully open return an error. 4164 This is ok from a locking 4165 perspective as we don't have to worry about this 4166 if DLCI0 is lost */ 4167 mutex_lock(&gsm->mutex); 4168 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) { 4169 mutex_unlock(&gsm->mutex); 4170 return -EL2NSYNC; 4171 } 4172 dlci = gsm->dlci[line]; 4173 if (dlci == NULL) { 4174 alloc = true; 4175 dlci = gsm_dlci_alloc(gsm, line); 4176 } 4177 if (dlci == NULL) { 4178 mutex_unlock(&gsm->mutex); 4179 return -ENOMEM; 4180 } 4181 ret = tty_port_install(&dlci->port, driver, tty); 4182 if (ret) { 4183 if (alloc) 4184 dlci_put(dlci); 4185 mutex_unlock(&gsm->mutex); 4186 return ret; 4187 } 4188 4189 dlci_get(dlci); 4190 dlci_get(gsm->dlci[0]); 4191 mux_get(gsm); 4192 tty->driver_data = dlci; 4193 mutex_unlock(&gsm->mutex); 4194 4195 return 0; 4196 } 4197 4198 static int gsmtty_open(struct tty_struct *tty, struct file *filp) 4199 { 4200 struct gsm_dlci *dlci = tty->driver_data; 4201 struct tty_port *port = &dlci->port; 4202 4203 port->count++; 4204 tty_port_tty_set(port, tty); 4205 4206 dlci->modem_rx = 0; 4207 /* We could in theory open and close before we wait - eg if we get 4208 a DM straight back. This is ok as that will have caused a hangup */ 4209 tty_port_set_initialized(port, true); 4210 /* Start sending off SABM messages */ 4211 if (!dlci->gsm->wait_config) { 4212 /* Start sending off SABM messages */ 4213 if (dlci->gsm->initiator) 4214 gsm_dlci_begin_open(dlci); 4215 else 4216 gsm_dlci_set_opening(dlci); 4217 } else { 4218 gsm_dlci_set_wait_config(dlci); 4219 } 4220 /* And wait for virtual carrier */ 4221 return tty_port_block_til_ready(port, tty, filp); 4222 } 4223 4224 static void gsmtty_close(struct tty_struct *tty, struct file *filp) 4225 { 4226 struct gsm_dlci *dlci = tty->driver_data; 4227 4228 if (dlci == NULL) 4229 return; 4230 if (dlci->state == DLCI_CLOSED) 4231 return; 4232 mutex_lock(&dlci->mutex); 4233 gsm_destroy_network(dlci); 4234 mutex_unlock(&dlci->mutex); 4235 if (tty_port_close_start(&dlci->port, tty, filp) == 0) 4236 return; 4237 gsm_dlci_begin_close(dlci); 4238 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty)) 4239 tty_port_lower_dtr_rts(&dlci->port); 4240 tty_port_close_end(&dlci->port, tty); 4241 tty_port_tty_set(&dlci->port, NULL); 4242 return; 4243 } 4244 4245 static void gsmtty_hangup(struct tty_struct *tty) 4246 { 4247 struct gsm_dlci *dlci = tty->driver_data; 4248 if (dlci->state == DLCI_CLOSED) 4249 return; 4250 tty_port_hangup(&dlci->port); 4251 gsm_dlci_begin_close(dlci); 4252 } 4253 4254 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf, 4255 int len) 4256 { 4257 int sent; 4258 struct gsm_dlci *dlci = tty->driver_data; 4259 if (dlci->state == DLCI_CLOSED) 4260 return -EINVAL; 4261 /* Stuff the bytes into the fifo queue */ 4262 sent = kfifo_in_locked(&dlci->fifo, buf, len, &dlci->lock); 4263 /* Need to kick the channel */ 4264 gsm_dlci_data_kick(dlci); 4265 return sent; 4266 } 4267 4268 static unsigned int gsmtty_write_room(struct tty_struct *tty) 4269 { 4270 struct gsm_dlci *dlci = tty->driver_data; 4271 if (dlci->state == DLCI_CLOSED) 4272 return 0; 4273 return kfifo_avail(&dlci->fifo); 4274 } 4275 4276 static unsigned int gsmtty_chars_in_buffer(struct tty_struct *tty) 4277 { 4278 struct gsm_dlci *dlci = tty->driver_data; 4279 if (dlci->state == DLCI_CLOSED) 4280 return 0; 4281 return kfifo_len(&dlci->fifo); 4282 } 4283 4284 static void gsmtty_flush_buffer(struct tty_struct *tty) 4285 { 4286 struct gsm_dlci *dlci = tty->driver_data; 4287 unsigned long flags; 4288 4289 if (dlci->state == DLCI_CLOSED) 4290 return; 4291 /* Caution needed: If we implement reliable transport classes 4292 then the data being transmitted can't simply be junked once 4293 it has first hit the stack. Until then we can just blow it 4294 away */ 4295 spin_lock_irqsave(&dlci->lock, flags); 4296 kfifo_reset(&dlci->fifo); 4297 spin_unlock_irqrestore(&dlci->lock, flags); 4298 /* Need to unhook this DLCI from the transmit queue logic */ 4299 } 4300 4301 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout) 4302 { 4303 /* The FIFO handles the queue so the kernel will do the right 4304 thing waiting on chars_in_buffer before calling us. No work 4305 to do here */ 4306 } 4307 4308 static int gsmtty_tiocmget(struct tty_struct *tty) 4309 { 4310 struct gsm_dlci *dlci = tty->driver_data; 4311 if (dlci->state == DLCI_CLOSED) 4312 return -EINVAL; 4313 return dlci->modem_rx; 4314 } 4315 4316 static int gsmtty_tiocmset(struct tty_struct *tty, 4317 unsigned int set, unsigned int clear) 4318 { 4319 struct gsm_dlci *dlci = tty->driver_data; 4320 unsigned int modem_tx = dlci->modem_tx; 4321 4322 if (dlci->state == DLCI_CLOSED) 4323 return -EINVAL; 4324 modem_tx &= ~clear; 4325 modem_tx |= set; 4326 4327 if (modem_tx != dlci->modem_tx) { 4328 dlci->modem_tx = modem_tx; 4329 return gsm_modem_update(dlci, 0); 4330 } 4331 return 0; 4332 } 4333 4334 4335 static int gsmtty_ioctl(struct tty_struct *tty, 4336 unsigned int cmd, unsigned long arg) 4337 { 4338 struct gsm_dlci *dlci = tty->driver_data; 4339 struct gsm_netconfig nc; 4340 struct gsm_dlci_config dc; 4341 int index; 4342 4343 if (dlci->state == DLCI_CLOSED) 4344 return -EINVAL; 4345 switch (cmd) { 4346 case GSMIOC_ENABLE_NET: 4347 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc))) 4348 return -EFAULT; 4349 nc.if_name[IFNAMSIZ-1] = '\0'; 4350 /* return net interface index or error code */ 4351 mutex_lock(&dlci->mutex); 4352 index = gsm_create_network(dlci, &nc); 4353 mutex_unlock(&dlci->mutex); 4354 if (copy_to_user((void __user *)arg, &nc, sizeof(nc))) 4355 return -EFAULT; 4356 return index; 4357 case GSMIOC_DISABLE_NET: 4358 if (!capable(CAP_NET_ADMIN)) 4359 return -EPERM; 4360 mutex_lock(&dlci->mutex); 4361 gsm_destroy_network(dlci); 4362 mutex_unlock(&dlci->mutex); 4363 return 0; 4364 case GSMIOC_GETCONF_DLCI: 4365 if (copy_from_user(&dc, (void __user *)arg, sizeof(dc))) 4366 return -EFAULT; 4367 if (dc.channel != dlci->addr) 4368 return -EPERM; 4369 gsm_dlci_copy_config_values(dlci, &dc); 4370 if (copy_to_user((void __user *)arg, &dc, sizeof(dc))) 4371 return -EFAULT; 4372 return 0; 4373 case GSMIOC_SETCONF_DLCI: 4374 if (copy_from_user(&dc, (void __user *)arg, sizeof(dc))) 4375 return -EFAULT; 4376 if (dc.channel >= NUM_DLCI) 4377 return -EINVAL; 4378 if (dc.channel != 0 && dc.channel != dlci->addr) 4379 return -EPERM; 4380 return gsm_dlci_config(dlci, &dc, 1); 4381 case TIOCMIWAIT: 4382 return gsm_wait_modem_change(dlci, (u32)arg); 4383 default: 4384 return -ENOIOCTLCMD; 4385 } 4386 } 4387 4388 static void gsmtty_set_termios(struct tty_struct *tty, 4389 const struct ktermios *old) 4390 { 4391 struct gsm_dlci *dlci = tty->driver_data; 4392 if (dlci->state == DLCI_CLOSED) 4393 return; 4394 /* For the moment its fixed. In actual fact the speed information 4395 for the virtual channel can be propogated in both directions by 4396 the RPN control message. This however rapidly gets nasty as we 4397 then have to remap modem signals each way according to whether 4398 our virtual cable is null modem etc .. */ 4399 tty_termios_copy_hw(&tty->termios, old); 4400 } 4401 4402 static void gsmtty_throttle(struct tty_struct *tty) 4403 { 4404 struct gsm_dlci *dlci = tty->driver_data; 4405 if (dlci->state == DLCI_CLOSED) 4406 return; 4407 if (C_CRTSCTS(tty)) 4408 dlci->modem_tx &= ~TIOCM_RTS; 4409 dlci->throttled = true; 4410 /* Send an MSC with RTS cleared */ 4411 gsm_modem_update(dlci, 0); 4412 } 4413 4414 static void gsmtty_unthrottle(struct tty_struct *tty) 4415 { 4416 struct gsm_dlci *dlci = tty->driver_data; 4417 if (dlci->state == DLCI_CLOSED) 4418 return; 4419 if (C_CRTSCTS(tty)) 4420 dlci->modem_tx |= TIOCM_RTS; 4421 dlci->throttled = false; 4422 /* Send an MSC with RTS set */ 4423 gsm_modem_update(dlci, 0); 4424 } 4425 4426 static int gsmtty_break_ctl(struct tty_struct *tty, int state) 4427 { 4428 struct gsm_dlci *dlci = tty->driver_data; 4429 int encode = 0; /* Off */ 4430 if (dlci->state == DLCI_CLOSED) 4431 return -EINVAL; 4432 4433 if (state == -1) /* "On indefinitely" - we can't encode this 4434 properly */ 4435 encode = 0x0F; 4436 else if (state > 0) { 4437 encode = state / 200; /* mS to encoding */ 4438 if (encode > 0x0F) 4439 encode = 0x0F; /* Best effort */ 4440 } 4441 return gsm_modem_update(dlci, encode); 4442 } 4443 4444 static void gsmtty_cleanup(struct tty_struct *tty) 4445 { 4446 struct gsm_dlci *dlci = tty->driver_data; 4447 struct gsm_mux *gsm = dlci->gsm; 4448 4449 dlci_put(dlci); 4450 dlci_put(gsm->dlci[0]); 4451 mux_put(gsm); 4452 } 4453 4454 /* Virtual ttys for the demux */ 4455 static const struct tty_operations gsmtty_ops = { 4456 .install = gsmtty_install, 4457 .open = gsmtty_open, 4458 .close = gsmtty_close, 4459 .write = gsmtty_write, 4460 .write_room = gsmtty_write_room, 4461 .chars_in_buffer = gsmtty_chars_in_buffer, 4462 .flush_buffer = gsmtty_flush_buffer, 4463 .ioctl = gsmtty_ioctl, 4464 .throttle = gsmtty_throttle, 4465 .unthrottle = gsmtty_unthrottle, 4466 .set_termios = gsmtty_set_termios, 4467 .hangup = gsmtty_hangup, 4468 .wait_until_sent = gsmtty_wait_until_sent, 4469 .tiocmget = gsmtty_tiocmget, 4470 .tiocmset = gsmtty_tiocmset, 4471 .break_ctl = gsmtty_break_ctl, 4472 .cleanup = gsmtty_cleanup, 4473 }; 4474 4475 4476 4477 static int __init gsm_init(void) 4478 { 4479 /* Fill in our line protocol discipline, and register it */ 4480 int status = tty_register_ldisc(&tty_ldisc_packet); 4481 if (status != 0) { 4482 pr_err("n_gsm: can't register line discipline (err = %d)\n", 4483 status); 4484 return status; 4485 } 4486 4487 gsm_tty_driver = tty_alloc_driver(GSM_TTY_MINORS, TTY_DRIVER_REAL_RAW | 4488 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK); 4489 if (IS_ERR(gsm_tty_driver)) { 4490 pr_err("gsm_init: tty allocation failed.\n"); 4491 status = PTR_ERR(gsm_tty_driver); 4492 goto err_unreg_ldisc; 4493 } 4494 gsm_tty_driver->driver_name = "gsmtty"; 4495 gsm_tty_driver->name = "gsmtty"; 4496 gsm_tty_driver->major = 0; /* Dynamic */ 4497 gsm_tty_driver->minor_start = 0; 4498 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 4499 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 4500 gsm_tty_driver->init_termios = tty_std_termios; 4501 /* Fixme */ 4502 gsm_tty_driver->init_termios.c_lflag &= ~ECHO; 4503 tty_set_operations(gsm_tty_driver, &gsmtty_ops); 4504 4505 if (tty_register_driver(gsm_tty_driver)) { 4506 pr_err("gsm_init: tty registration failed.\n"); 4507 status = -EBUSY; 4508 goto err_put_driver; 4509 } 4510 pr_debug("gsm_init: loaded as %d,%d.\n", 4511 gsm_tty_driver->major, gsm_tty_driver->minor_start); 4512 return 0; 4513 err_put_driver: 4514 tty_driver_kref_put(gsm_tty_driver); 4515 err_unreg_ldisc: 4516 tty_unregister_ldisc(&tty_ldisc_packet); 4517 return status; 4518 } 4519 4520 static void __exit gsm_exit(void) 4521 { 4522 tty_unregister_ldisc(&tty_ldisc_packet); 4523 tty_unregister_driver(gsm_tty_driver); 4524 tty_driver_kref_put(gsm_tty_driver); 4525 } 4526 4527 module_init(gsm_init); 4528 module_exit(gsm_exit); 4529 4530 4531 MODULE_LICENSE("GPL"); 4532 MODULE_ALIAS_LDISC(N_GSM0710); 4533