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
 908         while (i < NUM_DLCI) {
 909                 struct gsm_dlci *dlci;
 910
 911                 if (gsm->tx_bytes > TX_THRESH_HI)
 912                         break;
 913                 dlci = gsm->dlci[i];
 914                 if (dlci == NULL || dlci->constipated) {
 915                         i++;
 916                         continue;
 917                 }
 918                 if (dlci->adaption < 3)
 919                         len = gsm_dlci_data_output(gsm, dlci);
 920                 else
 921                         len = gsm_dlci_data_output_framed(gsm, dlci);
 922                 if (len < 0)
 923                         return;
 924                 /* DLCI empty - try the next */
 925                 if (len == 0)
 926                         i++;
 927         }
 928 }
 929
 930 /**
 931  *      gsm_dlci_data_kick      -       transmit if possible
 932  *      @dlci: DLCI to kick
 933  *
 934  *      Transmit data from this DLCI if the queue is empty. We can't rely on
 935  *      a tty wakeup except when we filled the pipe so we need to fire off
 936  *      new data ourselves in other cases.
 937  */
 938
 939 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
 940 {
 941         unsigned long flags;
 942
 943         spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
 944         /* If we have nothing running then we need to fire up */
 945         if (dlci->gsm->tx_bytes == 0)
 946                 gsm_dlci_data_output(dlci->gsm, dlci);
 947         else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
 948                 gsm_dlci_data_sweep(dlci->gsm);
 949         spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
 950 }
 951
 952 /*
 953  *      Control message processing
 954  */
 955
 956
 957 /**
 958  *      gsm_control_reply       -       send a response frame to a control
 959  *      @gsm: gsm channel
 960  *      @cmd: the command to use
 961  *      @data: data to follow encoded info
 962  *      @dlen: length of data
 963  *
 964  *      Encode up and queue a UI/UIH frame containing our response.
 965  */
 966
 967 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
 968                                         int dlen)
 969 {
 970         struct gsm_msg *msg;
 971         msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
 972         msg->data[0] = (cmd & 0xFE) << 1 | EA;  /* Clear C/R */
 973         msg->data[1] = (dlen << 1) | EA;
 974         memcpy(msg->data + 2, data, dlen);
 975         gsm_data_queue(gsm->dlci[0], msg);
 976 }
 977
 978 /**
 979  *      gsm_process_modem       -       process received modem status
 980  *      @tty: virtual tty bound to the DLCI
 981  *      @dlci: DLCI to affect
 982  *      @modem: modem bits (full EA)
 983  *
 984  *      Used when a modem control message or line state inline in adaption
 985  *      layer 2 is processed. Sort out the local modem state and throttles
 986  */
 987
 988 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
 989                                                         u32 modem)
 990 {
 991         int  mlines = 0;
 992         u8 brk = modem >> 6;
 993
 994         /* Flow control/ready to communicate */
 995         if (modem & MDM_FC) {
 996                 /* Need to throttle our output on this device */
 997                 dlci->constipated = 1;
 998         }
 999         if (modem & MDM_RTC) {
1000                 mlines |= TIOCM_DSR | TIOCM_DTR;
1001                 dlci->constipated = 0;
1002                 gsm_dlci_data_kick(dlci);
1003         }
1004         /* Map modem bits */
1005         if (modem & MDM_RTR)
1006                 mlines |= TIOCM_RTS | TIOCM_CTS;
1007         if (modem & MDM_IC)
1008                 mlines |= TIOCM_RI;
1009         if (modem & MDM_DV)
1010                 mlines |= TIOCM_CD;
1011
1012         /* Carrier drop -> hangup */
1013         if (tty) {
1014                 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1015                         if (!(tty->termios->c_cflag & CLOCAL))
1016                                 tty_hangup(tty);
1017                 if (brk & 0x01)
1018                         tty_insert_flip_char(tty, 0, TTY_BREAK);
1019         }
1020         dlci->modem_rx = mlines;
1021 }
1022
1023 /**
1024  *      gsm_control_modem       -       modem status received
1025  *      @gsm: GSM channel
1026  *      @data: data following command
1027  *      @clen: command length
1028  *
1029  *      We have received a modem status control message. This is used by
1030  *      the GSM mux protocol to pass virtual modem line status and optionally
1031  *      to indicate break signals. Unpack it, convert to Linux representation
1032  *      and if need be stuff a break message down the tty.
1033  */
1034
1035 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1036 {
1037         unsigned int addr = 0;
1038         unsigned int modem = 0;
1039         struct gsm_dlci *dlci;
1040         int len = clen;
1041         u8 *dp = data;
1042         struct tty_struct *tty;
1043
1044         while (gsm_read_ea(&addr, *dp++) == 0) {
1045                 len--;
1046                 if (len == 0)
1047                         return;
1048         }
1049         /* Must be at least one byte following the EA */
1050         len--;
1051         if (len <= 0)
1052                 return;
1053
1054         addr >>= 1;
1055         /* Closed port, or invalid ? */
1056         if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1057                 return;
1058         dlci = gsm->dlci[addr];
1059
1060         while (gsm_read_ea(&modem, *dp++) == 0) {
1061                 len--;
1062                 if (len == 0)
1063                         return;
1064         }
1065         tty = tty_port_tty_get(&dlci->port);
1066         gsm_process_modem(tty, dlci, modem);
1067         if (tty) {
1068                 tty_wakeup(tty);
1069                 tty_kref_put(tty);
1070         }
1071         gsm_control_reply(gsm, CMD_MSC, data, clen);
1072 }
1073
1074 /**
1075  *      gsm_control_rls         -       remote line status
1076  *      @gsm: GSM channel
1077  *      @data: data bytes
1078  *      @clen: data length
1079  *
1080  *      The modem sends us a two byte message on the control channel whenever
1081  *      it wishes to send us an error state from the virtual link. Stuff
1082  *      this into the uplink tty if present
1083  */
1084
1085 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1086 {
1087         struct tty_struct *tty;
1088         unsigned int addr = 0 ;
1089         u8 bits;
1090         int len = clen;
1091         u8 *dp = data;
1092
1093         while (gsm_read_ea(&addr, *dp++) == 0) {
1094                 len--;
1095                 if (len == 0)
1096                         return;
1097         }
1098         /* Must be at least one byte following ea */
1099         len--;
1100         if (len <= 0)
1101                 return;
1102         addr >>= 1;
1103         /* Closed port, or invalid ? */
1104         if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1105                 return;
1106         /* No error ? */
1107         bits = *dp;
1108         if ((bits & 1) == 0)
1109                 return;
1110         /* See if we have an uplink tty */
1111         tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1112
1113         if (tty) {
1114                 if (bits & 2)
1115                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1116                 if (bits & 4)
1117                         tty_insert_flip_char(tty, 0, TTY_PARITY);
1118                 if (bits & 8)
1119                         tty_insert_flip_char(tty, 0, TTY_FRAME);
1120                 tty_flip_buffer_push(tty);
1121                 tty_kref_put(tty);
1122         }
1123         gsm_control_reply(gsm, CMD_RLS, data, clen);
1124 }
1125
1126 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1127
1128 /**
1129  *      gsm_control_message     -       DLCI 0 control processing
1130  *      @gsm: our GSM mux
1131  *      @command:  the command EA
1132  *      @data: data beyond the command/length EAs
1133  *      @clen: length
1134  *
1135  *      Input processor for control messages from the other end of the link.
1136  *      Processes the incoming request and queues a response frame or an
1137  *      NSC response if not supported
1138  */
1139
1140 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1141                                                         u8 *data, int clen)
1142 {
1143         u8 buf[1];
1144         switch (command) {
1145         case CMD_CLD: {
1146                 struct gsm_dlci *dlci = gsm->dlci[0];
1147                 /* Modem wishes to close down */
1148                 if (dlci) {
1149                         dlci->dead = 1;
1150                         gsm->dead = 1;
1151                         gsm_dlci_begin_close(dlci);
1152                 }
1153                 }
1154                 break;
1155         case CMD_TEST:
1156                 /* Modem wishes to test, reply with the data */
1157                 gsm_control_reply(gsm, CMD_TEST, data, clen);
1158                 break;
1159         case CMD_FCON:
1160                 /* Modem wants us to STFU */
1161                 gsm->constipated = 1;
1162                 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1163                 break;
1164         case CMD_FCOFF:
1165                 /* Modem can accept data again */
1166                 gsm->constipated = 0;
1167                 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1168                 /* Kick the link in case it is idling */
1169                 gsm_data_kick(gsm);
1170                 break;
1171         case CMD_MSC:
1172                 /* Out of band modem line change indicator for a DLCI */
1173                 gsm_control_modem(gsm, data, clen);
1174                 break;
1175         case CMD_RLS:
1176                 /* Out of band error reception for a DLCI */
1177                 gsm_control_rls(gsm, data, clen);
1178                 break;
1179         case CMD_PSC:
1180                 /* Modem wishes to enter power saving state */
1181                 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1182                 break;
1183                 /* Optional unsupported commands */
1184         case CMD_PN:    /* Parameter negotiation */
1185         case CMD_RPN:   /* Remote port negotation */
1186         case CMD_SNC:   /* Service negotation command */
1187         default:
1188                 /* Reply to bad commands with an NSC */
1189                 buf[0] = command;
1190                 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1191                 break;
1192         }
1193 }
1194
1195 /**
1196  *      gsm_control_response    -       process a response to our control
1197  *      @gsm: our GSM mux
1198  *      @command: the command (response) EA
1199  *      @data: data beyond the command/length EA
1200  *      @clen: length
1201  *
1202  *      Process a response to an outstanding command. We only allow a single
1203  *      control message in flight so this is fairly easy. All the clean up
1204  *      is done by the caller, we just update the fields, flag it as done
1205  *      and return
1206  */
1207
1208 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1209                                                         u8 *data, int clen)
1210 {
1211         struct gsm_control *ctrl;
1212         unsigned long flags;
1213
1214         spin_lock_irqsave(&gsm->control_lock, flags);
1215
1216         ctrl = gsm->pending_cmd;
1217         /* Does the reply match our command */
1218         command |= 1;
1219         if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1220                 /* Our command was replied to, kill the retry timer */
1221                 del_timer(&gsm->t2_timer);
1222                 gsm->pending_cmd = NULL;
1223                 /* Rejected by the other end */
1224                 if (command == CMD_NSC)
1225                         ctrl->error = -EOPNOTSUPP;
1226                 ctrl->done = 1;
1227                 wake_up(&gsm->event);
1228         }
1229         spin_unlock_irqrestore(&gsm->control_lock, flags);
1230 }
1231
1232 /**
1233  *      gsm_control_transmit    -       send control packet
1234  *      @gsm: gsm mux
1235  *      @ctrl: frame to send
1236  *
1237  *      Send out a pending control command (called under control lock)
1238  */
1239
1240 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1241 {
1242         struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1,
1243                                                         gsm->ftype|PF);
1244         if (msg == NULL)
1245                 return;
1246         msg->data[0] = (ctrl->cmd << 1) | 2 | EA;       /* command */
1247         memcpy(msg->data + 1, ctrl->data, ctrl->len);
1248         gsm_data_queue(gsm->dlci[0], msg);
1249 }
1250
1251 /**
1252  *      gsm_control_retransmit  -       retransmit a control frame
1253  *      @data: pointer to our gsm object
1254  *
1255  *      Called off the T2 timer expiry in order to retransmit control frames
1256  *      that have been lost in the system somewhere. The control_lock protects
1257  *      us from colliding with another sender or a receive completion event.
1258  *      In that situation the timer may still occur in a small window but
1259  *      gsm->pending_cmd will be NULL and we just let the timer expire.
1260  */
1261
1262 static void gsm_control_retransmit(unsigned long data)
1263 {
1264         struct gsm_mux *gsm = (struct gsm_mux *)data;
1265         struct gsm_control *ctrl;
1266         unsigned long flags;
1267         spin_lock_irqsave(&gsm->control_lock, flags);
1268         ctrl = gsm->pending_cmd;
1269         if (ctrl) {
1270                 gsm->cretries--;
1271                 if (gsm->cretries == 0) {
1272                         gsm->pending_cmd = NULL;
1273                         ctrl->error = -ETIMEDOUT;
1274                         ctrl->done = 1;
1275                         spin_unlock_irqrestore(&gsm->control_lock, flags);
1276                         wake_up(&gsm->event);
1277                         return;
1278                 }
1279                 gsm_control_transmit(gsm, ctrl);
1280                 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1281         }
1282         spin_unlock_irqrestore(&gsm->control_lock, flags);
1283 }
1284
1285 /**
1286  *      gsm_control_send        -       send a control frame on DLCI 0
1287  *      @gsm: the GSM channel
1288  *      @command: command  to send including CR bit
1289  *      @data: bytes of data (must be kmalloced)
1290  *      @len: length of the block to send
1291  *
1292  *      Queue and dispatch a control command. Only one command can be
1293  *      active at a time. In theory more can be outstanding but the matching
1294  *      gets really complicated so for now stick to one outstanding.
1295  */
1296
1297 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1298                 unsigned int command, u8 *data, int clen)
1299 {
1300         struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1301                                                 GFP_KERNEL);
1302         unsigned long flags;
1303         if (ctrl == NULL)
1304                 return NULL;
1305 retry:
1306         wait_event(gsm->event, gsm->pending_cmd == NULL);
1307         spin_lock_irqsave(&gsm->control_lock, flags);
1308         if (gsm->pending_cmd != NULL) {
1309                 spin_unlock_irqrestore(&gsm->control_lock, flags);
1310                 goto retry;
1311         }
1312         ctrl->cmd = command;
1313         ctrl->data = data;
1314         ctrl->len = clen;
1315         gsm->pending_cmd = ctrl;
1316         gsm->cretries = gsm->n2;
1317         mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1318         gsm_control_transmit(gsm, ctrl);
1319         spin_unlock_irqrestore(&gsm->control_lock, flags);
1320         return ctrl;
1321 }
1322
1323 /**
1324  *      gsm_control_wait        -       wait for a control to finish
1325  *      @gsm: GSM mux
1326  *      @control: control we are waiting on
1327  *
1328  *      Waits for the control to complete or time out. Frees any used
1329  *      resources and returns 0 for success, or an error if the remote
1330  *      rejected or ignored the request.
1331  */
1332
1333 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1334 {
1335         int err;
1336         wait_event(gsm->event, control->done == 1);
1337         err = control->error;
1338         kfree(control);
1339         return err;
1340 }
1341
1342
1343 /*
1344  *      DLCI level handling: Needs krefs
1345  */
1346
1347 /*
1348  *      State transitions and timers
1349  */
1350
1351 /**
1352  *      gsm_dlci_close          -       a DLCI has closed
1353  *      @dlci: DLCI that closed
1354  *
1355  *      Perform processing when moving a DLCI into closed state. If there
1356  *      is an attached tty this is hung up
1357  */
1358
1359 static void gsm_dlci_close(struct gsm_dlci *dlci)
1360 {
1361         del_timer(&dlci->t1);
1362         if (debug & 8)
1363                 printk("DLCI %d goes closed.\n", dlci->addr);
1364         dlci->state = DLCI_CLOSED;
1365         if (dlci->addr != 0) {
1366                 struct tty_struct  *tty = tty_port_tty_get(&dlci->port);
1367                 if (tty) {
1368                         tty_hangup(tty);
1369                         tty_kref_put(tty);
1370                 }
1371                 kfifo_reset(dlci->fifo);
1372         } else
1373                 dlci->gsm->dead = 1;
1374         wake_up(&dlci->gsm->event);
1375         /* A DLCI 0 close is a MUX termination so we need to kick that
1376            back to userspace somehow */
1377 }
1378
1379 /**
1380  *      gsm_dlci_open           -       a DLCI has opened
1381  *      @dlci: DLCI that opened
1382  *
1383  *      Perform processing when moving a DLCI into open state.
1384  */
1385
1386 static void gsm_dlci_open(struct gsm_dlci *dlci)
1387 {
1388         /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1389            open -> open */
1390         del_timer(&dlci->t1);
1391         /* This will let a tty open continue */
1392         dlci->state = DLCI_OPEN;
1393         if (debug & 8)
1394                 printk("DLCI %d goes open.\n", dlci->addr);
1395         wake_up(&dlci->gsm->event);
1396 }
1397
1398 /**
1399  *      gsm_dlci_t1             -       T1 timer expiry
1400  *      @dlci: DLCI that opened
1401  *
1402  *      The T1 timer handles retransmits of control frames (essentially of
1403  *      SABM and DISC). We resend the command until the retry count runs out
1404  *      in which case an opening port goes back to closed and a closing port
1405  *      is simply put into closed state (any further frames from the other
1406  *      end will get a DM response)
1407  */
1408
1409 static void gsm_dlci_t1(unsigned long data)
1410 {
1411         struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1412         struct gsm_mux *gsm = dlci->gsm;
1413
1414         switch (dlci->state) {
1415         case DLCI_OPENING:
1416                 dlci->retries--;
1417                 if (dlci->retries) {
1418                         gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1419                         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1420                 } else
1421                         gsm_dlci_close(dlci);
1422                 break;
1423         case DLCI_CLOSING:
1424                 dlci->retries--;
1425                 if (dlci->retries) {
1426                         gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1427                         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1428                 } else
1429                         gsm_dlci_close(dlci);
1430                 break;
1431         }
1432 }
1433
1434 /**
1435  *      gsm_dlci_begin_open     -       start channel open procedure
1436  *      @dlci: DLCI to open
1437  *
1438  *      Commence opening a DLCI from the Linux side. We issue SABM messages
1439  *      to the modem which should then reply with a UA, at which point we
1440  *      will move into open state. Opening is done asynchronously with retry
1441  *      running off timers and the responses.
1442  */
1443
1444 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1445 {
1446         struct gsm_mux *gsm = dlci->gsm;
1447         if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1448                 return;
1449         dlci->retries = gsm->n2;
1450         dlci->state = DLCI_OPENING;
1451         gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1452         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1453 }
1454
1455 /**
1456  *      gsm_dlci_begin_close    -       start channel open procedure
1457  *      @dlci: DLCI to open
1458  *
1459  *      Commence closing a DLCI from the Linux side. We issue DISC messages
1460  *      to the modem which should then reply with a UA, at which point we
1461  *      will move into closed state. Closing is done asynchronously with retry
1462  *      off timers. We may also receive a DM reply from the other end which
1463  *      indicates the channel was already closed.
1464  */
1465
1466 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1467 {
1468         struct gsm_mux *gsm = dlci->gsm;
1469         if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1470                 return;
1471         dlci->retries = gsm->n2;
1472         dlci->state = DLCI_CLOSING;
1473         gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1474         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1475 }
1476
1477 /**
1478  *      gsm_dlci_data           -       data arrived
1479  *      @dlci: channel
1480  *      @data: block of bytes received
1481  *      @len: length of received block
1482  *
1483  *      A UI or UIH frame has arrived which contains data for a channel
1484  *      other than the control channel. If the relevant virtual tty is
1485  *      open we shovel the bits down it, if not we drop them.
1486  */
1487
1488 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
1489 {
1490         /* krefs .. */
1491         struct tty_port *port = &dlci->port;
1492         struct tty_struct *tty = tty_port_tty_get(port);
1493         unsigned int modem = 0;
1494
1495         if (debug & 16)
1496                 printk("%d bytes for tty %p\n", len, tty);
1497         if (tty) {
1498                 switch (dlci->adaption)  {
1499                         /* Unsupported types */
1500                         /* Packetised interruptible data */
1501                         case 4:
1502                                 break;
1503                         /* Packetised uininterruptible voice/data */
1504                         case 3:
1505                                 break;
1506                         /* Asynchronous serial with line state in each frame */
1507                         case 2:
1508                                 while (gsm_read_ea(&modem, *data++) == 0) {
1509                                         len--;
1510                                         if (len == 0)
1511                                                 return;
1512                                 }
1513                                 gsm_process_modem(tty, dlci, modem);
1514                         /* Line state will go via DLCI 0 controls only */
1515                         case 1:
1516                         default:
1517                                 tty_insert_flip_string(tty, data, len);
1518                                 tty_flip_buffer_push(tty);
1519                 }
1520                 tty_kref_put(tty);
1521         }
1522 }
1523
1524 /**
1525  *      gsm_dlci_control        -       data arrived on control channel
1526  *      @dlci: channel
1527  *      @data: block of bytes received
1528  *      @len: length of received block
1529  *
1530  *      A UI or UIH frame has arrived which contains data for DLCI 0 the
1531  *      control channel. This should contain a command EA followed by
1532  *      control data bytes. The command EA contains a command/response bit
1533  *      and we divide up the work accordingly.
1534  */
1535
1536 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1537 {
1538         /* See what command is involved */
1539         unsigned int command = 0;
1540         while (len-- > 0) {
1541                 if (gsm_read_ea(&command, *data++) == 1) {
1542                         int clen = *data++;
1543                         len--;
1544                         /* FIXME: this is properly an EA */
1545                         clen >>= 1;
1546                         /* Malformed command ? */
1547                         if (clen > len)
1548                                 return;
1549                         if (command & 1)
1550                                 gsm_control_message(dlci->gsm, command,
1551                                                                 data, clen);
1552                         else
1553                                 gsm_control_response(dlci->gsm, command,
1554                                                                 data, clen);
1555                         return;
1556                 }
1557         }
1558 }
1559
1560 /*
1561  *      Allocate/Free DLCI channels
1562  */
1563
1564 /**
1565  *      gsm_dlci_alloc          -       allocate a DLCI
1566  *      @gsm: GSM mux
1567  *      @addr: address of the DLCI
1568  *
1569  *      Allocate and install a new DLCI object into the GSM mux.
1570  *
1571  *      FIXME: review locking races
1572  */
1573
1574 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1575 {
1576         struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1577         if (dlci == NULL)
1578                 return NULL;
1579         spin_lock_init(&dlci->lock);
1580         dlci->fifo = &dlci->_fifo;
1581         if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1582                 kfree(dlci);
1583                 return NULL;
1584         }
1585
1586         skb_queue_head_init(&dlci->skb_list);
1587         init_timer(&dlci->t1);
1588         dlci->t1.function = gsm_dlci_t1;
1589         dlci->t1.data = (unsigned long)dlci;
1590         tty_port_init(&dlci->port);
1591         dlci->port.ops = &gsm_port_ops;
1592         dlci->gsm = gsm;
1593         dlci->addr = addr;
1594         dlci->adaption = gsm->adaption;
1595         dlci->state = DLCI_CLOSED;
1596         if (addr)
1597                 dlci->data = gsm_dlci_data;
1598         else
1599                 dlci->data = gsm_dlci_command;
1600         gsm->dlci[addr] = dlci;
1601         return dlci;
1602 }
1603
1604 /**
1605  *      gsm_dlci_free           -       release DLCI
1606  *      @dlci: DLCI to destroy
1607  *
1608  *      Free up a DLCI. Currently to keep the lifetime rules sane we only
1609  *      clean up DLCI objects when the MUX closes rather than as the port
1610  *      is closed down on both the tty and mux levels.
1611  *
1612  *      Can sleep.
1613  */
1614 static void gsm_dlci_free(struct gsm_dlci *dlci)
1615 {
1616         struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1617         if (tty) {
1618                 tty_vhangup(tty);
1619                 tty_kref_put(tty);
1620         }
1621         del_timer_sync(&dlci->t1);
1622         dlci->gsm->dlci[dlci->addr] = NULL;
1623         kfifo_free(dlci->fifo);
1624         kfree(dlci);
1625 }
1626
1627
1628 /*
1629  *      LAPBish link layer logic
1630  */
1631
1632 /**
1633  *      gsm_queue               -       a GSM frame is ready to process
1634  *      @gsm: pointer to our gsm mux
1635  *
1636  *      At this point in time a frame has arrived and been demangled from
1637  *      the line encoding. All the differences between the encodings have
1638  *      been handled below us and the frame is unpacked into the structures.
1639  *      The fcs holds the header FCS but any data FCS must be added here.
1640  */
1641
1642 static void gsm_queue(struct gsm_mux *gsm)
1643 {
1644         struct gsm_dlci *dlci;
1645         u8 cr;
1646         int address;
1647         /* We have to sneak a look at the packet body to do the FCS.
1648            A somewhat layering violation in the spec */
1649
1650         if ((gsm->control & ~PF) == UI)
1651                 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1652         if (gsm->fcs != GOOD_FCS) {
1653                 gsm->bad_fcs++;
1654                 if (debug & 4)
1655                         printk("BAD FCS %02x\n", gsm->fcs);
1656                 return;
1657         }
1658         address = gsm->address >> 1;
1659         if (address >= NUM_DLCI)
1660                 goto invalid;
1661
1662         cr = gsm->address & 1;          /* C/R bit */
1663
1664         gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1665
1666         cr ^= 1 - gsm->initiator;       /* Flip so 1 always means command */
1667         dlci = gsm->dlci[address];
1668
1669         switch (gsm->control) {
1670         case SABM|PF:
1671                 if (cr == 0)
1672                         goto invalid;
1673                 if (dlci == NULL)
1674                         dlci = gsm_dlci_alloc(gsm, address);
1675                 if (dlci == NULL)
1676                         return;
1677                 if (dlci->dead)
1678                         gsm_response(gsm, address, DM);
1679                 else {
1680                         gsm_response(gsm, address, UA);
1681                         gsm_dlci_open(dlci);
1682                 }
1683                 break;
1684         case DISC|PF:
1685                 if (cr == 0)
1686                         goto invalid;
1687                 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1688                         gsm_response(gsm, address, DM);
1689                         return;
1690                 }
1691                 /* Real close complete */
1692                 gsm_response(gsm, address, UA);
1693                 gsm_dlci_close(dlci);
1694                 break;
1695         case UA:
1696         case UA|PF:
1697                 if (cr == 0 || dlci == NULL)
1698                         break;
1699                 switch (dlci->state) {
1700                 case DLCI_CLOSING:
1701                         gsm_dlci_close(dlci);
1702                         break;
1703                 case DLCI_OPENING:
1704                         gsm_dlci_open(dlci);
1705                         break;
1706                 }
1707                 break;
1708         case DM:        /* DM can be valid unsolicited */
1709         case DM|PF:
1710                 if (cr)
1711                         goto invalid;
1712                 if (dlci == NULL)
1713                         return;
1714                 gsm_dlci_close(dlci);
1715                 break;
1716         case UI:
1717         case UI|PF:
1718         case UIH:
1719         case UIH|PF:
1720 #if 0
1721                 if (cr)
1722                         goto invalid;
1723 #endif
1724                 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1725                         gsm_command(gsm, address, DM|PF);
1726                         return;
1727                 }
1728                 dlci->data(dlci, gsm->buf, gsm->len);
1729                 break;
1730         default:
1731                 goto invalid;
1732         }
1733         return;
1734 invalid:
1735         gsm->malformed++;
1736         return;
1737 }
1738
1739
1740 /**
1741  *      gsm0_receive    -       perform processing for non-transparency
1742  *      @gsm: gsm data for this ldisc instance
1743  *      @c: character
1744  *
1745  *      Receive bytes in gsm mode 0
1746  */
1747
1748 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1749 {
1750         switch (gsm->state) {
1751         case GSM_SEARCH:        /* SOF marker */
1752                 if (c == GSM0_SOF) {
1753                         gsm->state = GSM_ADDRESS;
1754                         gsm->address = 0;
1755                         gsm->len = 0;
1756                         gsm->fcs = INIT_FCS;
1757                 }
1758                 break;          /* Address EA */
1759         case GSM_ADDRESS:
1760                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1761                 if (gsm_read_ea(&gsm->address, c))
1762                         gsm->state = GSM_CONTROL;
1763                 break;
1764         case GSM_CONTROL:       /* Control Byte */
1765                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1766                 gsm->control = c;
1767                 gsm->state = GSM_LEN;
1768                 break;
1769         case GSM_LEN:           /* Length EA */
1770                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1771                 if (gsm_read_ea(&gsm->len, c)) {
1772                         if (gsm->len > gsm->mru) {
1773                                 gsm->bad_size++;
1774                                 gsm->state = GSM_SEARCH;
1775                                 break;
1776                         }
1777                         gsm->count = 0;
1778                         gsm->state = GSM_DATA;
1779                 }
1780                 break;
1781         case GSM_DATA:          /* Data */
1782                 gsm->buf[gsm->count++] = c;
1783                 if (gsm->count == gsm->len)
1784                         gsm->state = GSM_FCS;
1785                 break;
1786         case GSM_FCS:           /* FCS follows the packet */
1787                 gsm->fcs = c;
1788                 gsm_queue(gsm);
1789                 /* And then back for the next frame */
1790                 gsm->state = GSM_SEARCH;
1791                 break;
1792         }
1793 }
1794
1795 /**
1796  *      gsm0_receive    -       perform processing for non-transparency
1797  *      @gsm: gsm data for this ldisc instance
1798  *      @c: character
1799  *
1800  *      Receive bytes in mode 1 (Advanced option)
1801  */
1802
1803 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1804 {
1805         if (c == GSM1_SOF) {
1806                 /* EOF is only valid in frame if we have got to the data state
1807                    and received at least one byte (the FCS) */
1808                 if (gsm->state == GSM_DATA && gsm->count) {
1809                         /* Extract the FCS */
1810                         gsm->count--;
1811                         gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1812                         gsm->len = gsm->count;
1813                         gsm_queue(gsm);
1814                         gsm->state  = GSM_START;
1815                         return;
1816                 }
1817                 /* Any partial frame was a runt so go back to start */
1818                 if (gsm->state != GSM_START) {
1819                         gsm->malformed++;
1820                         gsm->state = GSM_START;
1821                 }
1822                 /* A SOF in GSM_START means we are still reading idling or
1823                    framing bytes */
1824                 return;
1825         }
1826
1827         if (c == GSM1_ESCAPE) {
1828                 gsm->escape = 1;
1829                 return;
1830         }
1831
1832         /* Only an unescaped SOF gets us out of GSM search */
1833         if (gsm->state == GSM_SEARCH)
1834                 return;
1835
1836         if (gsm->escape) {
1837                 c ^= GSM1_ESCAPE_BITS;
1838                 gsm->escape = 0;
1839         }
1840         switch (gsm->state) {
1841         case GSM_START:         /* First byte after SOF */
1842                 gsm->address = 0;
1843                 gsm->state = GSM_ADDRESS;
1844                 gsm->fcs = INIT_FCS;
1845                 /* Drop through */
1846         case GSM_ADDRESS:       /* Address continuation */
1847                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1848                 if (gsm_read_ea(&gsm->address, c))
1849                         gsm->state = GSM_CONTROL;
1850                 break;
1851         case GSM_CONTROL:       /* Control Byte */
1852                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1853                 gsm->control = c;
1854                 gsm->count = 0;
1855                 gsm->state = GSM_DATA;
1856                 break;
1857         case GSM_DATA:          /* Data */
1858                 if (gsm->count > gsm->mru ) {   /* Allow one for the FCS */
1859                         gsm->state = GSM_OVERRUN;
1860                         gsm->bad_size++;
1861                 } else
1862                         gsm->buf[gsm->count++] = c;
1863                 break;
1864         case GSM_OVERRUN:       /* Over-long - eg a dropped SOF */
1865                 break;
1866         }
1867 }
1868
1869 /**
1870  *      gsm_error               -       handle tty error
1871  *      @gsm: ldisc data
1872  *      @data: byte received (may be invalid)
1873  *      @flag: error received
1874  *
1875  *      Handle an error in the receipt of data for a frame. Currently we just
1876  *      go back to hunting for a SOF.
1877  *
1878  *      FIXME: better diagnostics ?
1879  */
1880
1881 static void gsm_error(struct gsm_mux *gsm,
1882                                 unsigned char data, unsigned char flag)
1883 {
1884         gsm->state = GSM_SEARCH;
1885         gsm->io_error++;
1886 }
1887
1888 /**
1889  *      gsm_cleanup_mux         -       generic GSM protocol cleanup
1890  *      @gsm: our mux
1891  *
1892  *      Clean up the bits of the mux which are the same for all framing
1893  *      protocols. Remove the mux from the mux table, stop all the timers
1894  *      and then shut down each device hanging up the channels as we go.
1895  */
1896
1897 void gsm_cleanup_mux(struct gsm_mux *gsm)
1898 {
1899         int i;
1900         struct gsm_dlci *dlci = gsm->dlci[0];
1901         struct gsm_msg *txq;
1902
1903         gsm->dead = 1;
1904
1905         spin_lock(&gsm_mux_lock);
1906         for (i = 0; i < MAX_MUX; i++) {
1907                 if (gsm_mux[i] == gsm) {
1908                         gsm_mux[i] = NULL;
1909                         break;
1910                 }
1911         }
1912         spin_unlock(&gsm_mux_lock);
1913         WARN_ON(i == MAX_MUX);
1914
1915         del_timer_sync(&gsm->t2_timer);
1916         /* Now we are sure T2 has stopped */
1917         if (dlci) {
1918                 dlci->dead = 1;
1919                 gsm_dlci_begin_close(dlci);
1920                 wait_event_interruptible(gsm->event,
1921                                         dlci->state == DLCI_CLOSED);
1922         }
1923         /* Free up any link layer users */
1924         for (i = 0; i < NUM_DLCI; i++)
1925                 if (gsm->dlci[i])
1926                         gsm_dlci_free(gsm->dlci[i]);
1927         /* Now wipe the queues */
1928         for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1929                 gsm->tx_head = txq->next;
1930                 kfree(txq);
1931         }
1932         gsm->tx_tail = NULL;
1933 }
1934 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1935
1936 /**
1937  *      gsm_activate_mux        -       generic GSM setup
1938  *      @gsm: our mux
1939  *
1940  *      Set up the bits of the mux which are the same for all framing
1941  *      protocols. Add the mux to the mux table so it can be opened and
1942  *      finally kick off connecting to DLCI 0 on the modem.
1943  */
1944
1945 int gsm_activate_mux(struct gsm_mux *gsm)
1946 {
1947         struct gsm_dlci *dlci;
1948         int i = 0;
1949
1950         init_timer(&gsm->t2_timer);
1951         gsm->t2_timer.function = gsm_control_retransmit;
1952         gsm->t2_timer.data = (unsigned long)gsm;
1953         init_waitqueue_head(&gsm->event);
1954         spin_lock_init(&gsm->control_lock);
1955         spin_lock_init(&gsm->tx_lock);
1956
1957         if (gsm->encoding == 0)
1958                 gsm->receive = gsm0_receive;
1959         else
1960                 gsm->receive = gsm1_receive;
1961         gsm->error = gsm_error;
1962
1963         spin_lock(&gsm_mux_lock);
1964         for (i = 0; i < MAX_MUX; i++) {
1965                 if (gsm_mux[i] == NULL) {
1966                         gsm_mux[i] = gsm;
1967                         break;
1968                 }
1969         }
1970         spin_unlock(&gsm_mux_lock);
1971         if (i == MAX_MUX)
1972                 return -EBUSY;
1973
1974         dlci = gsm_dlci_alloc(gsm, 0);
1975         if (dlci == NULL)
1976                 return -ENOMEM;
1977         gsm->dead = 0;          /* Tty opens are now permissible */
1978         return 0;
1979 }
1980 EXPORT_SYMBOL_GPL(gsm_activate_mux);
1981
1982 /**
1983  *      gsm_free_mux            -       free up a mux
1984  *      @mux: mux to free
1985  *
1986  *      Dispose of allocated resources for a dead mux. No refcounting
1987  *      at present so the mux must be truely dead.
1988  */
1989 void gsm_free_mux(struct gsm_mux *gsm)
1990 {
1991         kfree(gsm->txframe);
1992         kfree(gsm->buf);
1993         kfree(gsm);
1994 }
1995 EXPORT_SYMBOL_GPL(gsm_free_mux);
1996
1997 /**
1998  *      gsm_alloc_mux           -       allocate a mux
1999  *
2000  *      Creates a new mux ready for activation.
2001  */
2002
2003 struct gsm_mux *gsm_alloc_mux(void)
2004 {
2005         struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2006         if (gsm == NULL)
2007                 return NULL;
2008         gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2009         if (gsm->buf == NULL) {
2010                 kfree(gsm);
2011                 return NULL;
2012         }
2013         gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2014         if (gsm->txframe == NULL) {
2015                 kfree(gsm->buf);
2016                 kfree(gsm);
2017                 return NULL;
2018         }
2019         spin_lock_init(&gsm->lock);
2020
2021         gsm->t1 = T1;
2022         gsm->t2 = T2;
2023         gsm->n2 = N2;
2024         gsm->ftype = UIH;
2025         gsm->initiator = 0;
2026         gsm->adaption = 1;
2027         gsm->encoding = 1;
2028         gsm->mru = 64;  /* Default to encoding 1 so these should be 64 */
2029         gsm->mtu = 64;
2030         gsm->dead = 1;  /* Avoid early tty opens */
2031
2032         return gsm;
2033 }
2034 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2035
2036
2037
2038
2039 /**
2040  *      gsmld_output            -       write to link
2041  *      @gsm: our mux
2042  *      @data: bytes to output
2043  *      @len: size
2044  *
2045  *      Write a block of data from the GSM mux to the data channel. This
2046  *      will eventually be serialized from above but at the moment isn't.
2047  */
2048
2049 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2050 {
2051         if (tty_write_room(gsm->tty) < len) {
2052                 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2053                 return -ENOSPC;
2054         }
2055         if (debug & 4) {
2056                 printk("-->%d bytes out\n", len);
2057                 hex_packet(data, len);
2058         }
2059         gsm->tty->ops->write(gsm->tty, data, len);
2060         return len;
2061 }
2062
2063 /**
2064  *      gsmld_attach_gsm        -       mode set up
2065  *      @tty: our tty structure
2066  *      @gsm: our mux
2067  *
2068  *      Set up the MUX for basic mode and commence connecting to the
2069  *      modem. Currently called from the line discipline set up but
2070  *      will need moving to an ioctl path.
2071  */
2072
2073 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2074 {
2075         int ret;
2076
2077         gsm->tty = tty_kref_get(tty);
2078         gsm->output = gsmld_output;
2079         ret =  gsm_activate_mux(gsm);
2080         if (ret != 0)
2081                 tty_kref_put(gsm->tty);
2082         return ret;
2083 }
2084
2085
2086 /**
2087  *      gsmld_detach_gsm        -       stop doing 0710 mux
2088  *      @tty: tty atttached to the mux
2089  *      @gsm: mux
2090  *
2091  *      Shutdown and then clean up the resources used by the line discipline
2092  */
2093
2094 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2095 {
2096         WARN_ON(tty != gsm->tty);
2097         gsm_cleanup_mux(gsm);
2098         tty_kref_put(gsm->tty);
2099         gsm->tty = NULL;
2100 }
2101
2102 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2103                               char *fp, int count)
2104 {
2105         struct gsm_mux *gsm = tty->disc_data;
2106         const unsigned char *dp;
2107         char *f;
2108         int i;
2109         char buf[64];
2110         char flags;
2111
2112         if (debug & 4) {
2113                 printk("Inbytes %dd\n", count);
2114                 hex_packet(cp, count);
2115         }
2116
2117         for (i = count, dp = cp, f = fp; i; i--, dp++) {
2118                 flags = *f++;
2119                 switch (flags) {
2120                 case TTY_NORMAL:
2121                         gsm->receive(gsm, *dp);
2122                         break;
2123                 case TTY_OVERRUN:
2124                 case TTY_BREAK:
2125                 case TTY_PARITY:
2126                 case TTY_FRAME:
2127                         gsm->error(gsm, *dp, flags);
2128                         break;
2129                 default:
2130                         printk(KERN_ERR "%s: unknown flag %d\n",
2131                                tty_name(tty, buf), flags);
2132                         break;
2133                 }
2134         }
2135         /* FASYNC if needed ? */
2136         /* If clogged call tty_throttle(tty); */
2137 }
2138
2139 /**
2140  *      gsmld_chars_in_buffer   -       report available bytes
2141  *      @tty: tty device
2142  *
2143  *      Report the number of characters buffered to be delivered to user
2144  *      at this instant in time.
2145  *
2146  *      Locking: gsm lock
2147  */
2148
2149 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2150 {
2151         return 0;
2152 }
2153
2154 /**
2155  *      gsmld_flush_buffer      -       clean input queue
2156  *      @tty:   terminal device
2157  *
2158  *      Flush the input buffer. Called when the line discipline is
2159  *      being closed, when the tty layer wants the buffer flushed (eg
2160  *      at hangup).
2161  */
2162
2163 static void gsmld_flush_buffer(struct tty_struct *tty)
2164 {
2165 }
2166
2167 /**
2168  *      gsmld_close             -       close the ldisc for this tty
2169  *      @tty: device
2170  *
2171  *      Called from the terminal layer when this line discipline is
2172  *      being shut down, either because of a close or becsuse of a
2173  *      discipline change. The function will not be called while other
2174  *      ldisc methods are in progress.
2175  */
2176
2177 static void gsmld_close(struct tty_struct *tty)
2178 {
2179         struct gsm_mux *gsm = tty->disc_data;
2180
2181         gsmld_detach_gsm(tty, gsm);
2182
2183         gsmld_flush_buffer(tty);
2184         /* Do other clean up here */
2185         gsm_free_mux(gsm);
2186 }
2187
2188 /**
2189  *      gsmld_open              -       open an ldisc
2190  *      @tty: terminal to open
2191  *
2192  *      Called when this line discipline is being attached to the
2193  *      terminal device. Can sleep. Called serialized so that no
2194  *      other events will occur in parallel. No further open will occur
2195  *      until a close.
2196  */
2197
2198 static int gsmld_open(struct tty_struct *tty)
2199 {
2200         struct gsm_mux *gsm;
2201
2202         if (tty->ops->write == NULL)
2203                 return -EINVAL;
2204
2205         /* Attach our ldisc data */
2206         gsm = gsm_alloc_mux();
2207         if (gsm == NULL)
2208                 return -ENOMEM;
2209
2210         tty->disc_data = gsm;
2211         tty->receive_room = 65536;
2212
2213         /* Attach the initial passive connection */
2214         gsm->encoding = 1;
2215         return gsmld_attach_gsm(tty, gsm);
2216 }
2217
2218 /**
2219  *      gsmld_write_wakeup      -       asynchronous I/O notifier
2220  *      @tty: tty device
2221  *
2222  *      Required for the ptys, serial driver etc. since processes
2223  *      that attach themselves to the master and rely on ASYNC
2224  *      IO must be woken up
2225  */
2226
2227 static void gsmld_write_wakeup(struct tty_struct *tty)
2228 {
2229         struct gsm_mux *gsm = tty->disc_data;
2230         unsigned long flags;
2231
2232         /* Queue poll */
2233         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2234         gsm_data_kick(gsm);
2235         if (gsm->tx_bytes < TX_THRESH_LO) {
2236                 spin_lock_irqsave(&gsm->tx_lock, flags);
2237                 gsm_dlci_data_sweep(gsm);
2238                 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2239         }
2240 }
2241
2242 /**
2243  *      gsmld_read              -       read function for tty
2244  *      @tty: tty device
2245  *      @file: file object
2246  *      @buf: userspace buffer pointer
2247  *      @nr: size of I/O
2248  *
2249  *      Perform reads for the line discipline. We are guaranteed that the
2250  *      line discipline will not be closed under us but we may get multiple
2251  *      parallel readers and must handle this ourselves. We may also get
2252  *      a hangup. Always called in user context, may sleep.
2253  *
2254  *      This code must be sure never to sleep through a hangup.
2255  */
2256
2257 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2258                          unsigned char __user *buf, size_t nr)
2259 {
2260         return -EOPNOTSUPP;
2261 }
2262
2263 /**
2264  *      gsmld_write             -       write function for tty
2265  *      @tty: tty device
2266  *      @file: file object
2267  *      @buf: userspace buffer pointer
2268  *      @nr: size of I/O
2269  *
2270  *      Called when the owner of the device wants to send a frame
2271  *      itself (or some other control data). The data is transferred
2272  *      as-is and must be properly framed and checksummed as appropriate
2273  *      by userspace. Frames are either sent whole or not at all as this
2274  *      avoids pain user side.
2275  */
2276
2277 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2278                            const unsigned char *buf, size_t nr)
2279 {
2280         int space = tty_write_room(tty);
2281         if (space >= nr)
2282                 return tty->ops->write(tty, buf, nr);
2283         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2284         return -ENOBUFS;
2285 }
2286
2287 /**
2288  *      gsmld_poll              -       poll method for N_GSM0710
2289  *      @tty: terminal device
2290  *      @file: file accessing it
2291  *      @wait: poll table
2292  *
2293  *      Called when the line discipline is asked to poll() for data or
2294  *      for special events. This code is not serialized with respect to
2295  *      other events save open/close.
2296  *
2297  *      This code must be sure never to sleep through a hangup.
2298  *      Called without the kernel lock held - fine
2299  */
2300
2301 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2302                                                         poll_table *wait)
2303 {
2304         unsigned int mask = 0;
2305         struct gsm_mux *gsm = tty->disc_data;
2306
2307         poll_wait(file, &tty->read_wait, wait);
2308         poll_wait(file, &tty->write_wait, wait);
2309         if (tty_hung_up_p(file))
2310                 mask |= POLLHUP;
2311         if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2312                 mask |= POLLOUT | POLLWRNORM;
2313         if (gsm->dead)
2314                 mask |= POLLHUP;
2315         return mask;
2316 }
2317
2318 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2319                                                         struct gsm_config *c)
2320 {
2321         int need_close = 0;
2322         int need_restart = 0;
2323
2324         /* Stuff we don't support yet - UI or I frame transport, windowing */
2325         if ((c->adaption !=1 && c->adaption != 2) || c->k)
2326                 return -EOPNOTSUPP;
2327         /* Check the MRU/MTU range looks sane */
2328         if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2329                 return -EINVAL;
2330         if (c->n2 < 3)
2331                 return -EINVAL;
2332         if (c->encapsulation > 1)       /* Basic, advanced, no I */
2333                 return -EINVAL;
2334         if (c->initiator > 1)
2335                 return -EINVAL;
2336         if (c->i == 0 || c->i > 2)      /* UIH and UI only */
2337                 return -EINVAL;
2338         /*
2339          *      See what is needed for reconfiguration
2340          */
2341
2342         /* Timing fields */
2343         if (c->t1 != 0 && c->t1 != gsm->t1)
2344                 need_restart = 1;
2345         if (c->t2 != 0 && c->t2 != gsm->t2)
2346                 need_restart = 1;
2347         if (c->encapsulation != gsm->encoding)
2348                 need_restart = 1;
2349         if (c->adaption != gsm->adaption)
2350                 need_restart = 1;
2351         /* Requires care */
2352         if (c->initiator != gsm->initiator)
2353                 need_close = 1;
2354         if (c->mru != gsm->mru)
2355                 need_restart = 1;
2356         if (c->mtu != gsm->mtu)
2357                 need_restart = 1;
2358
2359         /*
2360          *      Close down what is needed, restart and initiate the new
2361          *      configuration
2362          */
2363
2364         if (need_close || need_restart) {
2365                 gsm_dlci_begin_close(gsm->dlci[0]);
2366                 /* This will timeout if the link is down due to N2 expiring */
2367                 wait_event_interruptible(gsm->event,
2368                                 gsm->dlci[0]->state == DLCI_CLOSED);
2369                 if (signal_pending(current))
2370                         return -EINTR;
2371         }
2372         if (need_restart)
2373                 gsm_cleanup_mux(gsm);
2374
2375         gsm->initiator = c->initiator;
2376         gsm->mru = c->mru;
2377         gsm->encoding = c->encapsulation;
2378         gsm->adaption = c->adaption;
2379
2380         if (c->i == 1)
2381                 gsm->ftype = UIH;
2382         else if (c->i == 2)
2383                 gsm->ftype = UI;
2384
2385         if (c->t1)
2386                 gsm->t1 = c->t1;
2387         if (c->t2)
2388                 gsm->t2 = c->t2;
2389
2390         /* FIXME: We need to separate activation/deactivation from adding
2391            and removing from the mux array */
2392         if (need_restart)
2393                 gsm_activate_mux(gsm);
2394         if (gsm->initiator && need_close)
2395                 gsm_dlci_begin_open(gsm->dlci[0]);
2396         return 0;
2397 }
2398
2399 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2400                        unsigned int cmd, unsigned long arg)
2401 {
2402         struct gsm_config c;
2403         struct gsm_mux *gsm = tty->disc_data;
2404
2405         switch (cmd) {
2406         case GSMIOC_GETCONF:
2407                 memset(&c, 0, sizeof(c));
2408                 c.adaption = gsm->adaption;
2409                 c.encapsulation = gsm->encoding;
2410                 c.initiator = gsm->initiator;
2411                 c.t1 = gsm->t1;
2412                 c.t2 = gsm->t2;
2413                 c.t3 = 0;       /* Not supported */
2414                 c.n2 = gsm->n2;
2415                 if (gsm->ftype == UIH)
2416                         c.i = 1;
2417                 else
2418                         c.i = 2;
2419                 printk("Ftype %d i %d\n", gsm->ftype, c.i);
2420                 c.mru = gsm->mru;
2421                 c.mtu = gsm->mtu;
2422                 c.k = 0;
2423                 if (copy_to_user((void *)arg, &c, sizeof(c)))
2424                         return -EFAULT;
2425                 return 0;
2426         case GSMIOC_SETCONF:
2427                 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2428                         return -EFAULT;
2429                 return gsmld_config(tty, gsm, &c);
2430         default:
2431                 return n_tty_ioctl_helper(tty, file, cmd, arg);
2432         }
2433 }
2434
2435
2436 /* Line discipline for real tty */
2437 struct tty_ldisc_ops tty_ldisc_packet = {
2438         .owner           = THIS_MODULE,
2439         .magic           = TTY_LDISC_MAGIC,
2440         .name            = "n_gsm",
2441         .open            = gsmld_open,
2442         .close           = gsmld_close,
2443         .flush_buffer    = gsmld_flush_buffer,
2444         .chars_in_buffer = gsmld_chars_in_buffer,
2445         .read            = gsmld_read,
2446         .write           = gsmld_write,
2447         .ioctl           = gsmld_ioctl,
2448         .poll            = gsmld_poll,
2449         .receive_buf     = gsmld_receive_buf,
2450         .write_wakeup    = gsmld_write_wakeup
2451 };
2452
2453 /*
2454  *      Virtual tty side
2455  */
2456
2457 #define TX_SIZE         512
2458
2459 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2460 {
2461         u8 modembits[5];
2462         struct gsm_control *ctrl;
2463         int len = 2;
2464
2465         if (brk)
2466                 len++;
2467
2468         modembits[0] = len << 1 | EA;           /* Data bytes */
2469         modembits[1] = dlci->addr << 2 | 3;     /* DLCI, EA, 1 */
2470         modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2471         if (brk)
2472                 modembits[3] = brk << 4 | 2 | EA;       /* Valid, EA */
2473         ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2474         if (ctrl == NULL)
2475                 return -ENOMEM;
2476         return gsm_control_wait(dlci->gsm, ctrl);
2477 }
2478
2479 static int gsm_carrier_raised(struct tty_port *port)
2480 {
2481         struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2482         /* Not yet open so no carrier info */
2483         if (dlci->state != DLCI_OPEN)
2484                 return 0;
2485         if (debug & 2)
2486                 return 1;
2487         return dlci->modem_rx & TIOCM_CD;
2488 }
2489
2490 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2491 {
2492         struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2493         unsigned int modem_tx = dlci->modem_tx;
2494         if (onoff)
2495                 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2496         else
2497                 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2498         if (modem_tx != dlci->modem_tx) {
2499                 dlci->modem_tx = modem_tx;
2500                 gsmtty_modem_update(dlci, 0);
2501         }
2502 }
2503
2504 static const struct tty_port_operations gsm_port_ops = {
2505         .carrier_raised = gsm_carrier_raised,
2506         .dtr_rts = gsm_dtr_rts,
2507 };
2508
2509
2510 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2511 {
2512         struct gsm_mux *gsm;
2513         struct gsm_dlci *dlci;
2514         struct tty_port *port;
2515         unsigned int line = tty->index;
2516         unsigned int mux = line >> 6;
2517
2518         line = line & 0x3F;
2519
2520         if (mux >= MAX_MUX)
2521                 return -ENXIO;
2522         /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2523         if (gsm_mux[mux] == NULL)
2524                 return -EUNATCH;
2525         if (line == 0 || line > 61)     /* 62/63 reserved */
2526                 return -ECHRNG;
2527         gsm = gsm_mux[mux];
2528         if (gsm->dead)
2529                 return -EL2HLT;
2530         dlci = gsm->dlci[line];
2531         if (dlci == NULL)
2532                 dlci = gsm_dlci_alloc(gsm, line);
2533         if (dlci == NULL)
2534                 return -ENOMEM;
2535         port = &dlci->port;
2536         port->count++;
2537         tty->driver_data = dlci;
2538         tty_port_tty_set(port, tty);
2539
2540         dlci->modem_rx = 0;
2541         /* We could in theory open and close before we wait - eg if we get
2542            a DM straight back. This is ok as that will have caused a hangup */
2543         set_bit(ASYNCB_INITIALIZED, &port->flags);
2544         /* Start sending off SABM messages */
2545         gsm_dlci_begin_open(dlci);
2546         /* And wait for virtual carrier */
2547         return tty_port_block_til_ready(port, tty, filp);
2548 }
2549
2550 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2551 {
2552         struct gsm_dlci *dlci = tty->driver_data;
2553         if (dlci == NULL)
2554                 return;
2555         if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2556                 return;
2557         gsm_dlci_begin_close(dlci);
2558         tty_port_close_end(&dlci->port, tty);
2559         tty_port_tty_set(&dlci->port, NULL);
2560 }
2561
2562 static void gsmtty_hangup(struct tty_struct *tty)
2563 {
2564         struct gsm_dlci *dlci = tty->driver_data;
2565         tty_port_hangup(&dlci->port);
2566         gsm_dlci_begin_close(dlci);
2567 }
2568
2569 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2570                                                                     int len)
2571 {
2572         struct gsm_dlci *dlci = tty->driver_data;
2573         /* Stuff the bytes into the fifo queue */
2574         int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2575         /* Need to kick the channel */
2576         gsm_dlci_data_kick(dlci);
2577         return sent;
2578 }
2579
2580 static int gsmtty_write_room(struct tty_struct *tty)
2581 {
2582         struct gsm_dlci *dlci = tty->driver_data;
2583         return TX_SIZE - kfifo_len(dlci->fifo);
2584 }
2585
2586 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2587 {
2588         struct gsm_dlci *dlci = tty->driver_data;
2589         return kfifo_len(dlci->fifo);
2590 }
2591
2592 static void gsmtty_flush_buffer(struct tty_struct *tty)
2593 {
2594         struct gsm_dlci *dlci = tty->driver_data;
2595         /* Caution needed: If we implement reliable transport classes
2596            then the data being transmitted can't simply be junked once
2597            it has first hit the stack. Until then we can just blow it
2598            away */
2599         kfifo_reset(dlci->fifo);
2600         /* Need to unhook this DLCI from the transmit queue logic */
2601 }
2602
2603 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2604 {
2605         /* The FIFO handles the queue so the kernel will do the right
2606            thing waiting on chars_in_buffer before calling us. No work
2607            to do here */
2608 }
2609
2610 static int gsmtty_tiocmget(struct tty_struct *tty, struct file *filp)
2611 {
2612         struct gsm_dlci *dlci = tty->driver_data;
2613         return dlci->modem_rx;
2614 }
2615
2616 static int gsmtty_tiocmset(struct tty_struct *tty, struct file *filp,
2617         unsigned int set, unsigned int clear)
2618 {
2619         struct gsm_dlci *dlci = tty->driver_data;
2620         unsigned int modem_tx = dlci->modem_tx;
2621
2622         modem_tx &= clear;
2623         modem_tx |= set;
2624
2625         if (modem_tx != dlci->modem_tx) {
2626                 dlci->modem_tx = modem_tx;
2627                 return gsmtty_modem_update(dlci, 0);
2628         }
2629         return 0;
2630 }
2631
2632
2633 static int gsmtty_ioctl(struct tty_struct *tty, struct file *filp,
2634                         unsigned int cmd, unsigned long arg)
2635 {
2636         return -ENOIOCTLCMD;
2637 }
2638
2639 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2640 {
2641         /* For the moment its fixed. In actual fact the speed information
2642            for the virtual channel can be propogated in both directions by
2643            the RPN control message. This however rapidly gets nasty as we
2644            then have to remap modem signals each way according to whether
2645            our virtual cable is null modem etc .. */
2646         tty_termios_copy_hw(tty->termios, old);
2647 }
2648
2649 static void gsmtty_throttle(struct tty_struct *tty)
2650 {
2651         struct gsm_dlci *dlci = tty->driver_data;
2652         if (tty->termios->c_cflag & CRTSCTS)
2653                 dlci->modem_tx &= ~TIOCM_DTR;
2654         dlci->throttled = 1;
2655         /* Send an MSC with DTR cleared */
2656         gsmtty_modem_update(dlci, 0);
2657 }
2658
2659 static void gsmtty_unthrottle(struct tty_struct *tty)
2660 {
2661         struct gsm_dlci *dlci = tty->driver_data;
2662         if (tty->termios->c_cflag & CRTSCTS)
2663                 dlci->modem_tx |= TIOCM_DTR;
2664         dlci->throttled = 0;
2665         /* Send an MSC with DTR set */
2666         gsmtty_modem_update(dlci, 0);
2667 }
2668
2669 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2670 {
2671         struct gsm_dlci *dlci = tty->driver_data;
2672         int encode = 0; /* Off */
2673
2674         if (state == -1)        /* "On indefinitely" - we can't encode this
2675                                     properly */
2676                 encode = 0x0F;
2677         else if (state > 0) {
2678                 encode = state / 200;   /* mS to encoding */
2679                 if (encode > 0x0F)
2680                         encode = 0x0F;  /* Best effort */
2681         }
2682         return gsmtty_modem_update(dlci, encode);
2683 }
2684
2685 static struct tty_driver *gsm_tty_driver;
2686
2687 /* Virtual ttys for the demux */
2688 static const struct tty_operations gsmtty_ops = {
2689         .open                   = gsmtty_open,
2690         .close                  = gsmtty_close,
2691         .write                  = gsmtty_write,
2692         .write_room             = gsmtty_write_room,
2693         .chars_in_buffer        = gsmtty_chars_in_buffer,
2694         .flush_buffer           = gsmtty_flush_buffer,
2695         .ioctl                  = gsmtty_ioctl,
2696         .throttle               = gsmtty_throttle,
2697         .unthrottle             = gsmtty_unthrottle,
2698         .set_termios            = gsmtty_set_termios,
2699         .hangup                 = gsmtty_hangup,
2700         .wait_until_sent        = gsmtty_wait_until_sent,
2701         .tiocmget               = gsmtty_tiocmget,
2702         .tiocmset               = gsmtty_tiocmset,
2703         .break_ctl              = gsmtty_break_ctl,
2704 };
2705
2706
2707
2708 static int __init gsm_init(void)
2709 {
2710         /* Fill in our line protocol discipline, and register it */
2711         int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2712         if (status != 0) {
2713                 printk(KERN_ERR "n_gsm: can't register line discipline (err = %d)\n", status);
2714                 return status;
2715         }
2716
2717         gsm_tty_driver = alloc_tty_driver(256);
2718         if (!gsm_tty_driver) {
2719                 tty_unregister_ldisc(N_GSM0710);
2720                 printk(KERN_ERR "gsm_init: tty allocation failed.\n");
2721                 return -EINVAL;
2722         }
2723         gsm_tty_driver->owner   = THIS_MODULE;
2724         gsm_tty_driver->driver_name     = "gsmtty";
2725         gsm_tty_driver->name            = "gsmtty";
2726         gsm_tty_driver->major           = 0;    /* Dynamic */
2727         gsm_tty_driver->minor_start     = 0;
2728         gsm_tty_driver->type            = TTY_DRIVER_TYPE_SERIAL;
2729         gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2730         gsm_tty_driver->flags   = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2731                                                         | TTY_DRIVER_HARDWARE_BREAK;
2732         gsm_tty_driver->init_termios    = tty_std_termios;
2733         /* Fixme */
2734         gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2735         tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2736
2737         spin_lock_init(&gsm_mux_lock);
2738
2739         if (tty_register_driver(gsm_tty_driver)) {
2740                 put_tty_driver(gsm_tty_driver);
2741                 tty_unregister_ldisc(N_GSM0710);
2742                 printk(KERN_ERR "gsm_init: tty registration failed.\n");
2743                 return -EBUSY;
2744         }
2745         printk(KERN_INFO "gsm_init: loaded as %d,%d.\n", gsm_tty_driver->major, gsm_tty_driver->minor_start);
2746         return 0;
2747 }
2748
2749 static void __exit gsm_exit(void)
2750 {
2751         int status = tty_unregister_ldisc(N_GSM0710);
2752         if (status != 0)
2753                 printk(KERN_ERR "n_gsm: can't unregister line discipline (err = %d)\n", status);
2754         tty_unregister_driver(gsm_tty_driver);
2755         put_tty_driver(gsm_tty_driver);
2756         printk(KERN_INFO "gsm_init: unloaded.\n");
2757 }
2758
2759 module_init(gsm_init);
2760 module_exit(gsm_exit);
2761
2762
2763 MODULE_LICENSE("GPL");
2764 MODULE_ALIAS_LDISC(N_GSM0710);