drivers/char/n_gsm.c

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